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