Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 1 | // Copyright 2015 The Android Open Source Project |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 15 | #define LOG_TAG "keystore_client" |
| 16 | |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 17 | #include "keystore/keystore_client_impl.h" |
| 18 | |
| 19 | #include <string> |
| 20 | #include <vector> |
| 21 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 22 | #include <android/security/IKeystoreService.h> |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 23 | #include <binder/IBinder.h> |
| 24 | #include <binder/IInterface.h> |
| 25 | #include <binder/IServiceManager.h> |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 26 | #include <keystore/keystore.h> |
| 27 | #include <log/log.h> |
| 28 | #include <utils/String16.h> |
| 29 | #include <utils/String8.h> |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 30 | |
Shawn Willden | bb22a6c | 2017-12-06 19:35:28 -0700 | [diff] [blame^] | 31 | #include <keystore/keymaster_types.h> |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 32 | #include <keystore/keystore_hidl_support.h> |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 33 | |
Shawn Willden | bb22a6c | 2017-12-06 19:35:28 -0700 | [diff] [blame^] | 34 | #include "keystore_client.pb.h" |
| 35 | |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 36 | namespace { |
| 37 | |
| 38 | // Use the UID of the current process. |
| 39 | const int kDefaultUID = -1; |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 40 | const char kEncryptSuffix[] = "_ENC"; |
| 41 | const char kAuthenticateSuffix[] = "_AUTH"; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 42 | constexpr uint32_t kAESKeySize = 256; // bits |
| 43 | constexpr uint32_t kHMACKeySize = 256; // bits |
| 44 | constexpr uint32_t kHMACOutputSize = 256; // bits |
Darren Krahn | c8eca23 | 2015-10-16 10:54:43 -0700 | [diff] [blame] | 45 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 46 | using android::String16; |
| 47 | using android::security::keymaster::ExportResult; |
| 48 | using android::security::keymaster::OperationResult; |
| 49 | using keystore::AuthorizationSet; |
| 50 | using keystore::AuthorizationSetBuilder; |
| 51 | using keystore::KeyCharacteristics; |
| 52 | using keystore::KeyStoreServiceReturnCode; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 53 | } // namespace |
| 54 | |
| 55 | namespace keystore { |
| 56 | |
| 57 | KeystoreClientImpl::KeystoreClientImpl() { |
| 58 | service_manager_ = android::defaultServiceManager(); |
| 59 | keystore_binder_ = service_manager_->getService(String16("android.security.keystore")); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 60 | keystore_ = android::interface_cast<android::security::IKeystoreService>(keystore_binder_); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 61 | } |
| 62 | |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 63 | bool KeystoreClientImpl::encryptWithAuthentication(const std::string& key_name, |
| 64 | const std::string& data, |
| 65 | std::string* encrypted_data) { |
| 66 | // The encryption algorithm is AES-256-CBC with PKCS #7 padding and a random |
| 67 | // IV. The authentication algorithm is HMAC-SHA256 and is computed over the |
| 68 | // cipher-text (i.e. Encrypt-then-MAC approach). This was chosen over AES-GCM |
| 69 | // because hardware support for GCM is not mandatory for all Brillo devices. |
| 70 | std::string encryption_key_name = key_name + kEncryptSuffix; |
| 71 | if (!createOrVerifyEncryptionKey(encryption_key_name)) { |
| 72 | return false; |
| 73 | } |
| 74 | std::string authentication_key_name = key_name + kAuthenticateSuffix; |
| 75 | if (!createOrVerifyAuthenticationKey(authentication_key_name)) { |
| 76 | return false; |
| 77 | } |
| 78 | AuthorizationSetBuilder encrypt_params; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 79 | encrypt_params.Padding(PaddingMode::PKCS7); |
| 80 | encrypt_params.Authorization(TAG_BLOCK_MODE, BlockMode::CBC); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 81 | AuthorizationSet output_params; |
| 82 | std::string raw_encrypted_data; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 83 | if (!oneShotOperation(KeyPurpose::ENCRYPT, encryption_key_name, encrypt_params, data, |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 84 | std::string(), /* signature_to_verify */ |
| 85 | &output_params, &raw_encrypted_data)) { |
| 86 | ALOGE("Encrypt: AES operation failed."); |
| 87 | return false; |
| 88 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 89 | auto init_vector_blob = output_params.GetTagValue(TAG_NONCE); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 90 | if (!init_vector_blob.isOk()) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 91 | ALOGE("Encrypt: Missing initialization vector."); |
| 92 | return false; |
| 93 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 94 | std::string init_vector = hidlVec2String(init_vector_blob.value()); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 95 | |
| 96 | AuthorizationSetBuilder authenticate_params; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 97 | authenticate_params.Digest(Digest::SHA_2_256); |
| 98 | authenticate_params.Authorization(TAG_MAC_LENGTH, kHMACOutputSize); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 99 | std::string raw_authentication_data; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 100 | if (!oneShotOperation(KeyPurpose::SIGN, authentication_key_name, authenticate_params, |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 101 | init_vector + raw_encrypted_data, std::string(), /* signature_to_verify */ |
| 102 | &output_params, &raw_authentication_data)) { |
| 103 | ALOGE("Encrypt: HMAC operation failed."); |
| 104 | return false; |
| 105 | } |
| 106 | EncryptedData protobuf; |
| 107 | protobuf.set_init_vector(init_vector); |
| 108 | protobuf.set_authentication_data(raw_authentication_data); |
| 109 | protobuf.set_encrypted_data(raw_encrypted_data); |
| 110 | if (!protobuf.SerializeToString(encrypted_data)) { |
| 111 | ALOGE("Encrypt: Failed to serialize EncryptedData protobuf."); |
| 112 | return false; |
| 113 | } |
| 114 | return true; |
| 115 | } |
| 116 | |
| 117 | bool KeystoreClientImpl::decryptWithAuthentication(const std::string& key_name, |
| 118 | const std::string& encrypted_data, |
| 119 | std::string* data) { |
| 120 | EncryptedData protobuf; |
| 121 | if (!protobuf.ParseFromString(encrypted_data)) { |
| 122 | ALOGE("Decrypt: Failed to parse EncryptedData protobuf."); |
| 123 | } |
| 124 | // Verify authentication before attempting decryption. |
| 125 | std::string authentication_key_name = key_name + kAuthenticateSuffix; |
| 126 | AuthorizationSetBuilder authenticate_params; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 127 | authenticate_params.Digest(Digest::SHA_2_256); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 128 | AuthorizationSet output_params; |
| 129 | std::string output_data; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 130 | if (!oneShotOperation(KeyPurpose::VERIFY, authentication_key_name, authenticate_params, |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 131 | protobuf.init_vector() + protobuf.encrypted_data(), |
| 132 | protobuf.authentication_data(), &output_params, &output_data)) { |
| 133 | ALOGE("Decrypt: HMAC operation failed."); |
| 134 | return false; |
| 135 | } |
| 136 | std::string encryption_key_name = key_name + kEncryptSuffix; |
| 137 | AuthorizationSetBuilder encrypt_params; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 138 | encrypt_params.Padding(PaddingMode::PKCS7); |
| 139 | encrypt_params.Authorization(TAG_BLOCK_MODE, BlockMode::CBC); |
| 140 | encrypt_params.Authorization(TAG_NONCE, protobuf.init_vector().data(), |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 141 | protobuf.init_vector().size()); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 142 | if (!oneShotOperation(KeyPurpose::DECRYPT, encryption_key_name, encrypt_params, |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 143 | protobuf.encrypted_data(), std::string(), /* signature_to_verify */ |
| 144 | &output_params, data)) { |
| 145 | ALOGE("Decrypt: AES operation failed."); |
| 146 | return false; |
| 147 | } |
| 148 | return true; |
| 149 | } |
| 150 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 151 | bool KeystoreClientImpl::oneShotOperation(KeyPurpose purpose, const std::string& key_name, |
| 152 | const AuthorizationSet& input_parameters, |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 153 | const std::string& input_data, |
| 154 | const std::string& signature_to_verify, |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 155 | AuthorizationSet* output_parameters, |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 156 | std::string* output_data) { |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 157 | uint64_t handle; |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 158 | auto result = beginOperation(purpose, key_name, input_parameters, output_parameters, &handle); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 159 | if (!result.isOk()) { |
| 160 | ALOGE("BeginOperation failed: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 161 | return false; |
| 162 | } |
| 163 | AuthorizationSet empty_params; |
| 164 | size_t num_input_bytes_consumed; |
| 165 | AuthorizationSet ignored_params; |
| 166 | result = updateOperation(handle, empty_params, input_data, &num_input_bytes_consumed, |
| 167 | &ignored_params, output_data); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 168 | if (!result.isOk()) { |
| 169 | ALOGE("UpdateOperation failed: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 170 | return false; |
| 171 | } |
| 172 | result = |
| 173 | finishOperation(handle, empty_params, signature_to_verify, &ignored_params, output_data); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 174 | if (!result.isOk()) { |
| 175 | ALOGE("FinishOperation failed: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 176 | return false; |
| 177 | } |
| 178 | return true; |
| 179 | } |
| 180 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 181 | KeyStoreNativeReturnCode |
| 182 | KeystoreClientImpl::addRandomNumberGeneratorEntropy(const std::string& entropy) { |
| 183 | int32_t result; |
| 184 | auto binder_result = keystore_->addRngEntropy(blob2hidlVec(entropy), &result); |
| 185 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
| 186 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 189 | KeyStoreNativeReturnCode |
| 190 | KeystoreClientImpl::generateKey(const std::string& key_name, const AuthorizationSet& key_parameters, |
| 191 | AuthorizationSet* hardware_enforced_characteristics, |
| 192 | AuthorizationSet* software_enforced_characteristics) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 193 | String16 key_name16(key_name.data(), key_name.size()); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 194 | ::android::security::keymaster::KeyCharacteristics characteristics; |
| 195 | int32_t result; |
| 196 | auto binder_result = keystore_->generateKey( |
| 197 | key_name16, ::android::security::keymaster::KeymasterArguments(key_parameters.hidl_data()), |
| 198 | hidl_vec<uint8_t>() /* entropy */, kDefaultUID, KEYSTORE_FLAG_NONE, &characteristics, |
| 199 | &result); |
| 200 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 201 | |
| 202 | /* assignment (hidl_vec<KeyParameter> -> AuthorizationSet) makes a deep copy. |
| 203 | * There are no references to Parcel memory after that, and ownership of the newly acquired |
| 204 | * memory is with the AuthorizationSet objects. */ |
Shawn Willden | 0329a82 | 2017-12-04 13:55:14 -0700 | [diff] [blame] | 205 | *hardware_enforced_characteristics = characteristics.hardwareEnforced.getParameters(); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 206 | *software_enforced_characteristics = characteristics.softwareEnforced.getParameters(); |
| 207 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 208 | } |
| 209 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 210 | KeyStoreNativeReturnCode |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 211 | KeystoreClientImpl::getKeyCharacteristics(const std::string& key_name, |
| 212 | AuthorizationSet* hardware_enforced_characteristics, |
| 213 | AuthorizationSet* software_enforced_characteristics) { |
| 214 | String16 key_name16(key_name.data(), key_name.size()); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 215 | ::android::security::keymaster::KeyCharacteristics characteristics; |
| 216 | int32_t result; |
| 217 | auto binder_result = keystore_->getKeyCharacteristics( |
| 218 | key_name16, android::security::keymaster::KeymasterBlob(), |
| 219 | android::security::keymaster::KeymasterBlob(), kDefaultUID, &characteristics, &result); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 220 | |
| 221 | /* assignment (hidl_vec<KeyParameter> -> AuthorizationSet) makes a deep copy. |
| 222 | * There are no references to Parcel memory after that, and ownership of the newly acquired |
| 223 | * memory is with the AuthorizationSet objects. */ |
Shawn Willden | 0329a82 | 2017-12-04 13:55:14 -0700 | [diff] [blame] | 224 | *hardware_enforced_characteristics = characteristics.hardwareEnforced.getParameters(); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 225 | *software_enforced_characteristics = characteristics.softwareEnforced.getParameters(); |
| 226 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 227 | } |
| 228 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 229 | KeyStoreNativeReturnCode |
| 230 | KeystoreClientImpl::importKey(const std::string& key_name, const AuthorizationSet& key_parameters, |
| 231 | KeyFormat key_format, const std::string& key_data, |
| 232 | AuthorizationSet* hardware_enforced_characteristics, |
| 233 | AuthorizationSet* software_enforced_characteristics) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 234 | String16 key_name16(key_name.data(), key_name.size()); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 235 | auto hidlKeyData = blob2hidlVec(key_data); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 236 | ::android::security::keymaster::KeyCharacteristics characteristics; |
| 237 | int32_t result; |
| 238 | auto binder_result = keystore_->importKey( |
| 239 | key_name16, ::android::security::keymaster::KeymasterArguments(key_parameters.hidl_data()), |
| 240 | (int)key_format, hidlKeyData, kDefaultUID, KEYSTORE_FLAG_NONE, &characteristics, &result); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 241 | /* assignment (hidl_vec<KeyParameter> -> AuthorizationSet) makes a deep copy. |
| 242 | * There are no references to Parcel memory after that, and ownership of the newly acquired |
| 243 | * memory is with the AuthorizationSet objects. */ |
Shawn Willden | 0329a82 | 2017-12-04 13:55:14 -0700 | [diff] [blame] | 244 | *hardware_enforced_characteristics = characteristics.hardwareEnforced.getParameters(); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 245 | *software_enforced_characteristics = characteristics.softwareEnforced.getParameters(); |
| 246 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 247 | } |
| 248 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 249 | KeyStoreNativeReturnCode KeystoreClientImpl::exportKey(KeyFormat export_format, |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 250 | const std::string& key_name, |
| 251 | std::string* export_data) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 252 | String16 key_name16(key_name.data(), key_name.size()); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 253 | ExportResult export_result; |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 254 | auto binder_result = keystore_->exportKey( |
| 255 | key_name16, (int)export_format, android::security::keymaster::KeymasterBlob(), |
| 256 | android::security::keymaster::KeymasterBlob(), kDefaultUID, &export_result); |
| 257 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 258 | *export_data = hidlVec2String(export_result.exportData); |
| 259 | return export_result.resultCode; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 262 | KeyStoreNativeReturnCode KeystoreClientImpl::deleteKey(const std::string& key_name) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 263 | String16 key_name16(key_name.data(), key_name.size()); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 264 | int32_t result; |
| 265 | auto binder_result = keystore_->del(key_name16, kDefaultUID, &result); |
| 266 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
| 267 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 268 | } |
| 269 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 270 | KeyStoreNativeReturnCode KeystoreClientImpl::deleteAllKeys() { |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 271 | int32_t result; |
| 272 | auto binder_result = keystore_->clear_uid(kDefaultUID, &result); |
| 273 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
| 274 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 275 | } |
| 276 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 277 | KeyStoreNativeReturnCode |
| 278 | KeystoreClientImpl::beginOperation(KeyPurpose purpose, const std::string& key_name, |
| 279 | const AuthorizationSet& input_parameters, |
| 280 | AuthorizationSet* output_parameters, uint64_t* handle) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 281 | android::sp<android::IBinder> token(new android::BBinder); |
| 282 | String16 key_name16(key_name.data(), key_name.size()); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 283 | OperationResult result; |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 284 | auto binder_result = keystore_->begin( |
| 285 | token, key_name16, (int)purpose, true /*pruneable*/, |
| 286 | android::security::keymaster::KeymasterArguments(input_parameters.hidl_data()), |
| 287 | hidl_vec<uint8_t>() /* entropy */, kDefaultUID, &result); |
| 288 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 289 | if (result.resultCode.isOk()) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 290 | *handle = getNextVirtualHandle(); |
| 291 | active_operations_[*handle] = result.token; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 292 | if (result.outParams.size()) { |
| 293 | *output_parameters = result.outParams; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 294 | } |
| 295 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 296 | return result.resultCode; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 299 | KeyStoreNativeReturnCode |
| 300 | KeystoreClientImpl::updateOperation(uint64_t handle, const AuthorizationSet& input_parameters, |
| 301 | const std::string& input_data, size_t* num_input_bytes_consumed, |
| 302 | AuthorizationSet* output_parameters, std::string* output_data) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 303 | if (active_operations_.count(handle) == 0) { |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 304 | return ErrorCode::INVALID_OPERATION_HANDLE; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 305 | } |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 306 | OperationResult result; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 307 | auto hidlInputData = blob2hidlVec(input_data); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 308 | auto binder_result = keystore_->update( |
| 309 | active_operations_[handle], |
| 310 | android::security::keymaster::KeymasterArguments(input_parameters.hidl_data()), |
| 311 | hidlInputData, &result); |
| 312 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 313 | |
| 314 | if (result.resultCode.isOk()) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 315 | *num_input_bytes_consumed = result.inputConsumed; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 316 | if (result.outParams.size()) { |
| 317 | *output_parameters = result.outParams; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 318 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 319 | // TODO verify that append should not be assign |
| 320 | output_data->append(hidlVec2String(result.data)); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 321 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 322 | return result.resultCode; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 323 | } |
| 324 | |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 325 | KeyStoreNativeReturnCode |
| 326 | KeystoreClientImpl::finishOperation(uint64_t handle, const AuthorizationSet& input_parameters, |
| 327 | const std::string& signature_to_verify, |
| 328 | AuthorizationSet* output_parameters, std::string* output_data) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 329 | if (active_operations_.count(handle) == 0) { |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 330 | return ErrorCode::INVALID_OPERATION_HANDLE; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 331 | } |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 332 | OperationResult result; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 333 | auto hidlSignature = blob2hidlVec(signature_to_verify); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 334 | auto binder_result = keystore_->finish( |
| 335 | active_operations_[handle], |
| 336 | android::security::keymaster::KeymasterArguments(input_parameters.hidl_data()), |
| 337 | (std::vector<uint8_t>)hidlSignature, hidl_vec<uint8_t>(), &result); |
| 338 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 339 | |
| 340 | if (result.resultCode.isOk()) { |
| 341 | if (result.outParams.size()) { |
| 342 | *output_parameters = result.outParams; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 343 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 344 | // TODO verify that append should not be assign |
| 345 | output_data->append(hidlVec2String(result.data)); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 346 | active_operations_.erase(handle); |
| 347 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 348 | return result.resultCode; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 349 | } |
| 350 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 351 | KeyStoreNativeReturnCode KeystoreClientImpl::abortOperation(uint64_t handle) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 352 | if (active_operations_.count(handle) == 0) { |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 353 | return ErrorCode::INVALID_OPERATION_HANDLE; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 354 | } |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 355 | int32_t result; |
| 356 | // Current implementation does not return exceptions in android::binder::Status |
| 357 | auto binder_result = keystore_->abort(active_operations_[handle], &result); |
| 358 | if (!binder_result.isOk()) return ResponseCode::SYSTEM_ERROR; |
| 359 | if (KeyStoreNativeReturnCode(result).isOk()) { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 360 | active_operations_.erase(handle); |
| 361 | } |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 362 | return KeyStoreNativeReturnCode(result); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | bool KeystoreClientImpl::doesKeyExist(const std::string& key_name) { |
| 366 | String16 key_name16(key_name.data(), key_name.size()); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 367 | int32_t result; |
| 368 | auto binder_result = keystore_->exist(key_name16, kDefaultUID, &result); |
| 369 | if (!binder_result.isOk()) return false; // binder error |
| 370 | return result; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | bool KeystoreClientImpl::listKeys(const std::string& prefix, |
| 374 | std::vector<std::string>* key_name_list) { |
| 375 | String16 prefix16(prefix.data(), prefix.size()); |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 376 | std::vector<::android::String16> matches; |
| 377 | auto binder_result = keystore_->list(prefix16, kDefaultUID, &matches); |
| 378 | if (!binder_result.isOk()) return false; |
| 379 | |
| 380 | for (const auto& match : matches) { |
| 381 | android::String8 key_name(match); |
| 382 | key_name_list->push_back(prefix + std::string(key_name.string(), key_name.size())); |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 383 | } |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 384 | return true; |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 385 | } |
| 386 | |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 387 | uint64_t KeystoreClientImpl::getNextVirtualHandle() { |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 388 | return next_virtual_handle_++; |
| 389 | } |
| 390 | |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 391 | bool KeystoreClientImpl::createOrVerifyEncryptionKey(const std::string& key_name) { |
| 392 | bool key_exists = doesKeyExist(key_name); |
| 393 | if (key_exists) { |
| 394 | bool verified = false; |
| 395 | if (!verifyEncryptionKeyAttributes(key_name, &verified)) { |
| 396 | return false; |
| 397 | } |
| 398 | if (!verified) { |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 399 | auto result = deleteKey(key_name); |
| 400 | if (!result.isOk()) { |
| 401 | ALOGE("Failed to delete invalid encryption key: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 402 | return false; |
| 403 | } |
| 404 | key_exists = false; |
| 405 | } |
| 406 | } |
| 407 | if (!key_exists) { |
| 408 | AuthorizationSetBuilder key_parameters; |
| 409 | key_parameters.AesEncryptionKey(kAESKeySize) |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 410 | .Padding(PaddingMode::PKCS7) |
| 411 | .Authorization(TAG_BLOCK_MODE, BlockMode::CBC) |
| 412 | .Authorization(TAG_NO_AUTH_REQUIRED); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 413 | AuthorizationSet hardware_enforced_characteristics; |
| 414 | AuthorizationSet software_enforced_characteristics; |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 415 | auto result = generateKey(key_name, key_parameters, &hardware_enforced_characteristics, |
| 416 | &software_enforced_characteristics); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 417 | if (!result.isOk()) { |
| 418 | ALOGE("Failed to generate encryption key: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 419 | return false; |
| 420 | } |
| 421 | if (hardware_enforced_characteristics.size() == 0) { |
| 422 | ALOGW("WARNING: Encryption key is not hardware-backed."); |
| 423 | } |
| 424 | } |
| 425 | return true; |
| 426 | } |
| 427 | |
| 428 | bool KeystoreClientImpl::createOrVerifyAuthenticationKey(const std::string& key_name) { |
| 429 | bool key_exists = doesKeyExist(key_name); |
| 430 | if (key_exists) { |
| 431 | bool verified = false; |
| 432 | if (!verifyAuthenticationKeyAttributes(key_name, &verified)) { |
| 433 | return false; |
| 434 | } |
| 435 | if (!verified) { |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 436 | auto result = deleteKey(key_name); |
| 437 | if (!result.isOk()) { |
| 438 | ALOGE("Failed to delete invalid authentication key: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 439 | return false; |
| 440 | } |
| 441 | key_exists = false; |
| 442 | } |
| 443 | } |
| 444 | if (!key_exists) { |
| 445 | AuthorizationSetBuilder key_parameters; |
| 446 | key_parameters.HmacKey(kHMACKeySize) |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 447 | .Digest(Digest::SHA_2_256) |
| 448 | .Authorization(TAG_MIN_MAC_LENGTH, kHMACOutputSize) |
| 449 | .Authorization(TAG_NO_AUTH_REQUIRED); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 450 | AuthorizationSet hardware_enforced_characteristics; |
| 451 | AuthorizationSet software_enforced_characteristics; |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 452 | auto result = generateKey(key_name, key_parameters, &hardware_enforced_characteristics, |
| 453 | &software_enforced_characteristics); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 454 | if (!result.isOk()) { |
| 455 | ALOGE("Failed to generate authentication key: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 456 | return false; |
| 457 | } |
| 458 | if (hardware_enforced_characteristics.size() == 0) { |
| 459 | ALOGW("WARNING: Authentication key is not hardware-backed."); |
| 460 | } |
| 461 | } |
| 462 | return true; |
| 463 | } |
| 464 | |
| 465 | bool KeystoreClientImpl::verifyEncryptionKeyAttributes(const std::string& key_name, |
| 466 | bool* verified) { |
| 467 | AuthorizationSet hardware_enforced_characteristics; |
| 468 | AuthorizationSet software_enforced_characteristics; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 469 | auto result = getKeyCharacteristics(key_name, &hardware_enforced_characteristics, |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 470 | &software_enforced_characteristics); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 471 | if (!result.isOk()) { |
| 472 | ALOGE("Failed to query encryption key: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 473 | return false; |
| 474 | } |
| 475 | *verified = true; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 476 | auto algorithm = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_ALGORITHM), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 477 | software_enforced_characteristics.GetTagValue(TAG_ALGORITHM)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 478 | if (!algorithm.isOk() || algorithm.value() != Algorithm::AES) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 479 | ALOGW("Found encryption key with invalid algorithm."); |
| 480 | *verified = false; |
| 481 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 482 | auto key_size = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_KEY_SIZE), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 483 | software_enforced_characteristics.GetTagValue(TAG_KEY_SIZE)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 484 | if (!key_size.isOk() || key_size.value() != kAESKeySize) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 485 | ALOGW("Found encryption key with invalid size."); |
| 486 | *verified = false; |
| 487 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 488 | auto block_mode = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_BLOCK_MODE), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 489 | software_enforced_characteristics.GetTagValue(TAG_BLOCK_MODE)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 490 | if (!block_mode.isOk() || block_mode.value() != BlockMode::CBC) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 491 | ALOGW("Found encryption key with invalid block mode."); |
| 492 | *verified = false; |
| 493 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 494 | auto padding_mode = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_PADDING), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 495 | software_enforced_characteristics.GetTagValue(TAG_PADDING)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 496 | if (!padding_mode.isOk() || padding_mode.value() != PaddingMode::PKCS7) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 497 | ALOGW("Found encryption key with invalid padding mode."); |
| 498 | *verified = false; |
| 499 | } |
| 500 | if (hardware_enforced_characteristics.size() == 0) { |
| 501 | ALOGW("WARNING: Encryption key is not hardware-backed."); |
| 502 | } |
| 503 | return true; |
| 504 | } |
| 505 | |
| 506 | bool KeystoreClientImpl::verifyAuthenticationKeyAttributes(const std::string& key_name, |
| 507 | bool* verified) { |
| 508 | AuthorizationSet hardware_enforced_characteristics; |
| 509 | AuthorizationSet software_enforced_characteristics; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 510 | auto result = getKeyCharacteristics(key_name, &hardware_enforced_characteristics, |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 511 | &software_enforced_characteristics); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 512 | if (!result.isOk()) { |
| 513 | ALOGE("Failed to query authentication key: %d", int32_t(result)); |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 514 | return false; |
| 515 | } |
| 516 | *verified = true; |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 517 | auto algorithm = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_ALGORITHM), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 518 | software_enforced_characteristics.GetTagValue(TAG_ALGORITHM)); |
| 519 | if (!algorithm.isOk() || algorithm.value() != Algorithm::HMAC) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 520 | ALOGW("Found authentication key with invalid algorithm."); |
| 521 | *verified = false; |
| 522 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 523 | auto key_size = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_KEY_SIZE), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 524 | software_enforced_characteristics.GetTagValue(TAG_KEY_SIZE)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 525 | if (!key_size.isOk() || key_size.value() != kHMACKeySize) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 526 | ALOGW("Found authentication key with invalid size."); |
| 527 | *verified = false; |
| 528 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 529 | auto mac_size = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_MIN_MAC_LENGTH), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 530 | software_enforced_characteristics.GetTagValue(TAG_MIN_MAC_LENGTH)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 531 | if (!mac_size.isOk() || mac_size.value() != kHMACOutputSize) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 532 | ALOGW("Found authentication key with invalid minimum mac size."); |
| 533 | *verified = false; |
| 534 | } |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 535 | auto digest = NullOrOr(hardware_enforced_characteristics.GetTagValue(TAG_DIGEST), |
Dmitry Dementyev | a447b3c | 2017-10-27 23:09:53 -0700 | [diff] [blame] | 536 | software_enforced_characteristics.GetTagValue(TAG_DIGEST)); |
Janis Danisevskis | c7a9fa2 | 2016-10-13 18:43:45 +0100 | [diff] [blame] | 537 | if (!digest.isOk() || digest.value() != Digest::SHA_2_256) { |
Darren Krahn | 251cb28 | 2015-09-28 08:51:18 -0700 | [diff] [blame] | 538 | ALOGW("Found authentication key with invalid digest list."); |
| 539 | *verified = false; |
| 540 | } |
| 541 | if (hardware_enforced_characteristics.size() == 0) { |
| 542 | ALOGW("WARNING: Authentication key is not hardware-backed."); |
| 543 | } |
| 544 | return true; |
| 545 | } |
| 546 | |
Darren Krahn | 69a3dbc | 2015-09-22 16:21:04 -0700 | [diff] [blame] | 547 | } // namespace keystore |