| /* |
| * Copyright 2014 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 <assert.h> |
| #include <string.h> |
| |
| #include <cstddef> |
| |
| #include <openssl/rand.h> |
| #include <openssl/x509.h> |
| |
| #include <UniquePtr.h> |
| |
| #include <keymaster/google_keymaster.h> |
| #include <keymaster/google_keymaster_utils.h> |
| #include <keymaster/key_blob.h> |
| |
| #include "ae.h" |
| #include "key.h" |
| #include "operation.h" |
| |
| namespace keymaster { |
| |
| GoogleKeymaster::GoogleKeymaster(size_t operation_table_size, Logger* logger) |
| : operation_table_(new OpTableEntry[operation_table_size]), |
| operation_table_size_(operation_table_size), logger_(logger) { |
| if (operation_table_.get() == NULL) |
| operation_table_size_ = 0; |
| } |
| GoogleKeymaster::~GoogleKeymaster() { |
| for (size_t i = 0; i < operation_table_size_; ++i) |
| if (operation_table_[i].operation != NULL) |
| delete operation_table_[i].operation; |
| } |
| |
| struct AE_CTX_Delete { |
| void operator()(ae_ctx* ctx) const { ae_free(ctx); } |
| }; |
| typedef UniquePtr<ae_ctx, AE_CTX_Delete> Unique_ae_ctx; |
| |
| keymaster_algorithm_t supported_algorithms[] = { |
| KM_ALGORITHM_RSA, KM_ALGORITHM_DSA, KM_ALGORITHM_ECDSA, |
| }; |
| |
| template <typename T> |
| bool check_supported(keymaster_algorithm_t algorithm, SupportedResponse<T>* response) { |
| if (!array_contains(supported_algorithms, algorithm)) { |
| response->error = KM_ERROR_UNSUPPORTED_ALGORITHM; |
| return false; |
| } |
| return true; |
| } |
| |
| void |
| GoogleKeymaster::SupportedAlgorithms(SupportedResponse<keymaster_algorithm_t>* response) const { |
| if (response == NULL) |
| return; |
| response->SetResults(supported_algorithms); |
| } |
| |
| void |
| GoogleKeymaster::SupportedBlockModes(keymaster_algorithm_t algorithm, |
| SupportedResponse<keymaster_block_mode_t>* response) const { |
| if (response == NULL || !check_supported(algorithm, response)) |
| return; |
| response->error = KM_ERROR_OK; |
| } |
| |
| keymaster_padding_t supported_padding[] = {KM_PAD_NONE}; |
| void |
| GoogleKeymaster::SupportedPaddingModes(keymaster_algorithm_t algorithm, |
| SupportedResponse<keymaster_padding_t>* response) const { |
| if (response == NULL || !check_supported(algorithm, response)) |
| return; |
| |
| response->error = KM_ERROR_OK; |
| switch (algorithm) { |
| case KM_ALGORITHM_RSA: |
| case KM_ALGORITHM_DSA: |
| case KM_ALGORITHM_ECDSA: |
| response->SetResults(supported_padding); |
| break; |
| default: |
| response->results_length = 0; |
| break; |
| } |
| } |
| |
| keymaster_digest_t supported_digests[] = {KM_DIGEST_NONE}; |
| void GoogleKeymaster::SupportedDigests(keymaster_algorithm_t algorithm, |
| SupportedResponse<keymaster_digest_t>* response) const { |
| if (response == NULL || !check_supported(algorithm, response)) |
| return; |
| |
| response->error = KM_ERROR_OK; |
| switch (algorithm) { |
| case KM_ALGORITHM_RSA: |
| case KM_ALGORITHM_DSA: |
| case KM_ALGORITHM_ECDSA: |
| response->SetResults(supported_digests); |
| break; |
| default: |
| response->results_length = 0; |
| break; |
| } |
| } |
| |
| keymaster_key_format_t supported_import_formats[] = {KM_KEY_FORMAT_PKCS8}; |
| void |
| GoogleKeymaster::SupportedImportFormats(keymaster_algorithm_t algorithm, |
| SupportedResponse<keymaster_key_format_t>* response) const { |
| if (response == NULL || !check_supported(algorithm, response)) |
| return; |
| |
| response->error = KM_ERROR_OK; |
| switch (algorithm) { |
| case KM_ALGORITHM_RSA: |
| case KM_ALGORITHM_DSA: |
| case KM_ALGORITHM_ECDSA: |
| response->SetResults(supported_import_formats); |
| break; |
| default: |
| response->results_length = 0; |
| break; |
| } |
| } |
| |
| keymaster_key_format_t supported_export_formats[] = {KM_KEY_FORMAT_X509}; |
| void |
| GoogleKeymaster::SupportedExportFormats(keymaster_algorithm_t algorithm, |
| SupportedResponse<keymaster_key_format_t>* response) const { |
| if (response == NULL || !check_supported(algorithm, response)) |
| return; |
| |
| response->error = KM_ERROR_OK; |
| switch (algorithm) { |
| case KM_ALGORITHM_RSA: |
| case KM_ALGORITHM_DSA: |
| case KM_ALGORITHM_ECDSA: |
| response->SetResults(supported_export_formats); |
| break; |
| default: |
| response->results_length = 0; |
| break; |
| } |
| } |
| |
| void GoogleKeymaster::GenerateKey(const GenerateKeyRequest& request, |
| GenerateKeyResponse* response) { |
| if (response == NULL) |
| return; |
| |
| UniquePtr<Key> key(Key::GenerateKey(request.key_description, logger(), &response->error)); |
| if (response->error != KM_ERROR_OK) |
| return; |
| |
| response->error = SerializeKey(key.get(), origin(), &response->key_blob, &response->enforced, |
| &response->unenforced); |
| } |
| |
| void GoogleKeymaster::GetKeyCharacteristics(const GetKeyCharacteristicsRequest& request, |
| GetKeyCharacteristicsResponse* response) { |
| if (response == NULL) |
| return; |
| response->error = KM_ERROR_UNKNOWN_ERROR; |
| |
| UniquePtr<KeyBlob> blob( |
| LoadKeyBlob(request.key_blob, request.additional_params, &(response->error))); |
| if (blob.get() == NULL) |
| return; |
| |
| response->enforced.Reinitialize(blob->enforced()); |
| response->unenforced.Reinitialize(blob->unenforced()); |
| response->error = KM_ERROR_OK; |
| } |
| |
| void GoogleKeymaster::BeginOperation(const BeginOperationRequest& request, |
| BeginOperationResponse* response) { |
| if (response == NULL) |
| return; |
| response->op_handle = 0; |
| |
| UniquePtr<Key> key(LoadKey(request.key_blob, request.additional_params, &response->error)); |
| if (key.get() == NULL) |
| return; |
| |
| UniquePtr<Operation> operation(key->CreateOperation(request.purpose, &response->error)); |
| if (operation.get() == NULL) |
| return; |
| |
| response->error = operation->Begin(); |
| if (response->error != KM_ERROR_OK) |
| return; |
| |
| response->error = AddOperation(operation.release(), &response->op_handle); |
| } |
| |
| void GoogleKeymaster::UpdateOperation(const UpdateOperationRequest& request, |
| UpdateOperationResponse* response) { |
| OpTableEntry* entry = FindOperation(request.op_handle); |
| if (entry == NULL) { |
| response->error = KM_ERROR_INVALID_OPERATION_HANDLE; |
| return; |
| } |
| |
| response->error = entry->operation->Update(request.input, &response->output); |
| if (response->error != KM_ERROR_OK) { |
| // Any error invalidates the operation. |
| DeleteOperation(entry); |
| } |
| } |
| |
| void GoogleKeymaster::FinishOperation(const FinishOperationRequest& request, |
| FinishOperationResponse* response) { |
| OpTableEntry* entry = FindOperation(request.op_handle); |
| if (entry == NULL) { |
| response->error = KM_ERROR_INVALID_OPERATION_HANDLE; |
| return; |
| } |
| |
| response->error = entry->operation->Finish(request.signature, &response->output); |
| DeleteOperation(entry); |
| } |
| |
| keymaster_error_t GoogleKeymaster::AbortOperation(const keymaster_operation_handle_t op_handle) { |
| OpTableEntry* entry = FindOperation(op_handle); |
| if (entry == NULL) |
| return KM_ERROR_INVALID_OPERATION_HANDLE; |
| DeleteOperation(entry); |
| return KM_ERROR_OK; |
| } |
| |
| bool GoogleKeymaster::is_supported_export_format(keymaster_key_format_t test_format) { |
| unsigned int index; |
| for (index = 0; index < array_length(supported_export_formats); index++) { |
| if (test_format == supported_export_formats[index]) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| bool GoogleKeymaster::is_supported_import_format(keymaster_key_format_t test_format) { |
| unsigned int index; |
| for (index = 0; index < array_length(supported_import_formats); index++) { |
| if (test_format == supported_import_formats[index]) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| void GoogleKeymaster::ExportKey(const ExportKeyRequest& request, ExportKeyResponse* response) { |
| if (response == NULL) |
| return; |
| |
| UniquePtr<Key> to_export( |
| LoadKey(request.key_blob, request.additional_params, &response->error)); |
| if (to_export.get() == NULL) |
| return; |
| |
| UniquePtr<uint8_t[]> out_key; |
| size_t size; |
| response->error = to_export->formatted_key_material(request.key_format, &out_key, &size); |
| if (response->error == KM_ERROR_OK) { |
| response->key_data = out_key.release(); |
| response->key_data_length = size; |
| } |
| } |
| |
| void GoogleKeymaster::ImportKey(const ImportKeyRequest& request, ImportKeyResponse* response) { |
| if (response == NULL) |
| return; |
| |
| UniquePtr<Key> key(Key::ImportKey(request.key_description, request.key_format, request.key_data, |
| request.key_data_length, logger(), &response->error)); |
| if (response->error != KM_ERROR_OK) |
| return; |
| |
| response->error = SerializeKey(key.get(), KM_ORIGIN_IMPORTED, &response->key_blob, |
| &response->enforced, &response->unenforced); |
| } |
| |
| keymaster_error_t GoogleKeymaster::SerializeKey(const Key* key, keymaster_key_origin_t origin, |
| keymaster_key_blob_t* keymaster_blob, |
| AuthorizationSet* enforced, |
| AuthorizationSet* unenforced) { |
| keymaster_error_t error; |
| |
| error = SetAuthorizations(key->authorizations(), origin, enforced, unenforced); |
| if (error != KM_ERROR_OK) |
| return error; |
| |
| AuthorizationSet hidden_auths; |
| error = BuildHiddenAuthorizations(key->authorizations(), &hidden_auths); |
| if (error != KM_ERROR_OK) |
| return error; |
| |
| UniquePtr<uint8_t[]> key_material; |
| size_t key_material_size; |
| error = key->key_material(&key_material, &key_material_size); |
| if (error != KM_ERROR_OK) |
| return error; |
| |
| uint8_t nonce[KeyBlob::NONCE_LENGTH]; |
| GenerateNonce(nonce, array_size(nonce)); |
| |
| keymaster_key_blob_t key_data = {key_material.get(), key_material_size}; |
| UniquePtr<KeyBlob> blob( |
| new KeyBlob(*enforced, *unenforced, hidden_auths, key_data, MasterKey(), nonce)); |
| if (blob.get() == NULL) |
| return KM_ERROR_MEMORY_ALLOCATION_FAILED; |
| if (blob->error() != KM_ERROR_OK) |
| return blob->error(); |
| |
| size_t size = blob->SerializedSize(); |
| UniquePtr<uint8_t[]> blob_bytes(new uint8_t[size]); |
| if (blob_bytes.get() == NULL) |
| return KM_ERROR_MEMORY_ALLOCATION_FAILED; |
| |
| blob->Serialize(blob_bytes.get(), blob_bytes.get() + size); |
| keymaster_blob->key_material_size = size; |
| keymaster_blob->key_material = blob_bytes.release(); |
| |
| return KM_ERROR_OK; |
| } |
| |
| Key* GoogleKeymaster::LoadKey(const keymaster_key_blob_t& key, |
| const AuthorizationSet& client_params, keymaster_error_t* error) { |
| UniquePtr<KeyBlob> blob(LoadKeyBlob(key, client_params, error)); |
| if (*error != KM_ERROR_OK) |
| return NULL; |
| return Key::CreateKey(*blob, logger(), error); |
| } |
| |
| KeyBlob* GoogleKeymaster::LoadKeyBlob(const keymaster_key_blob_t& key, |
| const AuthorizationSet& client_params, |
| keymaster_error_t* error) { |
| AuthorizationSet hidden; |
| BuildHiddenAuthorizations(client_params, &hidden); |
| UniquePtr<KeyBlob> blob(new KeyBlob(key, hidden, MasterKey())); |
| if (blob.get() == NULL) { |
| *error = KM_ERROR_MEMORY_ALLOCATION_FAILED; |
| return NULL; |
| } else if (blob->error() != KM_ERROR_OK) { |
| *error = blob->error(); |
| return NULL; |
| } |
| *error = KM_ERROR_OK; |
| return blob.release(); |
| } |
| |
| static keymaster_error_t TranslateAuthorizationSetError(AuthorizationSet::Error err) { |
| switch (err) { |
| case AuthorizationSet::OK: |
| return KM_ERROR_OK; |
| case AuthorizationSet::ALLOCATION_FAILURE: |
| return KM_ERROR_MEMORY_ALLOCATION_FAILED; |
| case AuthorizationSet::MALFORMED_DATA: |
| return KM_ERROR_UNKNOWN_ERROR; |
| } |
| return KM_ERROR_OK; |
| } |
| |
| keymaster_error_t GoogleKeymaster::SetAuthorizations(const AuthorizationSet& key_description, |
| keymaster_key_origin_t origin, |
| AuthorizationSet* enforced, |
| AuthorizationSet* unenforced) { |
| for (size_t i = 0; i < key_description.size(); ++i) { |
| switch (key_description[i].tag) { |
| // These cannot be specified by the client. |
| case KM_TAG_ROOT_OF_TRUST: |
| case KM_TAG_ORIGIN: |
| return KM_ERROR_INVALID_TAG; |
| |
| // These don't work. |
| case KM_TAG_ROLLBACK_RESISTANT: |
| return KM_ERROR_UNSUPPORTED_TAG; |
| |
| // These are hidden. |
| case KM_TAG_APPLICATION_ID: |
| case KM_TAG_APPLICATION_DATA: |
| break; |
| |
| // Everything else we just copy into the appropriate set. |
| default: |
| AddAuthorization(key_description[i], enforced, unenforced); |
| break; |
| } |
| } |
| |
| AddAuthorization(Authorization(TAG_CREATION_DATETIME, java_time(time(NULL))), enforced, |
| unenforced); |
| AddAuthorization(Authorization(TAG_ORIGIN, origin), enforced, unenforced); |
| |
| if (enforced->is_valid() != AuthorizationSet::OK) |
| return TranslateAuthorizationSetError(enforced->is_valid()); |
| |
| return TranslateAuthorizationSetError(unenforced->is_valid()); |
| } |
| |
| keymaster_error_t GoogleKeymaster::BuildHiddenAuthorizations(const AuthorizationSet& input_set, |
| AuthorizationSet* hidden) { |
| keymaster_blob_t entry; |
| if (input_set.GetTagValue(TAG_APPLICATION_ID, &entry)) |
| hidden->push_back(TAG_APPLICATION_ID, entry.data, entry.data_length); |
| if (input_set.GetTagValue(TAG_APPLICATION_DATA, &entry)) |
| hidden->push_back(TAG_APPLICATION_DATA, entry.data, entry.data_length); |
| hidden->push_back(RootOfTrustTag()); |
| |
| return TranslateAuthorizationSetError(hidden->is_valid()); |
| } |
| |
| void GoogleKeymaster::AddAuthorization(const keymaster_key_param_t& auth, |
| AuthorizationSet* enforced, AuthorizationSet* unenforced) { |
| if (is_enforced(auth.tag)) |
| enforced->push_back(auth); |
| else |
| unenforced->push_back(auth); |
| } |
| |
| keymaster_error_t GoogleKeymaster::AddOperation(Operation* operation, |
| keymaster_operation_handle_t* op_handle) { |
| UniquePtr<Operation> op(operation); |
| if (RAND_bytes(reinterpret_cast<uint8_t*>(op_handle), sizeof(*op_handle)) == 0) |
| return KM_ERROR_UNKNOWN_ERROR; |
| if (*op_handle == 0) { |
| // Statistically this is vanishingly unlikely, which means if it ever happens in practice, |
| // it indicates a broken RNG. |
| return KM_ERROR_UNKNOWN_ERROR; |
| } |
| for (size_t i = 0; i < operation_table_size_; ++i) { |
| if (operation_table_[i].operation == NULL) { |
| operation_table_[i].operation = op.release(); |
| operation_table_[i].handle = *op_handle; |
| return KM_ERROR_OK; |
| } |
| } |
| return KM_ERROR_TOO_MANY_OPERATIONS; |
| } |
| |
| GoogleKeymaster::OpTableEntry* |
| GoogleKeymaster::FindOperation(keymaster_operation_handle_t op_handle) { |
| if (op_handle == 0) |
| return NULL; |
| |
| for (size_t i = 0; i < operation_table_size_; ++i) { |
| if (operation_table_[i].handle == op_handle) |
| return operation_table_.get() + i; |
| } |
| return NULL; |
| } |
| |
| void GoogleKeymaster::DeleteOperation(OpTableEntry* entry) { |
| delete entry->operation; |
| entry->operation = NULL; |
| entry->handle = 0; |
| } |
| |
| } // namespace keymaster |