/*
**
** Copyright 2017, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

#include <keymaster/legacy_support/keymaster_passthrough_key.h>

namespace keymaster {

keymaster_error_t KeymasterPassthroughKeyFactory::LoadKey(KeymasterKeyBlob&& key_material,
                                                          const AuthorizationSet& additional_params,
                                                          AuthorizationSet&& hw_enforced,
                                                          AuthorizationSet&& sw_enforced,
                                                          UniquePtr<Key>* key) const {
    keymaster_error_t error = KM_ERROR_OK;
    if (!key) return KM_ERROR_OUTPUT_PARAMETER_NULL;

    key->reset(new (std::nothrow)
                   KeymasterPassthroughKey(move(key_material), move(hw_enforced), move(sw_enforced),
                                           this, &error, additional_params, engine_));
    if (!key->get()) error = KM_ERROR_MEMORY_ALLOCATION_FAILED;

    return error;
}

const keymaster_key_format_t*
KeymasterPassthroughKeyFactory::SupportedImportFormats(size_t* format_count) const {
    if (format_count) *format_count = 0;
    return nullptr;
}
const keymaster_key_format_t*
KeymasterPassthroughKeyFactory::SupportedExportFormats(size_t* format_count) const {
    if (format_count) *format_count = 0;
    return nullptr;
}

keymaster_error_t KeymasterPassthroughKey::formatted_key_material(keymaster_key_format_t format,
                                                                  UniquePtr<uint8_t[]>* material,
                                                                  size_t* size) const {
    if (!material || !size) {
        return KM_ERROR_OUTPUT_PARAMETER_NULL;
    }
    keymaster_blob_t km_app_data = {};
    KeymasterBlob app_data;
    if (additional_parameters_.GetTagValue(TAG_APPLICATION_DATA, &km_app_data)) {
        app_data = KeymasterBlob(km_app_data);
    }

    keymaster_blob_t km_client_id = {};
    KeymasterBlob client_id;
    if (additional_parameters_.GetTagValue(TAG_APPLICATION_ID, &km_client_id)) {
        client_id = KeymasterBlob(km_client_id);
    }

    KeymasterBlob export_data;

    keymaster_error_t error =
        engine_->ExportKey(format, key_material(), client_id, app_data, &export_data);
    if (error == KM_ERROR_OK) {
        keymaster_blob_t export_blob = export_data.release();
        material->reset(const_cast<uint8_t*>(export_blob.data));
        *size = export_blob.data_length;
    }
    return error;
}

}  // namespace keymaster