Home | History | Annotate | Download | only in keymaster
      1 /*
      2  * Copyright 2014 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <keymaster/android_keymaster.h>
     18 
     19 #include <assert.h>
     20 #include <string.h>
     21 
     22 #include <cstddef>
     23 
     24 #include <openssl/rand.h>
     25 #include <openssl/x509.h>
     26 
     27 #include <UniquePtr.h>
     28 
     29 #include <keymaster/android_keymaster_utils.h>
     30 #include <keymaster/key_factory.h>
     31 #include <keymaster/keymaster_context.h>
     32 
     33 #include "ae.h"
     34 #include "key.h"
     35 #include "openssl_err.h"
     36 #include "operation.h"
     37 #include "operation_table.h"
     38 
     39 namespace keymaster {
     40 
     41 namespace {
     42 
     43 const uint8_t MAJOR_VER = 1;
     44 const uint8_t MINOR_VER = 1;
     45 const uint8_t SUBMINOR_VER = 0;
     46 
     47 keymaster_error_t CheckVersionInfo(const AuthorizationSet& tee_enforced,
     48                                    const AuthorizationSet& sw_enforced,
     49                                    const KeymasterContext& context) {
     50     uint32_t os_version;
     51     uint32_t os_patchlevel;
     52     context.GetSystemVersion(&os_version, &os_patchlevel);
     53 
     54     uint32_t key_os_patchlevel;
     55     if (tee_enforced.GetTagValue(TAG_OS_PATCHLEVEL, &key_os_patchlevel) ||
     56         sw_enforced.GetTagValue(TAG_OS_PATCHLEVEL, &key_os_patchlevel)) {
     57         if (key_os_patchlevel < os_patchlevel)
     58             return KM_ERROR_KEY_REQUIRES_UPGRADE;
     59         else if (key_os_patchlevel > os_patchlevel)
     60             return KM_ERROR_INVALID_KEY_BLOB;
     61     }
     62 
     63     return KM_ERROR_OK;
     64 }
     65 
     66 }  // anonymous namespace
     67 
     68 AndroidKeymaster::AndroidKeymaster(KeymasterContext* context, size_t operation_table_size)
     69     : context_(context), operation_table_(new OperationTable(operation_table_size)) {}
     70 
     71 AndroidKeymaster::~AndroidKeymaster() {}
     72 
     73 struct AE_CTX_Delete {
     74     void operator()(ae_ctx* ctx) const { ae_free(ctx); }
     75 };
     76 typedef UniquePtr<ae_ctx, AE_CTX_Delete> Unique_ae_ctx;
     77 
     78 // TODO(swillden): Unify support analysis.  Right now, we have per-keytype methods that determine if
     79 // specific modes, padding, etc. are supported for that key type, and AndroidKeymaster also has
     80 // methods that return the same information.  They'll get out of sync.  Best to put the knowledge in
     81 // the keytypes and provide some mechanism for AndroidKeymaster to query the keytypes for the
     82 // information.
     83 
     84 template <typename T>
     85 bool check_supported(const KeymasterContext& context, keymaster_algorithm_t algorithm,
     86                      SupportedResponse<T>* response) {
     87     if (context.GetKeyFactory(algorithm) == NULL) {
     88         response->error = KM_ERROR_UNSUPPORTED_ALGORITHM;
     89         return false;
     90     }
     91     return true;
     92 }
     93 
     94 void AndroidKeymaster::GetVersion(const GetVersionRequest&, GetVersionResponse* rsp) {
     95     if (rsp == NULL)
     96         return;
     97 
     98     rsp->major_ver = MAJOR_VER;
     99     rsp->minor_ver = MINOR_VER;
    100     rsp->subminor_ver = SUBMINOR_VER;
    101     rsp->error = KM_ERROR_OK;
    102 }
    103 
    104 void AndroidKeymaster::SupportedAlgorithms(const SupportedAlgorithmsRequest& /* request */,
    105                                            SupportedAlgorithmsResponse* response) {
    106     if (response == NULL)
    107         return;
    108 
    109     response->error = KM_ERROR_OK;
    110 
    111     size_t algorithm_count = 0;
    112     const keymaster_algorithm_t* algorithms = context_->GetSupportedAlgorithms(&algorithm_count);
    113     if (algorithm_count == 0)
    114         return;
    115     response->results_length = algorithm_count;
    116     response->results = dup_array(algorithms, algorithm_count);
    117     if (!response->results)
    118         response->error = KM_ERROR_MEMORY_ALLOCATION_FAILED;
    119 }
    120 
    121 template <typename T>
    122 void GetSupported(const KeymasterContext& context, keymaster_algorithm_t algorithm,
    123                   keymaster_purpose_t purpose,
    124                   const T* (OperationFactory::*get_supported_method)(size_t* count) const,
    125                   SupportedResponse<T>* response) {
    126     if (response == NULL || !check_supported(context, algorithm, response))
    127         return;
    128 
    129     const OperationFactory* factory = context.GetOperationFactory(algorithm, purpose);
    130     if (!factory) {
    131         response->error = KM_ERROR_UNSUPPORTED_PURPOSE;
    132         return;
    133     }
    134 
    135     size_t count;
    136     const T* supported = (factory->*get_supported_method)(&count);
    137     response->SetResults(supported, count);
    138 }
    139 
    140 void AndroidKeymaster::SupportedBlockModes(const SupportedBlockModesRequest& request,
    141                                            SupportedBlockModesResponse* response) {
    142     GetSupported(*context_, request.algorithm, request.purpose,
    143                  &OperationFactory::SupportedBlockModes, response);
    144 }
    145 
    146 void AndroidKeymaster::SupportedPaddingModes(const SupportedPaddingModesRequest& request,
    147                                              SupportedPaddingModesResponse* response) {
    148     GetSupported(*context_, request.algorithm, request.purpose,
    149                  &OperationFactory::SupportedPaddingModes, response);
    150 }
    151 
    152 void AndroidKeymaster::SupportedDigests(const SupportedDigestsRequest& request,
    153                                         SupportedDigestsResponse* response) {
    154     GetSupported(*context_, request.algorithm, request.purpose, &OperationFactory::SupportedDigests,
    155                  response);
    156 }
    157 
    158 void AndroidKeymaster::SupportedImportFormats(const SupportedImportFormatsRequest& request,
    159                                               SupportedImportFormatsResponse* response) {
    160     if (response == NULL || !check_supported(*context_, request.algorithm, response))
    161         return;
    162 
    163     size_t count;
    164     const keymaster_key_format_t* formats =
    165         context_->GetKeyFactory(request.algorithm)->SupportedImportFormats(&count);
    166     response->SetResults(formats, count);
    167 }
    168 
    169 void AndroidKeymaster::SupportedExportFormats(const SupportedExportFormatsRequest& request,
    170                                               SupportedExportFormatsResponse* response) {
    171     if (response == NULL || !check_supported(*context_, request.algorithm, response))
    172         return;
    173 
    174     size_t count;
    175     const keymaster_key_format_t* formats =
    176         context_->GetKeyFactory(request.algorithm)->SupportedExportFormats(&count);
    177     response->SetResults(formats, count);
    178 }
    179 
    180 void AndroidKeymaster::AddRngEntropy(const AddEntropyRequest& request,
    181                                      AddEntropyResponse* response) {
    182     response->error = context_->AddRngEntropy(request.random_data.peek_read(),
    183                                               request.random_data.available_read());
    184 }
    185 
    186 void AndroidKeymaster::GenerateKey(const GenerateKeyRequest& request,
    187                                    GenerateKeyResponse* response) {
    188     if (response == NULL)
    189         return;
    190 
    191     keymaster_algorithm_t algorithm;
    192     KeyFactory* factory = 0;
    193     UniquePtr<Key> key;
    194     if (!request.key_description.GetTagValue(TAG_ALGORITHM, &algorithm) ||
    195         !(factory = context_->GetKeyFactory(algorithm)))
    196         response->error = KM_ERROR_UNSUPPORTED_ALGORITHM;
    197     else {
    198         KeymasterKeyBlob key_blob;
    199         response->enforced.Clear();
    200         response->unenforced.Clear();
    201         response->error = factory->GenerateKey(request.key_description, &key_blob,
    202                                                &response->enforced, &response->unenforced);
    203         if (response->error == KM_ERROR_OK)
    204             response->key_blob = key_blob.release();
    205     }
    206 }
    207 
    208 void AndroidKeymaster::GetKeyCharacteristics(const GetKeyCharacteristicsRequest& request,
    209                                              GetKeyCharacteristicsResponse* response) {
    210     if (response == NULL)
    211         return;
    212 
    213     KeymasterKeyBlob key_material;
    214     response->error =
    215         context_->ParseKeyBlob(KeymasterKeyBlob(request.key_blob), request.additional_params,
    216                                &key_material, &response->enforced, &response->unenforced);
    217     if (response->error != KM_ERROR_OK)
    218         return;
    219 
    220     response->error = CheckVersionInfo(response->enforced, response->unenforced, *context_);
    221 }
    222 
    223 static KeyFactory* GetKeyFactory(const KeymasterContext& context,
    224                                  const AuthorizationSet& hw_enforced,
    225                                  const AuthorizationSet& sw_enforced,
    226                                  keymaster_algorithm_t* algorithm, keymaster_error_t* error) {
    227     *error = KM_ERROR_UNSUPPORTED_ALGORITHM;
    228     if (!hw_enforced.GetTagValue(TAG_ALGORITHM, algorithm) &&
    229         !sw_enforced.GetTagValue(TAG_ALGORITHM, algorithm))
    230         return nullptr;
    231     KeyFactory* factory = context.GetKeyFactory(*algorithm);
    232     if (factory)
    233         *error = KM_ERROR_OK;
    234     return factory;
    235 }
    236 
    237 void AndroidKeymaster::BeginOperation(const BeginOperationRequest& request,
    238                                       BeginOperationResponse* response) {
    239     if (response == NULL)
    240         return;
    241     response->op_handle = 0;
    242 
    243     AuthorizationSet hw_enforced;
    244     AuthorizationSet sw_enforced;
    245     const KeyFactory* key_factory;
    246     UniquePtr<Key> key;
    247     response->error = LoadKey(request.key_blob, request.additional_params, &hw_enforced,
    248                               &sw_enforced, &key_factory, &key);
    249     if (response->error != KM_ERROR_OK)
    250         return;
    251 
    252     response->error = KM_ERROR_UNKNOWN_ERROR;
    253     keymaster_algorithm_t key_algorithm;
    254     if (!key->authorizations().GetTagValue(TAG_ALGORITHM, &key_algorithm))
    255         return;
    256 
    257     response->error = KM_ERROR_UNSUPPORTED_PURPOSE;
    258     OperationFactory* factory = key_factory->GetOperationFactory(request.purpose);
    259     if (!factory)
    260         return;
    261 
    262     UniquePtr<Operation> operation(
    263         factory->CreateOperation(*key, request.additional_params, &response->error));
    264     if (operation.get() == NULL)
    265         return;
    266 
    267     if (context_->enforcement_policy()) {
    268         km_id_t key_id;
    269         response->error = KM_ERROR_UNKNOWN_ERROR;
    270         if (!context_->enforcement_policy()->CreateKeyId(request.key_blob, &key_id))
    271             return;
    272         operation->set_key_id(key_id);
    273         response->error = context_->enforcement_policy()->AuthorizeOperation(
    274             request.purpose, key_id, key->authorizations(), request.additional_params,
    275             0 /* op_handle */, true /* is_begin_operation */);
    276         if (response->error != KM_ERROR_OK)
    277             return;
    278     }
    279 
    280     response->output_params.Clear();
    281     response->error = operation->Begin(request.additional_params, &response->output_params);
    282     if (response->error != KM_ERROR_OK)
    283         return;
    284 
    285     operation->SetAuthorizations(key->authorizations());
    286     response->error = operation_table_->Add(operation.release(), &response->op_handle);
    287 }
    288 
    289 void AndroidKeymaster::UpdateOperation(const UpdateOperationRequest& request,
    290                                        UpdateOperationResponse* response) {
    291     if (response == NULL)
    292         return;
    293 
    294     response->error = KM_ERROR_INVALID_OPERATION_HANDLE;
    295     Operation* operation = operation_table_->Find(request.op_handle);
    296     if (operation == NULL)
    297         return;
    298 
    299     if (context_->enforcement_policy()) {
    300         response->error = context_->enforcement_policy()->AuthorizeOperation(
    301             operation->purpose(), operation->key_id(), operation->authorizations(),
    302             request.additional_params, request.op_handle, false /* is_begin_operation */);
    303         if (response->error != KM_ERROR_OK) {
    304             operation_table_->Delete(request.op_handle);
    305             return;
    306         }
    307     }
    308 
    309     response->error =
    310         operation->Update(request.additional_params, request.input, &response->output_params,
    311                           &response->output, &response->input_consumed);
    312     if (response->error != KM_ERROR_OK) {
    313         // Any error invalidates the operation.
    314         operation_table_->Delete(request.op_handle);
    315     }
    316 }
    317 
    318 void AndroidKeymaster::FinishOperation(const FinishOperationRequest& request,
    319                                        FinishOperationResponse* response) {
    320     if (response == NULL)
    321         return;
    322 
    323     response->error = KM_ERROR_INVALID_OPERATION_HANDLE;
    324     Operation* operation = operation_table_->Find(request.op_handle);
    325     if (operation == NULL)
    326         return;
    327 
    328     if (context_->enforcement_policy()) {
    329         response->error = context_->enforcement_policy()->AuthorizeOperation(
    330             operation->purpose(), operation->key_id(), operation->authorizations(),
    331             request.additional_params, request.op_handle, false /* is_begin_operation */);
    332         if (response->error != KM_ERROR_OK) {
    333             operation_table_->Delete(request.op_handle);
    334             return;
    335         }
    336     }
    337 
    338     response->error = operation->Finish(request.additional_params, request.input, request.signature,
    339                                         &response->output_params, &response->output);
    340     operation_table_->Delete(request.op_handle);
    341 }
    342 
    343 void AndroidKeymaster::AbortOperation(const AbortOperationRequest& request,
    344                                       AbortOperationResponse* response) {
    345     if (!response)
    346         return;
    347 
    348     Operation* operation = operation_table_->Find(request.op_handle);
    349     if (!operation) {
    350         response->error = KM_ERROR_INVALID_OPERATION_HANDLE;
    351         return;
    352     }
    353 
    354     response->error = operation->Abort();
    355     operation_table_->Delete(request.op_handle);
    356 }
    357 
    358 void AndroidKeymaster::ExportKey(const ExportKeyRequest& request, ExportKeyResponse* response) {
    359     if (response == NULL)
    360         return;
    361 
    362     AuthorizationSet hw_enforced;
    363     AuthorizationSet sw_enforced;
    364     KeymasterKeyBlob key_material;
    365     response->error =
    366         context_->ParseKeyBlob(KeymasterKeyBlob(request.key_blob), request.additional_params,
    367                                &key_material, &hw_enforced, &sw_enforced);
    368     if (response->error != KM_ERROR_OK)
    369         return;
    370 
    371     keymaster_algorithm_t algorithm;
    372     KeyFactory* key_factory =
    373         GetKeyFactory(*context_, hw_enforced, sw_enforced, &algorithm, &response->error);
    374     if (!key_factory)
    375         return;
    376 
    377     UniquePtr<Key> key;
    378     response->error = key_factory->LoadKey(key_material, request.additional_params, hw_enforced,
    379                                            sw_enforced, &key);
    380     if (response->error != KM_ERROR_OK)
    381         return;
    382 
    383     UniquePtr<uint8_t[]> out_key;
    384     size_t size;
    385     response->error = key->formatted_key_material(request.key_format, &out_key, &size);
    386     if (response->error == KM_ERROR_OK) {
    387         response->key_data = out_key.release();
    388         response->key_data_length = size;
    389     }
    390 }
    391 
    392 void AndroidKeymaster::AttestKey(const AttestKeyRequest& request, AttestKeyResponse* response) {
    393     if (!response)
    394         return;
    395 
    396     AuthorizationSet tee_enforced;
    397     AuthorizationSet sw_enforced;
    398     const KeyFactory* key_factory;
    399     UniquePtr<Key> key;
    400     response->error = LoadKey(request.key_blob, request.attest_params, &tee_enforced, &sw_enforced,
    401                               &key_factory, &key);
    402     if (response->error != KM_ERROR_OK)
    403         return;
    404 
    405     response->error = key->GenerateAttestation(*context_, request.attest_params, tee_enforced,
    406                                                sw_enforced, &response->certificate_chain);
    407 }
    408 
    409 void AndroidKeymaster::UpgradeKey(const UpgradeKeyRequest& request, UpgradeKeyResponse* response) {
    410     if (!response)
    411         return;
    412 
    413     KeymasterKeyBlob upgraded_key;
    414     response->error = context_->UpgradeKeyBlob(KeymasterKeyBlob(request.key_blob),
    415                                                request.upgrade_params, &upgraded_key);
    416     if (response->error != KM_ERROR_OK)
    417         return;
    418     response->upgraded_key = upgraded_key.release();
    419 }
    420 
    421 void AndroidKeymaster::ImportKey(const ImportKeyRequest& request, ImportKeyResponse* response) {
    422     if (response == NULL)
    423         return;
    424 
    425     keymaster_algorithm_t algorithm;
    426     KeyFactory* factory = 0;
    427     UniquePtr<Key> key;
    428     if (!request.key_description.GetTagValue(TAG_ALGORITHM, &algorithm) ||
    429         !(factory = context_->GetKeyFactory(algorithm)))
    430         response->error = KM_ERROR_UNSUPPORTED_ALGORITHM;
    431     else {
    432         keymaster_key_blob_t key_material = {request.key_data, request.key_data_length};
    433         KeymasterKeyBlob key_blob;
    434         response->error = factory->ImportKey(request.key_description, request.key_format,
    435                                              KeymasterKeyBlob(key_material), &key_blob,
    436                                              &response->enforced, &response->unenforced);
    437         if (response->error == KM_ERROR_OK)
    438             response->key_blob = key_blob.release();
    439     }
    440 }
    441 
    442 void AndroidKeymaster::DeleteKey(const DeleteKeyRequest& request, DeleteKeyResponse* response) {
    443     if (!response)
    444         return;
    445     response->error = context_->DeleteKey(KeymasterKeyBlob(request.key_blob));
    446 }
    447 
    448 void AndroidKeymaster::DeleteAllKeys(const DeleteAllKeysRequest&, DeleteAllKeysResponse* response) {
    449     if (!response)
    450         return;
    451     response->error = context_->DeleteAllKeys();
    452 }
    453 
    454 bool AndroidKeymaster::has_operation(keymaster_operation_handle_t op_handle) const {
    455     return operation_table_->Find(op_handle) != nullptr;
    456 }
    457 
    458 keymaster_error_t AndroidKeymaster::LoadKey(const keymaster_key_blob_t& key_blob,
    459                                             const AuthorizationSet& additional_params,
    460                                             AuthorizationSet* hw_enforced,
    461                                             AuthorizationSet* sw_enforced,
    462                                             const KeyFactory** factory, UniquePtr<Key>* key) {
    463     KeymasterKeyBlob key_material;
    464     keymaster_error_t error = context_->ParseKeyBlob(KeymasterKeyBlob(key_blob), additional_params,
    465                                                      &key_material, hw_enforced, sw_enforced);
    466     if (error != KM_ERROR_OK)
    467         return error;
    468 
    469     error = CheckVersionInfo(*hw_enforced, *sw_enforced, *context_);
    470     if (error != KM_ERROR_OK)
    471         return error;
    472 
    473     keymaster_algorithm_t algorithm;
    474     *factory = GetKeyFactory(*context_, *hw_enforced, *sw_enforced, &algorithm, &error);
    475     if (error != KM_ERROR_OK)
    476         return error;
    477 
    478     return (*factory)->LoadKey(key_material, additional_params, *hw_enforced, *sw_enforced, key);
    479 }
    480 
    481 }  // namespace keymaster
    482