km_openssl/wrapped_key.cpp

/*
 * 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/attestation_record.h>
#include <keymaster/logger.h>
#include <keymaster/wrapped_key.h>

#include <openssl/asn1t.h>

#include <keymaster/android_keymaster_utils.h>
#include <keymaster/km_openssl/openssl_err.h>
#include <keymaster/km_openssl/openssl_utils.h>

namespace keymaster {

IMPLEMENT_ASN1_FUNCTIONS(KM_WRAPPED_KEY_DESCRIPTION);
IMPLEMENT_ASN1_FUNCTIONS(KM_WRAPPED_KEY);

struct KM_WRAPPED_KEY_Delete {
    void operator()(KM_WRAPPED_KEY* p) { KM_WRAPPED_KEY_free(p); }
};

struct KM_WRAPPED_KEY_DESCRIPTION_Delete {
    void operator()(KM_WRAPPED_KEY_DESCRIPTION* p) { KM_WRAPPED_KEY_DESCRIPTION_free(p); }
};

// DER encode a wrapped key for secure import
keymaster_error_t build_wrapped_key(const KeymasterKeyBlob& transit_key, const KeymasterBlob& iv,
                                    keymaster_key_format_t key_format,
                                    const KeymasterKeyBlob& secure_key, const KeymasterBlob& tag,
                                    const AuthorizationSet& auth_set,
                                    KeymasterKeyBlob* der_wrapped_key) {
    UniquePtr<KM_WRAPPED_KEY, KM_WRAPPED_KEY_Delete> wrapped_key(KM_WRAPPED_KEY_new());
    if (!wrapped_key.get()) return KM_ERROR_MEMORY_ALLOCATION_FAILED;

    if (!ASN1_OCTET_STRING_set(wrapped_key->transit_key, transit_key.key_material,
                               transit_key.key_material_size) ||
        !ASN1_OCTET_STRING_set(wrapped_key->iv, iv.data, iv.data_length) ||
        !ASN1_OCTET_STRING_set(wrapped_key->secure_key, secure_key.key_material,
                               secure_key.key_material_size) ||
        !ASN1_OCTET_STRING_set(wrapped_key->tag, tag.data, tag.data_length) ||
        !ASN1_INTEGER_set(wrapped_key->wrapped_key_description->key_format, key_format)) {
        return TranslateLastOpenSslError();
    }

    auto err = build_auth_list(auth_set, wrapped_key->wrapped_key_description->auth_list);
    if (err != KM_ERROR_OK) {
        return err;
    }

    int len = i2d_KM_WRAPPED_KEY(wrapped_key.get(), nullptr);
    if (len < 0) {
        return TranslateLastOpenSslError();
    }
    if (!der_wrapped_key->Reset(len)) {
        return KM_ERROR_MEMORY_ALLOCATION_FAILED;
    }

    uint8_t* p = der_wrapped_key->writable_data();
    len = i2d_KM_WRAPPED_KEY(wrapped_key.get(), &p);
    if (len < 0) {
        return TranslateLastOpenSslError();
    }

    return KM_ERROR_OK;
}

// Parse the DER-encoded wrapped key format
keymaster_error_t parse_wrapped_key(const KeymasterKeyBlob& wrapped_key, KeymasterBlob* iv,
                                    KeymasterKeyBlob* transit_key, KeymasterKeyBlob* secure_key,
                                    KeymasterBlob* tag, AuthorizationSet* auth_list,
                                    keymaster_key_format_t* key_format,
                                    KeymasterBlob* wrapped_key_description) {
    if (!iv || !transit_key || !secure_key || !tag || !auth_list || !key_format ||
        !wrapped_key_description) {
        return KM_ERROR_UNEXPECTED_NULL_POINTER;
    }

    const uint8_t* tmp = wrapped_key.key_material;
    UniquePtr<KM_WRAPPED_KEY, KM_WRAPPED_KEY_Delete> record(
        d2i_KM_WRAPPED_KEY(nullptr, &tmp, wrapped_key.key_material_size));
    if (!record.get()) return TranslateLastOpenSslError();

    *iv = KeymasterBlob(record->iv->data, record->iv->length);
    if (record->iv->data && !iv->data) {
        return KM_ERROR_MEMORY_ALLOCATION_FAILED;
    }

    *transit_key = KeymasterKeyBlob(record->transit_key->data, record->transit_key->length);
    if (record->transit_key->data && !transit_key->key_material) {
        return KM_ERROR_MEMORY_ALLOCATION_FAILED;
    }

    *secure_key = KeymasterKeyBlob(record->secure_key->data, record->secure_key->length);
    if (record->secure_key->data && !secure_key->key_material) {
        return KM_ERROR_MEMORY_ALLOCATION_FAILED;
    }

    *tag = KeymasterBlob(record->tag->data, record->tag->length);
    if (record->tag->data && !tag->data) {
        return KM_ERROR_MEMORY_ALLOCATION_FAILED;
    }

    // Re-serialize the wrapped key description
    int len = i2d_KM_WRAPPED_KEY_DESCRIPTION(record->wrapped_key_description, nullptr);
    if (len < 0) {
        return TranslateLastOpenSslError();
    }
    if (!wrapped_key_description->Reset(len)) {
        return KM_ERROR_MEMORY_ALLOCATION_FAILED;
    }
    uint8_t* p = wrapped_key_description->writable_data();
    if (i2d_KM_WRAPPED_KEY_DESCRIPTION(record->wrapped_key_description, &p) < 0) {
        return TranslateLastOpenSslError();
    }

    *key_format = static_cast<keymaster_key_format_t>(
        ASN1_INTEGER_get(record->wrapped_key_description->key_format));
    return extract_auth_list(record->wrapped_key_description->auth_list, auth_list);
}

}  // namespace keymaster