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 #pragma once 18 19 #include <assert.h> 20 #include <stdint.h> 21 #include <stdlib.h> 22 #include <string.h> 23 24 #include <string> 25 #include <string_view> 26 #include <utility> 27 #include <vector> 28 29 #include <keymaster/android_keymaster_utils.h> 30 #include <keymaster/authorization_set.h> 31 #include <keymaster/km_version.h> 32 33 namespace keymaster { 34 35 // Commands 36 enum AndroidKeymasterCommand : uint32_t { 37 GENERATE_KEY = 0, 38 BEGIN_OPERATION = 1, 39 UPDATE_OPERATION = 2, 40 FINISH_OPERATION = 3, 41 ABORT_OPERATION = 4, 42 IMPORT_KEY = 5, 43 EXPORT_KEY = 6, 44 GET_VERSION = 7, 45 ADD_RNG_ENTROPY = 8, 46 GET_SUPPORTED_ALGORITHMS = 9, 47 GET_SUPPORTED_BLOCK_MODES = 10, 48 GET_SUPPORTED_PADDING_MODES = 11, 49 GET_SUPPORTED_DIGESTS = 12, 50 GET_SUPPORTED_IMPORT_FORMATS = 13, 51 GET_SUPPORTED_EXPORT_FORMATS = 14, 52 GET_KEY_CHARACTERISTICS = 15, 53 ATTEST_KEY = 16, 54 UPGRADE_KEY = 17, 55 CONFIGURE = 18, 56 GET_HMAC_SHARING_PARAMETERS = 19, 57 COMPUTE_SHARED_HMAC = 20, 58 VERIFY_AUTHORIZATION = 21, 59 DELETE_KEY = 22, 60 DELETE_ALL_KEYS = 23, 61 DESTROY_ATTESTATION_IDS = 24, 62 IMPORT_WRAPPED_KEY = 25, 63 EARLY_BOOT_ENDED = 26, 64 DEVICE_LOCKED = 27, 65 GET_VERSION_2 = 28, 66 GENERATE_RKP_KEY = 29, 67 GENERATE_CSR = 30, 68 GENERATE_TIMESTAMP_TOKEN = 31, 69 CONFIGURE_VENDOR_PATCHLEVEL = 32, 70 CONFIGURE_BOOT_PATCHLEVEL = 33, 71 CONFIGURE_VERIFIED_BOOT_INFO = 34, 72 GET_ROOT_OF_TRUST = 35, 73 GET_HW_INFO = 36, 74 GENERATE_CSR_V2 = 37, 75 SET_ATTESTATION_IDS = 38, 76 SET_ATTESTATION_IDS_KM3 = 39, 77 SET_ADDITIONAL_ATTESTATION_INFO = 40, 78 }; 79 80 /** 81 * Keymaster message versions are tied to keymaster versions. We map the keymaster version to a 82 * sequential "message version". The actual message formatting differences are implemented in the 83 * message classes. Note that it is not necessary to increase the message version when new messages 84 * are added, only when the serialized format of one or more messages changes. A message version 85 * argument is provided to the message constructor and when the serialization/deserialization 86 * methods are called the implementations of those methods should examine the message version and 87 * generate/parse the byte stream accordingly. 88 * 89 * The original design of message versioning uses the GetVersion message, sent from client (e.g. HAL 90 * service) to server (e.g. trusted app), and then relies on the client to identify what messages to 91 * send. This architecture assumes that the client is never older than the server. This assumption 92 * turned out not to be true in general. 93 * 94 * The current approach performs a mutual exchange of message version info between client and 95 * server, using the GetVersion2 message. In addition, it defers the specification of the message 96 * ID to the message classes, so a message class can use a different ID when necessary. ID changes 97 * should be rare, in fact the only time they should be required is during the switch from 98 * GetVersion to GetVersion2. 99 * 100 * Assuming both client and server support GetVersion2, the approach is as follows: 101 * 102 * 1. Client sends GetVersion2Request, containing its maximum message version, c_max. 103 * 2. Server replies with GetVersion2Response, containing its maximum message version, s_max. 104 * 3. Both sides proceed to create all messages with version min(c_max, s_max). 105 * 106 * To enable this, the client must always send GetVersion2 as its first message. If the server 107 * doesn't support GetVersion2, it will reply with an error of some sort (the details are likely 108 * environment-specific). If the client gets this error, it must respond by sending GetVersion, and 109 * then must configure its message version according to the response. Note that an acceptable 110 * response to a too-old server version is to return an error to the caller of the client, informing 111 * it of the problem. 112 * 113 * On the server side, a server that supports GetVersion2 must also support GetVersion. If it 114 * received GetVersion2 it should proceed as outline above, and expect that the client will not send 115 * GetVersion. If it received GetVersion, it must assume that the client does not support 116 * GetVersion2 and reply that it is version 2.0.0 and use the corresponding message version (3). 117 */ 118 constexpr int32_t kInvalidMessageVersion = -1; 119 constexpr int32_t kMaxMessageVersion = 4; 120 constexpr int32_t kDefaultMessageVersion = 3; 121 122 /** 123 * MessageVersion returns the message version for a specified KM version and, possibly, KM release 124 * date in YYYYMMDD format (it's not recommended to change message formats within a KM version, but 125 * it could happen). 126 */ 127 inline int32_t MessageVersion(KmVersion version, uint32_t /* km_date */ = 0) { 128 switch (version) { 129 case KmVersion::KEYMASTER_1: 130 return 1; 131 case KmVersion::KEYMASTER_1_1: 132 return 2; 133 case KmVersion::KEYMASTER_2: 134 case KmVersion::KEYMASTER_3: 135 case KmVersion::KEYMASTER_4: 136 case KmVersion::KEYMASTER_4_1: 137 return 3; 138 case KmVersion::KEYMINT_1: 139 case KmVersion::KEYMINT_2: 140 case KmVersion::KEYMINT_3: 141 case KmVersion::KEYMINT_4: 142 return 4; 143 } 144 return kInvalidMessageVersion; 145 } 146 147 /** 148 * NegotiateMessageVersion implements the client side of the GetVersion protocol, determining the 149 * appropriate message version from the values returned by the server. 150 */ 151 struct GetVersionResponse; 152 int32_t NegotiateMessageVersion(const GetVersionResponse& response, keymaster_error_t* error); 153 154 /** 155 * This MessageVersion overload determines the message version to use given the provided client and 156 * server messages. If the client gets an error when it sends GetVersion2Request, it should send 157 * GetVersionRequest and use the above overload. If the server receives GetVersionRequest, it 158 * should assume it should use message version 3 and return GetVersionResponse(2, 0, 0). 159 */ 160 struct GetVersion2Request; 161 struct GetVersion2Response; 162 int32_t NegotiateMessageVersion(const GetVersion2Request& request, 163 const GetVersion2Response& response); 164 165 struct KeymasterMessage : public Serializable { KeymasterMessageKeymasterMessage166 explicit KeymasterMessage(int32_t ver) : message_version(ver) { assert(ver >= 0); } 167 168 // The message version that should be used for this message. This indicates how the data is 169 // serialized/deserialized. Commonly, higher message versions serialize/deserialize additional 170 // arguments, though there is no specific rule limiting later version to adding parameters. 171 const int32_t message_version; 172 }; 173 174 /** 175 * All responses include an error value, and if the error is not KM_ERROR_OK, return no additional 176 * data. 177 */ 178 struct KeymasterResponse : public KeymasterMessage { KeymasterResponseKeymasterResponse179 explicit KeymasterResponse(int32_t ver) 180 : KeymasterMessage(ver), error(KM_ERROR_UNKNOWN_ERROR) {} 181 182 size_t SerializedSize() const override; 183 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 184 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 185 186 virtual size_t NonErrorSerializedSize() const = 0; 187 virtual uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const = 0; 188 virtual bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) = 0; 189 190 keymaster_error_t error; 191 }; 192 193 // Abstract base for empty requests. 194 struct EmptyKeymasterRequest : public KeymasterMessage { EmptyKeymasterRequestEmptyKeymasterRequest195 explicit EmptyKeymasterRequest(int32_t ver) : KeymasterMessage(ver) {} 196 SerializedSizeEmptyKeymasterRequest197 size_t SerializedSize() const override { return 0; } SerializeEmptyKeymasterRequest198 uint8_t* Serialize(uint8_t* buf, const uint8_t*) const override { return buf; } DeserializeEmptyKeymasterRequest199 bool Deserialize(const uint8_t**, const uint8_t*) override { return true; }; 200 }; 201 202 // Empty response. 203 struct EmptyKeymasterResponse : public KeymasterResponse { EmptyKeymasterResponseEmptyKeymasterResponse204 explicit EmptyKeymasterResponse(int32_t ver) : KeymasterResponse(ver) {} 205 NonErrorSerializedSizeEmptyKeymasterResponse206 size_t NonErrorSerializedSize() const override { return 0; } NonErrorSerializeEmptyKeymasterResponse207 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; } NonErrorDeserializeEmptyKeymasterResponse208 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; } 209 }; 210 211 // TODO(swillden): Remove when Keymaster1 is deleted 212 struct SupportedAlgorithmsRequest : public KeymasterMessage { SupportedAlgorithmsRequestSupportedAlgorithmsRequest213 explicit SupportedAlgorithmsRequest(int32_t ver) : KeymasterMessage(ver) {} 214 SerializedSizeSupportedAlgorithmsRequest215 size_t SerializedSize() const override { return 0; }; SerializeSupportedAlgorithmsRequest216 uint8_t* Serialize(uint8_t* buf, const uint8_t* /* end */) const override { return buf; } DeserializeSupportedAlgorithmsRequest217 bool Deserialize(const uint8_t** /* buf_ptr */, const uint8_t* /* end */) override { 218 return true; 219 } 220 }; 221 222 // TODO(swillden): Remove when Keymaster1 is deleted 223 struct SupportedByAlgorithmRequest : public KeymasterMessage { SupportedByAlgorithmRequestSupportedByAlgorithmRequest224 explicit SupportedByAlgorithmRequest(int32_t ver) : KeymasterMessage(ver) {} 225 SerializedSizeSupportedByAlgorithmRequest226 size_t SerializedSize() const override { return sizeof(uint32_t); }; SerializeSupportedByAlgorithmRequest227 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 228 return append_uint32_to_buf(buf, end, algorithm); 229 } DeserializeSupportedByAlgorithmRequest230 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 231 return copy_uint32_from_buf(buf_ptr, end, &algorithm); 232 } 233 234 keymaster_algorithm_t algorithm; 235 }; 236 237 // TODO(swillden): Remove when Keymaster1 is deleted 238 struct SupportedImportFormatsRequest : public SupportedByAlgorithmRequest { SupportedImportFormatsRequestSupportedImportFormatsRequest239 explicit SupportedImportFormatsRequest(int32_t ver) : SupportedByAlgorithmRequest(ver) {} 240 }; 241 242 // TODO(swillden): Remove when Keymaster1 is deleted 243 struct SupportedExportFormatsRequest : public SupportedByAlgorithmRequest { SupportedExportFormatsRequestSupportedExportFormatsRequest244 explicit SupportedExportFormatsRequest(int32_t ver) : SupportedByAlgorithmRequest(ver) {} 245 }; 246 247 // TODO(swillden): Remove when Keymaster1 is deleted 248 struct SupportedByAlgorithmAndPurposeRequest : public KeymasterMessage { SupportedByAlgorithmAndPurposeRequestSupportedByAlgorithmAndPurposeRequest249 explicit SupportedByAlgorithmAndPurposeRequest(int32_t ver) : KeymasterMessage(ver) {} 250 SerializedSizeSupportedByAlgorithmAndPurposeRequest251 size_t SerializedSize() const override { return sizeof(uint32_t) * 2; }; SerializeSupportedByAlgorithmAndPurposeRequest252 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 253 buf = append_uint32_to_buf(buf, end, algorithm); 254 return append_uint32_to_buf(buf, end, purpose); 255 } DeserializeSupportedByAlgorithmAndPurposeRequest256 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 257 return copy_uint32_from_buf(buf_ptr, end, &algorithm) && 258 copy_uint32_from_buf(buf_ptr, end, &purpose); 259 } 260 261 keymaster_algorithm_t algorithm; 262 keymaster_purpose_t purpose; 263 }; 264 265 // TODO(swillden): Remove when Keymaster1 is deleted 266 struct SupportedBlockModesRequest : public SupportedByAlgorithmAndPurposeRequest { SupportedBlockModesRequestSupportedBlockModesRequest267 explicit SupportedBlockModesRequest(int32_t ver) : SupportedByAlgorithmAndPurposeRequest(ver) {} 268 }; 269 270 // TODO(swillden): Remove when Keymaster1 is deleted 271 struct SupportedPaddingModesRequest : public SupportedByAlgorithmAndPurposeRequest { SupportedPaddingModesRequestSupportedPaddingModesRequest272 explicit SupportedPaddingModesRequest(int32_t ver) 273 : SupportedByAlgorithmAndPurposeRequest(ver) {} 274 }; 275 276 // TODO(swillden): Remove when Keymaster1 is deleted 277 struct SupportedDigestsRequest : public SupportedByAlgorithmAndPurposeRequest { SupportedDigestsRequestSupportedDigestsRequest278 explicit SupportedDigestsRequest(int32_t ver) : SupportedByAlgorithmAndPurposeRequest(ver) {} 279 }; 280 281 // TODO(swillden): Remove when Keymaster1 is deleted 282 template <typename T> struct SupportedResponse : public KeymasterResponse { SupportedResponseSupportedResponse283 explicit SupportedResponse(int32_t ver) 284 : KeymasterResponse(ver), results(nullptr), results_length(0) {} ~SupportedResponseSupportedResponse285 ~SupportedResponse() { delete[] results; } 286 SetResultsSupportedResponse287 template <size_t N> void SetResults(const T (&arr)[N]) { SetResults(arr, N); } 288 SetResultsSupportedResponse289 void SetResults(const T* arr, size_t n) { 290 delete[] results; 291 results_length = 0; 292 results = dup_array(arr, n); 293 if (results == nullptr) { 294 error = KM_ERROR_MEMORY_ALLOCATION_FAILED; 295 } else { 296 results_length = n; 297 error = KM_ERROR_OK; 298 } 299 } 300 NonErrorSerializedSizeSupportedResponse301 size_t NonErrorSerializedSize() const override { 302 return sizeof(uint32_t) + results_length * sizeof(uint32_t); 303 } NonErrorSerializeSupportedResponse304 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 305 return append_uint32_array_to_buf(buf, end, results, results_length); 306 } NonErrorDeserializeSupportedResponse307 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 308 delete[] results; 309 results = nullptr; 310 UniquePtr<T[]> tmp; 311 if (!copy_uint32_array_from_buf(buf_ptr, end, &tmp, &results_length)) return false; 312 results = tmp.release(); 313 return true; 314 } 315 316 T* results; 317 size_t results_length; 318 }; 319 320 // TODO(swillden): Remove when Keymaster1 is deleted 321 struct SupportedAlgorithmsResponse : public SupportedResponse<keymaster_algorithm_t> { SupportedAlgorithmsResponseSupportedAlgorithmsResponse322 explicit SupportedAlgorithmsResponse(int32_t ver) 323 : SupportedResponse<keymaster_algorithm_t>(ver) {} 324 }; 325 326 // TODO(swillden): Remove when Keymaster1 is deleted 327 struct SupportedBlockModesResponse : public SupportedResponse<keymaster_block_mode_t> { SupportedBlockModesResponseSupportedBlockModesResponse328 explicit SupportedBlockModesResponse(int32_t ver) 329 : SupportedResponse<keymaster_block_mode_t>(ver) {} 330 }; 331 332 // TODO(swillden): Remove when Keymaster1 is deleted 333 struct SupportedPaddingModesResponse : public SupportedResponse<keymaster_padding_t> { SupportedPaddingModesResponseSupportedPaddingModesResponse334 explicit SupportedPaddingModesResponse(int32_t ver) 335 : SupportedResponse<keymaster_padding_t>(ver) {} 336 }; 337 338 // TODO(swillden): Remove when Keymaster1 is deleted 339 struct SupportedDigestsResponse : public SupportedResponse<keymaster_digest_t> { SupportedDigestsResponseSupportedDigestsResponse340 explicit SupportedDigestsResponse(int32_t ver) : SupportedResponse<keymaster_digest_t>(ver) {} 341 }; 342 343 // TODO(swillden): Remove when Keymaster1 is deleted 344 struct SupportedImportFormatsResponse : public SupportedResponse<keymaster_key_format_t> { SupportedImportFormatsResponseSupportedImportFormatsResponse345 explicit SupportedImportFormatsResponse(int32_t ver) 346 : SupportedResponse<keymaster_key_format_t>(ver) {} 347 }; 348 349 // TODO(swillden): Remove when Keymaster1 is deleted 350 struct SupportedExportFormatsResponse : public SupportedResponse<keymaster_key_format_t> { SupportedExportFormatsResponseSupportedExportFormatsResponse351 explicit SupportedExportFormatsResponse(int32_t ver) 352 : SupportedResponse<keymaster_key_format_t>(ver) {} 353 }; 354 355 struct GenerateKeyRequest : public KeymasterMessage { GenerateKeyRequestGenerateKeyRequest356 explicit GenerateKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 357 358 size_t SerializedSize() const override; 359 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 360 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 361 362 AuthorizationSet key_description; 363 KeymasterKeyBlob attestation_signing_key_blob; 364 AuthorizationSet attest_key_params; 365 KeymasterBlob issuer_subject; 366 }; 367 368 struct GenerateKeyResponse : public KeymasterResponse { GenerateKeyResponseGenerateKeyResponse369 explicit GenerateKeyResponse(int32_t ver) 370 : KeymasterResponse(ver), key_blob{}, certificate_chain{} {} 371 372 size_t NonErrorSerializedSize() const override; 373 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 374 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 375 376 KeymasterKeyBlob key_blob; 377 AuthorizationSet enforced; 378 AuthorizationSet unenforced; 379 CertificateChain certificate_chain; 380 }; 381 382 struct GenerateRkpKeyRequest : KeymasterMessage { GenerateRkpKeyRequestGenerateRkpKeyRequest383 explicit GenerateRkpKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 384 SerializedSizeGenerateRkpKeyRequest385 size_t SerializedSize() const override { return sizeof(uint8_t); } SerializeGenerateRkpKeyRequest386 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 387 return append_to_buf(buf, end, &test_mode, sizeof(uint8_t)); 388 } DeserializeGenerateRkpKeyRequest389 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 390 return copy_from_buf(buf_ptr, end, &test_mode, sizeof(uint8_t)); 391 } 392 393 bool test_mode = false; 394 }; 395 396 struct GenerateRkpKeyResponse : public KeymasterResponse { GenerateRkpKeyResponseGenerateRkpKeyResponse397 explicit GenerateRkpKeyResponse(int32_t ver) : KeymasterResponse(ver) {} 398 399 size_t NonErrorSerializedSize() const override; 400 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 401 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 402 403 KeymasterKeyBlob key_blob; 404 KeymasterBlob maced_public_key; 405 }; 406 407 struct GenerateCsrRequest : public KeymasterMessage { GenerateCsrRequestGenerateCsrRequest408 explicit GenerateCsrRequest(int32_t ver) : KeymasterMessage(ver) {} 409 ~GenerateCsrRequestGenerateCsrRequest410 ~GenerateCsrRequest() override { delete[] keys_to_sign_array; } 411 412 size_t SerializedSize() const override; 413 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 414 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 415 void SetKeyToSign(uint32_t index, const void* data, size_t length); 416 void SetEndpointEncCertChain(const void* data, size_t length); 417 void SetChallenge(const void* data, size_t length); 418 419 bool test_mode = false; 420 size_t num_keys = 0; 421 KeymasterBlob* keys_to_sign_array = nullptr; 422 KeymasterBlob endpoint_enc_cert_chain; 423 KeymasterBlob challenge; 424 }; 425 426 struct GenerateCsrResponse : public KeymasterResponse { GenerateCsrResponseGenerateCsrResponse427 explicit GenerateCsrResponse(int32_t ver) : KeymasterResponse(ver) {} 428 429 size_t NonErrorSerializedSize() const override; 430 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 431 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 432 433 KeymasterBlob keys_to_sign_mac; 434 KeymasterBlob device_info_blob; 435 KeymasterBlob protected_data_blob; 436 }; 437 438 struct GenerateCsrV2Request : public KeymasterMessage { GenerateCsrV2RequestGenerateCsrV2Request439 explicit GenerateCsrV2Request(int32_t ver) : KeymasterMessage(ver) {} 440 ~GenerateCsrV2RequestGenerateCsrV2Request441 ~GenerateCsrV2Request() override { delete[] keys_to_sign_array; } 442 443 size_t SerializedSize() const override; 444 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 445 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 446 bool InitKeysToSign(uint32_t count); 447 void SetKeyToSign(uint32_t index, const void* data, size_t length); 448 void SetChallenge(const void* data, size_t length); 449 450 uint32_t num_keys = 0; 451 KeymasterBlob* keys_to_sign_array = nullptr; 452 KeymasterBlob challenge; 453 }; 454 455 struct GenerateCsrV2Response : public KeymasterResponse { GenerateCsrV2ResponseGenerateCsrV2Response456 explicit GenerateCsrV2Response(int32_t ver) : KeymasterResponse(ver) {} 457 458 size_t NonErrorSerializedSize() const override; 459 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 460 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 461 462 KeymasterBlob csr; 463 }; 464 465 struct GetKeyCharacteristicsRequest : public KeymasterMessage { GetKeyCharacteristicsRequestGetKeyCharacteristicsRequest466 explicit GetKeyCharacteristicsRequest(int32_t ver) : KeymasterMessage(ver) { 467 key_blob.key_material = nullptr; 468 key_blob.key_material_size = 0; 469 } 470 ~GetKeyCharacteristicsRequest(); 471 472 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialGetKeyCharacteristicsRequest473 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 474 SetKeyMaterial(blob.key_material, blob.key_material_size); 475 } 476 477 size_t SerializedSize() const override; 478 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 479 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 480 481 keymaster_key_blob_t key_blob; 482 AuthorizationSet additional_params; 483 }; 484 485 struct GetKeyCharacteristicsResponse : public KeymasterResponse { GetKeyCharacteristicsResponseGetKeyCharacteristicsResponse486 explicit GetKeyCharacteristicsResponse(int32_t ver) : KeymasterResponse(ver) {} 487 488 size_t NonErrorSerializedSize() const override; 489 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 490 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 491 492 AuthorizationSet enforced; 493 AuthorizationSet unenforced; 494 }; 495 496 struct BeginOperationRequest : public KeymasterMessage { BeginOperationRequestBeginOperationRequest497 explicit BeginOperationRequest(int32_t ver) : KeymasterMessage(ver) { 498 key_blob.key_material = nullptr; 499 key_blob.key_material_size = 0; 500 } ~BeginOperationRequestBeginOperationRequest501 ~BeginOperationRequest() { delete[] key_blob.key_material; } 502 503 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialBeginOperationRequest504 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 505 SetKeyMaterial(blob.key_material, blob.key_material_size); 506 } 507 508 size_t SerializedSize() const override; 509 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 510 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 511 512 keymaster_purpose_t purpose; 513 keymaster_key_blob_t key_blob; 514 AuthorizationSet additional_params; 515 }; 516 517 struct BeginOperationResponse : public KeymasterResponse { BeginOperationResponseBeginOperationResponse518 explicit BeginOperationResponse(int32_t ver) : KeymasterResponse(ver) {} 519 520 size_t NonErrorSerializedSize() const override; 521 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 522 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 523 524 keymaster_operation_handle_t op_handle; 525 AuthorizationSet output_params; 526 }; 527 528 struct UpdateOperationRequest : public KeymasterMessage { UpdateOperationRequestUpdateOperationRequest529 explicit UpdateOperationRequest(int32_t ver) : KeymasterMessage(ver) {} 530 531 size_t SerializedSize() const override; 532 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 533 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 534 535 keymaster_operation_handle_t op_handle; 536 Buffer input; 537 AuthorizationSet additional_params; 538 }; 539 540 struct UpdateOperationResponse : public KeymasterResponse { UpdateOperationResponseUpdateOperationResponse541 explicit UpdateOperationResponse(int32_t ver) : KeymasterResponse(ver), input_consumed(0) {} 542 543 size_t NonErrorSerializedSize() const override; 544 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 545 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 546 547 Buffer output; 548 size_t input_consumed; 549 AuthorizationSet output_params; 550 }; 551 552 struct FinishOperationRequest : public KeymasterMessage { FinishOperationRequestFinishOperationRequest553 explicit FinishOperationRequest(int32_t ver) : KeymasterMessage(ver) {} 554 555 size_t SerializedSize() const override; 556 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 557 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 558 559 keymaster_operation_handle_t op_handle; 560 Buffer input; 561 Buffer signature; 562 AuthorizationSet additional_params; 563 }; 564 565 struct FinishOperationResponse : public KeymasterResponse { FinishOperationResponseFinishOperationResponse566 explicit FinishOperationResponse(int32_t ver) : KeymasterResponse(ver) {} 567 568 size_t NonErrorSerializedSize() const override; 569 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 570 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 571 572 Buffer output; 573 AuthorizationSet output_params; 574 }; 575 576 struct AbortOperationRequest : public KeymasterMessage { AbortOperationRequestAbortOperationRequest577 explicit AbortOperationRequest(int32_t ver) : KeymasterMessage(ver) {} 578 SerializedSizeAbortOperationRequest579 size_t SerializedSize() const override { return sizeof(uint64_t); } SerializeAbortOperationRequest580 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 581 return append_uint64_to_buf(buf, end, op_handle); 582 } DeserializeAbortOperationRequest583 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 584 return copy_uint64_from_buf(buf_ptr, end, &op_handle); 585 } 586 587 keymaster_operation_handle_t op_handle; 588 }; 589 590 using AbortOperationResponse = EmptyKeymasterResponse; 591 592 struct AddEntropyRequest : public KeymasterMessage { AddEntropyRequestAddEntropyRequest593 explicit AddEntropyRequest(int32_t ver) : KeymasterMessage(ver) {} 594 595 size_t SerializedSize() const override; 596 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 597 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 598 599 Buffer random_data; 600 }; 601 602 using AddEntropyResponse = EmptyKeymasterResponse; 603 604 struct ImportKeyRequest : public KeymasterMessage { ImportKeyRequestImportKeyRequest605 explicit ImportKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 606 607 size_t SerializedSize() const override; 608 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 609 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 610 611 AuthorizationSet key_description; 612 keymaster_key_format_t key_format; 613 KeymasterKeyBlob key_data; 614 KeymasterKeyBlob attestation_signing_key_blob; 615 AuthorizationSet attest_key_params; 616 KeymasterBlob issuer_subject; 617 }; 618 619 struct ImportKeyResponse : public KeymasterResponse { ImportKeyResponseImportKeyResponse620 explicit ImportKeyResponse(int32_t ver) 621 : KeymasterResponse(ver), key_blob{}, certificate_chain{} {} 622 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialImportKeyResponse623 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 624 SetKeyMaterial(blob.key_material, blob.key_material_size); 625 } 626 627 size_t NonErrorSerializedSize() const override; 628 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 629 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 630 631 KeymasterKeyBlob key_blob; 632 AuthorizationSet enforced; 633 AuthorizationSet unenforced; 634 CertificateChain certificate_chain; 635 }; 636 637 struct ExportKeyRequest : public KeymasterMessage { ExportKeyRequestExportKeyRequest638 explicit ExportKeyRequest(int32_t ver) : KeymasterMessage(ver) { 639 key_blob.key_material = nullptr; 640 key_blob.key_material_size = 0; 641 } ~ExportKeyRequestExportKeyRequest642 ~ExportKeyRequest() { delete[] key_blob.key_material; } 643 644 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialExportKeyRequest645 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 646 SetKeyMaterial(blob.key_material, blob.key_material_size); 647 } 648 649 size_t SerializedSize() const override; 650 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 651 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 652 653 AuthorizationSet additional_params; 654 keymaster_key_format_t key_format; 655 keymaster_key_blob_t key_blob; 656 }; 657 658 struct ExportKeyResponse : public KeymasterResponse { ExportKeyResponseExportKeyResponse659 explicit ExportKeyResponse(int32_t ver) : KeymasterResponse(ver), key_data(nullptr) {} ~ExportKeyResponseExportKeyResponse660 ~ExportKeyResponse() { delete[] key_data; } 661 662 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialExportKeyResponse663 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 664 SetKeyMaterial(blob.key_material, blob.key_material_size); 665 } 666 667 size_t NonErrorSerializedSize() const override; 668 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 669 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 670 671 uint8_t* key_data; 672 size_t key_data_length; 673 }; 674 675 struct DeleteKeyRequest : public KeymasterMessage { DeleteKeyRequestDeleteKeyRequest676 explicit DeleteKeyRequest(int32_t ver) : KeymasterMessage(ver) { 677 key_blob.key_material = nullptr; 678 key_blob.key_material_size = 0; 679 } ~DeleteKeyRequestDeleteKeyRequest680 ~DeleteKeyRequest() { delete[] key_blob.key_material; } 681 682 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialDeleteKeyRequest683 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 684 SetKeyMaterial(blob.key_material, blob.key_material_size); 685 } 686 687 size_t SerializedSize() const override; 688 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 689 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 690 691 keymaster_key_blob_t key_blob; 692 }; 693 694 using DeleteKeyResponse = EmptyKeymasterResponse; 695 696 struct DeleteAllKeysRequest : public EmptyKeymasterRequest { DeleteAllKeysRequestDeleteAllKeysRequest697 explicit DeleteAllKeysRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 698 }; 699 700 using DeleteAllKeysResponse = EmptyKeymasterResponse; 701 702 struct DestroyAttestationIdsRequest : public EmptyKeymasterRequest { DestroyAttestationIdsRequestDestroyAttestationIdsRequest703 explicit DestroyAttestationIdsRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 704 }; 705 706 using DestroyAttestationIdsResponse = EmptyKeymasterResponse; 707 708 struct GetVersionRequest : public EmptyKeymasterRequest { 709 // GetVersionRequest ctor takes a version arg so it has the same signature as others, but the 710 // value is ignored because it is not not versionable. 711 explicit GetVersionRequest(uint32_t /* ver */ = 0) 712 : EmptyKeymasterRequest(0 /* not versionable */) {} 713 }; 714 715 struct GetVersionResponse : public KeymasterResponse { 716 // GetVersionResponse ctor takes a version arg so it has the same signature as others, but the 717 // value is ignored because it is not not versionable. 718 explicit GetVersionResponse(uint32_t /* ver */ = 0) 719 : KeymasterResponse(0 /* not versionable */), major_ver(0), minor_ver(0), subminor_ver(0) {} 720 721 size_t NonErrorSerializedSize() const override; 722 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 723 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 724 725 uint8_t major_ver; 726 uint8_t minor_ver; 727 uint8_t subminor_ver; 728 }; 729 730 struct AttestKeyRequest : public KeymasterMessage { AttestKeyRequestAttestKeyRequest731 explicit AttestKeyRequest(int32_t ver) : KeymasterMessage(ver) { 732 key_blob.key_material = nullptr; 733 key_blob.key_material_size = 0; 734 } 735 ~AttestKeyRequest(); 736 737 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialAttestKeyRequest738 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 739 SetKeyMaterial(blob.key_material, blob.key_material_size); 740 } 741 742 size_t SerializedSize() const override; 743 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 744 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 745 746 keymaster_key_blob_t key_blob; 747 AuthorizationSet attest_params; 748 }; 749 750 struct AttestKeyResponse : public KeymasterResponse { AttestKeyResponseAttestKeyResponse751 explicit AttestKeyResponse(int32_t ver) : KeymasterResponse(ver) {} 752 753 size_t NonErrorSerializedSize() const override; 754 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 755 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 756 757 CertificateChain certificate_chain; 758 }; 759 760 struct UpgradeKeyRequest : public KeymasterMessage { UpgradeKeyRequestUpgradeKeyRequest761 explicit UpgradeKeyRequest(int32_t ver) : KeymasterMessage(ver) { key_blob = {nullptr, 0}; } 762 ~UpgradeKeyRequest(); 763 764 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialUpgradeKeyRequest765 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 766 SetKeyMaterial(blob.key_material, blob.key_material_size); 767 } 768 769 size_t SerializedSize() const override; 770 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 771 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 772 773 keymaster_key_blob_t key_blob; 774 AuthorizationSet upgrade_params; 775 }; 776 777 struct UpgradeKeyResponse : public KeymasterResponse { UpgradeKeyResponseUpgradeKeyResponse778 explicit UpgradeKeyResponse(int32_t ver) : KeymasterResponse(ver) { 779 upgraded_key = {nullptr, 0}; 780 } 781 ~UpgradeKeyResponse(); 782 783 size_t NonErrorSerializedSize() const override; 784 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 785 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 786 787 keymaster_key_blob_t upgraded_key; 788 }; 789 790 struct ConfigureRequest : public KeymasterMessage { ConfigureRequestConfigureRequest791 explicit ConfigureRequest(int32_t ver) : KeymasterMessage(ver) {} 792 SerializedSizeConfigureRequest793 size_t SerializedSize() const override { return sizeof(os_version) + sizeof(os_patchlevel); } SerializeConfigureRequest794 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 795 buf = append_uint32_to_buf(buf, end, os_version); 796 return append_uint32_to_buf(buf, end, os_patchlevel); 797 } DeserializeConfigureRequest798 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 799 return copy_uint32_from_buf(buf_ptr, end, &os_version) && 800 copy_uint32_from_buf(buf_ptr, end, &os_patchlevel); 801 } 802 803 uint32_t os_version; 804 uint32_t os_patchlevel; // YYYYMM 805 }; 806 807 using ConfigureResponse = EmptyKeymasterResponse; 808 809 struct HmacSharingParameters : public Serializable { HmacSharingParametersHmacSharingParameters810 HmacSharingParameters() : seed({}) { memset(nonce, 0, sizeof(nonce)); } HmacSharingParametersHmacSharingParameters811 HmacSharingParameters(HmacSharingParameters&& other) { 812 seed = std::move(other.seed); 813 memcpy(nonce, other.nonce, sizeof(nonce)); 814 } 815 SetSeedHmacSharingParameters816 void SetSeed(KeymasterBlob&& value) { seed = std::move(value); } 817 818 size_t SerializedSize() const override; 819 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 820 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 821 822 KeymasterBlob seed{}; 823 uint8_t nonce[32]; 824 }; 825 826 struct HmacSharingParametersArray : public Serializable { HmacSharingParametersArrayHmacSharingParametersArray827 HmacSharingParametersArray() : params_array(nullptr), num_params(0) {} HmacSharingParametersArrayHmacSharingParametersArray828 HmacSharingParametersArray(HmacSharingParametersArray&& other) { 829 delete[] params_array; 830 params_array = other.params_array; 831 num_params = other.num_params; 832 other.params_array = nullptr; 833 other.num_params = 0; 834 } ~HmacSharingParametersArrayHmacSharingParametersArray835 ~HmacSharingParametersArray() override { delete[] params_array; } 836 837 size_t SerializedSize() const override; 838 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 839 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 840 841 HmacSharingParameters* params_array; 842 size_t num_params; 843 }; 844 845 struct GetHmacSharingParametersRequest : public EmptyKeymasterRequest { GetHmacSharingParametersRequestGetHmacSharingParametersRequest846 explicit GetHmacSharingParametersRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 847 }; 848 849 struct GetHmacSharingParametersResponse : public KeymasterResponse { GetHmacSharingParametersResponseGetHmacSharingParametersResponse850 explicit GetHmacSharingParametersResponse(int32_t ver) : KeymasterResponse(ver) {} GetHmacSharingParametersResponseGetHmacSharingParametersResponse851 GetHmacSharingParametersResponse(GetHmacSharingParametersResponse&& other) 852 : KeymasterResponse(other.message_version), params(std::move(other.params)) {} 853 SetSeedGetHmacSharingParametersResponse854 void SetSeed(KeymasterBlob&& seed_data) { params.SetSeed(std::move(seed_data)); } 855 NonErrorSerializedSizeGetHmacSharingParametersResponse856 size_t NonErrorSerializedSize() const override { return params.SerializedSize(); } NonErrorSerializeGetHmacSharingParametersResponse857 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 858 return params.Serialize(buf, end); 859 } NonErrorDeserializeGetHmacSharingParametersResponse860 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 861 return params.Deserialize(buf_ptr, end); 862 } 863 864 HmacSharingParameters params; 865 }; 866 867 struct ComputeSharedHmacRequest : public KeymasterMessage { ComputeSharedHmacRequestComputeSharedHmacRequest868 explicit ComputeSharedHmacRequest(int32_t ver) : KeymasterMessage(ver) {} 869 SerializedSizeComputeSharedHmacRequest870 size_t SerializedSize() const override { return params_array.SerializedSize(); } SerializeComputeSharedHmacRequest871 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 872 return params_array.Serialize(buf, end); 873 } DeserializeComputeSharedHmacRequest874 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 875 return params_array.Deserialize(buf_ptr, end); 876 } 877 878 HmacSharingParametersArray params_array; 879 }; 880 881 struct ComputeSharedHmacResponse : public KeymasterResponse { ComputeSharedHmacResponseComputeSharedHmacResponse882 explicit ComputeSharedHmacResponse(int32_t ver) : KeymasterResponse(ver) {} ComputeSharedHmacResponseComputeSharedHmacResponse883 ComputeSharedHmacResponse(ComputeSharedHmacResponse&& other) 884 : KeymasterResponse(other.message_version) { 885 sharing_check = std::move(other.sharing_check); 886 } 887 888 size_t NonErrorSerializedSize() const override; 889 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 890 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 891 892 KeymasterBlob sharing_check; 893 }; 894 895 struct ImportWrappedKeyRequest : public KeymasterMessage { ImportWrappedKeyRequestImportWrappedKeyRequest896 explicit ImportWrappedKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 897 898 void SetWrappedMaterial(const void* key_material, size_t length); 899 void SetWrappingMaterial(const void* key_material, size_t length); 900 void SetMaskingKeyMaterial(const void* key_material, size_t length); 901 SetKeyMaterialImportWrappedKeyRequest902 void SetKeyMaterial(const keymaster_key_blob_t& wrapped, const keymaster_key_blob_t& wrapping) { 903 SetWrappedMaterial(wrapped.key_material, wrapped.key_material_size); 904 SetWrappingMaterial(wrapping.key_material, wrapping.key_material_size); 905 } 906 907 size_t SerializedSize() const override; 908 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 909 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 910 911 KeymasterKeyBlob wrapped_key; 912 KeymasterKeyBlob wrapping_key; 913 KeymasterKeyBlob masking_key; 914 AuthorizationSet additional_params; 915 uint64_t password_sid; 916 uint64_t biometric_sid; 917 }; 918 919 struct ImportWrappedKeyResponse : public KeymasterResponse { 920 explicit ImportWrappedKeyResponse(int32_t ver = kDefaultMessageVersion) KeymasterResponseImportWrappedKeyResponse921 : KeymasterResponse(ver), key_blob{}, certificate_chain{} {} 922 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialImportWrappedKeyResponse923 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 924 SetKeyMaterial(blob.key_material, blob.key_material_size); 925 } 926 927 size_t NonErrorSerializedSize() const override; 928 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 929 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 930 931 KeymasterKeyBlob key_blob; 932 AuthorizationSet enforced; 933 AuthorizationSet unenforced; 934 CertificateChain certificate_chain; 935 }; 936 937 struct HardwareAuthToken : public Serializable { 938 HardwareAuthToken() = default; HardwareAuthTokenHardwareAuthToken939 HardwareAuthToken(HardwareAuthToken&& other) { 940 challenge = other.challenge; 941 user_id = other.user_id; 942 authenticator_id = other.authenticator_id; 943 authenticator_type = other.authenticator_type; 944 timestamp = other.timestamp; 945 mac = std::move(other.mac); 946 } 947 948 size_t SerializedSize() const override; 949 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 950 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 951 952 uint64_t challenge{}; 953 uint64_t user_id{}; 954 uint64_t authenticator_id{}; 955 hw_authenticator_type_t authenticator_type{}; 956 uint64_t timestamp{}; 957 KeymasterBlob mac; 958 }; 959 960 struct VerificationToken : public Serializable { 961 VerificationToken() = default; VerificationTokenVerificationToken962 VerificationToken(VerificationToken&& other) { 963 challenge = other.challenge; 964 timestamp = other.timestamp; 965 parameters_verified = std::move(other.parameters_verified); 966 security_level = other.security_level; 967 mac = std::move(other.mac); 968 } 969 970 size_t SerializedSize() const override; 971 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 972 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 973 974 uint64_t challenge{}; 975 uint64_t timestamp{}; 976 AuthorizationSet parameters_verified{}; 977 keymaster_security_level_t security_level{}; 978 KeymasterBlob mac{}; 979 }; 980 981 struct VerifyAuthorizationRequest : public KeymasterMessage { VerifyAuthorizationRequestVerifyAuthorizationRequest982 explicit VerifyAuthorizationRequest(int32_t ver) : KeymasterMessage(ver) {} 983 VerifyAuthorizationRequest(VerifyAuthorizationRequest&& other) = default; 984 SerializedSizeVerifyAuthorizationRequest985 size_t SerializedSize() const override { 986 return sizeof(challenge) + parameters_to_verify.SerializedSize() + 987 auth_token.SerializedSize(); 988 } 989 SerializeVerifyAuthorizationRequest990 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 991 buf = append_uint64_to_buf(buf, end, challenge); 992 buf = parameters_to_verify.Serialize(buf, end); 993 return auth_token.Serialize(buf, end); 994 } 995 DeserializeVerifyAuthorizationRequest996 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 997 return (copy_uint64_from_buf(buf_ptr, end, &challenge) && 998 parameters_to_verify.Deserialize(buf_ptr, end) && 999 auth_token.Deserialize(buf_ptr, end)); 1000 } 1001 1002 uint64_t challenge{}; 1003 AuthorizationSet parameters_to_verify; 1004 HardwareAuthToken auth_token; 1005 }; 1006 1007 struct VerifyAuthorizationResponse : public KeymasterResponse { VerifyAuthorizationResponseVerifyAuthorizationResponse1008 explicit VerifyAuthorizationResponse(int32_t ver) : KeymasterResponse(ver) {} 1009 VerifyAuthorizationResponse(VerifyAuthorizationResponse&& other) = default; 1010 NonErrorSerializedSizeVerifyAuthorizationResponse1011 size_t NonErrorSerializedSize() const override { 1012 return sizeof(error) + token.SerializedSize(); 1013 } NonErrorSerializeVerifyAuthorizationResponse1014 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 1015 buf = append_uint32_to_buf(buf, end, error); 1016 return token.Serialize(buf, end); 1017 } NonErrorDeserializeVerifyAuthorizationResponse1018 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1019 return copy_uint32_from_buf(buf_ptr, end, &error) && token.Deserialize(buf_ptr, end); 1020 } 1021 1022 VerificationToken token; 1023 }; 1024 1025 struct EarlyBootEndedRequest : public EmptyKeymasterRequest { EarlyBootEndedRequestEarlyBootEndedRequest1026 explicit EarlyBootEndedRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 1027 }; 1028 1029 struct EarlyBootEndedResponse : public KeymasterResponse { EarlyBootEndedResponseEarlyBootEndedResponse1030 explicit EarlyBootEndedResponse(int32_t ver) : KeymasterResponse(ver) {} 1031 NonErrorSerializedSizeEarlyBootEndedResponse1032 size_t NonErrorSerializedSize() const override { return 0; } NonErrorSerializeEarlyBootEndedResponse1033 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; } NonErrorDeserializeEarlyBootEndedResponse1034 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; } 1035 }; 1036 1037 struct DeviceLockedRequest : public KeymasterMessage { DeviceLockedRequestDeviceLockedRequest1038 explicit DeviceLockedRequest(int32_t ver) : KeymasterMessage(ver) {} DeviceLockedRequestDeviceLockedRequest1039 explicit DeviceLockedRequest(int32_t ver, bool passwordOnly_, VerificationToken&& token_) 1040 : KeymasterMessage(ver), passwordOnly(passwordOnly_), token(std::move(token_)) {} 1041 SerializedSizeDeviceLockedRequest1042 size_t SerializedSize() const override { return 1; } SerializeDeviceLockedRequest1043 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1044 if (buf < end) *buf++ = passwordOnly ? 1 : 0; 1045 return token.Serialize(buf, end); 1046 } DeserializeDeviceLockedRequest1047 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1048 if (*buf_ptr >= end) return false; 1049 passwordOnly = !!*(*buf_ptr)++; 1050 return token.Deserialize(buf_ptr, end); 1051 } 1052 1053 bool passwordOnly; 1054 VerificationToken token; 1055 }; 1056 1057 struct DeviceLockedResponse : public KeymasterResponse { DeviceLockedResponseDeviceLockedResponse1058 explicit DeviceLockedResponse(int32_t ver) : KeymasterResponse(ver) {} 1059 NonErrorSerializedSizeDeviceLockedResponse1060 size_t NonErrorSerializedSize() const override { return 0; } NonErrorSerializeDeviceLockedResponse1061 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; } NonErrorDeserializeDeviceLockedResponse1062 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; } 1063 }; 1064 1065 struct GetVersion2Request : public KeymasterMessage { 1066 // GetVersion2Request ctor takes a version arg so it has the same signature as others, but the 1067 // value is ignored because it's not versionable. 1068 explicit GetVersion2Request(uint32_t /* ver */ = 0) 1069 : KeymasterMessage(0 /* not versionable */) {} 1070 SerializedSizeGetVersion2Request1071 size_t SerializedSize() const override { return sizeof(uint32_t); /* max message version */ } SerializeGetVersion2Request1072 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1073 return append_uint32_to_buf(buf, end, max_message_version); 1074 } DeserializeGetVersion2Request1075 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1076 return copy_uint32_from_buf(buf_ptr, end, &max_message_version); 1077 } 1078 1079 uint32_t max_message_version = kDefaultMessageVersion; 1080 }; 1081 1082 struct GetVersion2Response : public KeymasterResponse { 1083 // GetVersion2Request ctor takes a version arg so it has the same signature as others, but the 1084 // value is ignored because it's not versionable. 1085 explicit GetVersion2Response(uint32_t /* ver */ = 0) 1086 : KeymasterResponse(0 /* not versionable */) {} 1087 1088 size_t NonErrorSerializedSize() const override; 1089 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override; 1090 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 1091 1092 uint32_t max_message_version; 1093 KmVersion km_version; 1094 uint32_t km_date; 1095 }; 1096 1097 struct TimestampToken : public Serializable { 1098 explicit TimestampToken() = default; TimestampTokenTimestampToken1099 TimestampToken(TimestampToken&& other) { 1100 challenge = other.challenge; 1101 timestamp = other.timestamp; 1102 security_level = other.security_level; 1103 mac = std::move(other.mac); 1104 } SerializedSizeTimestampToken1105 size_t SerializedSize() const override { 1106 return sizeof(challenge) + sizeof(timestamp) + sizeof(security_level) + 1107 mac.SerializedSize(); 1108 } SerializeTimestampToken1109 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1110 buf = append_uint64_to_buf(buf, end, challenge); 1111 buf = append_uint64_to_buf(buf, end, timestamp); 1112 buf = append_uint32_to_buf(buf, end, security_level); 1113 return mac.Serialize(buf, end); 1114 } DeserializeTimestampToken1115 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1116 return copy_uint64_from_buf(buf_ptr, end, &challenge) && 1117 copy_uint64_from_buf(buf_ptr, end, ×tamp) && 1118 copy_uint32_from_buf(buf_ptr, end, &security_level) && mac.Deserialize(buf_ptr, end); 1119 } 1120 uint64_t challenge{}; 1121 uint64_t timestamp{}; 1122 keymaster_security_level_t security_level{}; 1123 KeymasterBlob mac{}; 1124 }; 1125 1126 struct GenerateTimestampTokenRequest : public KeymasterMessage { GenerateTimestampTokenRequestGenerateTimestampTokenRequest1127 explicit GenerateTimestampTokenRequest(int32_t ver) : KeymasterMessage(ver), challenge{} {} SerializedSizeGenerateTimestampTokenRequest1128 size_t SerializedSize() const override { return sizeof(challenge); } SerializeGenerateTimestampTokenRequest1129 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1130 return append_uint64_to_buf(buf, end, challenge); 1131 } DeserializeGenerateTimestampTokenRequest1132 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1133 return copy_uint64_from_buf(buf_ptr, end, &challenge); 1134 } 1135 uint64_t challenge; 1136 }; 1137 1138 struct GenerateTimestampTokenResponse : public KeymasterResponse { GenerateTimestampTokenResponseGenerateTimestampTokenResponse1139 explicit GenerateTimestampTokenResponse(int32_t ver) : KeymasterResponse(ver), token{} {} NonErrorSerializedSizeGenerateTimestampTokenResponse1140 size_t NonErrorSerializedSize() const override { return token.SerializedSize(); } NonErrorSerializeGenerateTimestampTokenResponse1141 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 1142 return token.Serialize(buf, end); 1143 } NonErrorDeserializeGenerateTimestampTokenResponse1144 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1145 return token.Deserialize(buf_ptr, end); 1146 } 1147 TimestampToken token; 1148 }; 1149 1150 struct SetAttestationIdsRequest : public KeymasterMessage { SetAttestationIdsRequestSetAttestationIdsRequest1151 explicit SetAttestationIdsRequest(int32_t ver) : KeymasterMessage(ver) {} SerializedSizeSetAttestationIdsRequest1152 size_t SerializedSize() const override { 1153 return brand.SerializedSize() // 1154 + device.SerializedSize() // 1155 + product.SerializedSize() // 1156 + serial.SerializedSize() // 1157 + imei.SerializedSize() // 1158 + meid.SerializedSize() // 1159 + manufacturer.SerializedSize() // 1160 + model.SerializedSize(); 1161 } 1162 SerializeSetAttestationIdsRequest1163 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1164 buf = brand.Serialize(buf, end); 1165 buf = device.Serialize(buf, end); 1166 buf = product.Serialize(buf, end); 1167 buf = serial.Serialize(buf, end); 1168 buf = imei.Serialize(buf, end); 1169 buf = meid.Serialize(buf, end); 1170 buf = manufacturer.Serialize(buf, end); 1171 return model.Serialize(buf, end); 1172 } 1173 DeserializeSetAttestationIdsRequest1174 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1175 return brand.Deserialize(buf_ptr, end) // 1176 && device.Deserialize(buf_ptr, end) // 1177 && product.Deserialize(buf_ptr, end) // 1178 && serial.Deserialize(buf_ptr, end) // 1179 && imei.Deserialize(buf_ptr, end) // 1180 && meid.Deserialize(buf_ptr, end) // 1181 && manufacturer.Deserialize(buf_ptr, end) // 1182 && model.Deserialize(buf_ptr, end); // 1183 } 1184 1185 Buffer brand; 1186 Buffer device; 1187 Buffer product; 1188 Buffer serial; 1189 Buffer imei; 1190 Buffer meid; 1191 Buffer manufacturer; 1192 Buffer model; 1193 }; 1194 1195 using SetAttestationIdsResponse = EmptyKeymasterResponse; 1196 1197 struct SetAttestationIdsKM3Request : public KeymasterMessage { SetAttestationIdsKM3RequestSetAttestationIdsKM3Request1198 explicit SetAttestationIdsKM3Request(int32_t ver) : KeymasterMessage(ver), base(ver) {} SerializedSizeSetAttestationIdsKM3Request1199 size_t SerializedSize() const override { 1200 return base.SerializedSize() // 1201 + second_imei.SerializedSize(); 1202 } 1203 SerializeSetAttestationIdsKM3Request1204 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1205 buf = base.Serialize(buf, end); 1206 return second_imei.Serialize(buf, end); 1207 } 1208 DeserializeSetAttestationIdsKM3Request1209 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1210 return base.Deserialize(buf_ptr, end) // 1211 && second_imei.Deserialize(buf_ptr, end); // 1212 } 1213 1214 SetAttestationIdsRequest base; 1215 Buffer second_imei; 1216 }; 1217 1218 using SetAttestationIdsKM3Response = EmptyKeymasterResponse; 1219 1220 struct SetAdditionalAttestationInfoRequest : public KeymasterMessage { SetAdditionalAttestationInfoRequestSetAdditionalAttestationInfoRequest1221 explicit SetAdditionalAttestationInfoRequest(int32_t ver) : KeymasterMessage(ver) {} SerializedSizeSetAdditionalAttestationInfoRequest1222 size_t SerializedSize() const override { return info.SerializedSize(); } 1223 SerializeSetAdditionalAttestationInfoRequest1224 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1225 return info.Serialize(buf, end); 1226 } 1227 DeserializeSetAdditionalAttestationInfoRequest1228 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1229 return info.Deserialize(buf_ptr, end); 1230 } 1231 1232 AuthorizationSet info; 1233 }; 1234 1235 using SetAdditionalAttestationInfoResponse = EmptyKeymasterResponse; 1236 1237 struct ConfigureVendorPatchlevelRequest : public KeymasterMessage { ConfigureVendorPatchlevelRequestConfigureVendorPatchlevelRequest1238 explicit ConfigureVendorPatchlevelRequest(int32_t ver) : KeymasterMessage(ver) {} 1239 SerializedSizeConfigureVendorPatchlevelRequest1240 size_t SerializedSize() const override { return sizeof(vendor_patchlevel); } SerializeConfigureVendorPatchlevelRequest1241 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1242 return append_uint32_to_buf(buf, end, vendor_patchlevel); 1243 } DeserializeConfigureVendorPatchlevelRequest1244 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1245 return copy_uint32_from_buf(buf_ptr, end, &vendor_patchlevel); 1246 } 1247 1248 uint32_t vendor_patchlevel{}; // YYYYMMDD 1249 }; 1250 1251 using ConfigureVendorPatchlevelResponse = EmptyKeymasterResponse; 1252 1253 struct ConfigureBootPatchlevelRequest : public KeymasterMessage { ConfigureBootPatchlevelRequestConfigureBootPatchlevelRequest1254 explicit ConfigureBootPatchlevelRequest(int32_t ver) : KeymasterMessage(ver) {} 1255 SerializedSizeConfigureBootPatchlevelRequest1256 size_t SerializedSize() const override { return sizeof(boot_patchlevel); } SerializeConfigureBootPatchlevelRequest1257 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1258 return append_uint32_to_buf(buf, end, boot_patchlevel); 1259 } DeserializeConfigureBootPatchlevelRequest1260 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1261 return copy_uint32_from_buf(buf_ptr, end, &boot_patchlevel); 1262 } 1263 1264 uint32_t boot_patchlevel{}; // YYYYMMDD 1265 }; 1266 1267 using ConfigureBootPatchlevelResponse = EmptyKeymasterResponse; 1268 1269 struct ConfigureVerifiedBootInfoRequest : public KeymasterMessage { ConfigureVerifiedBootInfoRequestConfigureVerifiedBootInfoRequest1270 explicit ConfigureVerifiedBootInfoRequest(int32_t ver) 1271 : ConfigureVerifiedBootInfoRequest(ver, {}, {}, {}) {} 1272 ConfigureVerifiedBootInfoRequestConfigureVerifiedBootInfoRequest1273 ConfigureVerifiedBootInfoRequest(int32_t ver, std::string_view boot_state_param, 1274 std::string_view bootloader_state_param, 1275 std::vector<uint8_t> vbmeta_digest_param) 1276 : KeymasterMessage(ver), boot_state(boot_state_param), 1277 bootloader_state(bootloader_state_param), vbmeta_digest(std::move(vbmeta_digest_param)) {} 1278 SerializedSizeConfigureVerifiedBootInfoRequest1279 size_t SerializedSize() const override { 1280 return sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) // buffer sizes 1281 + boot_state.size() + bootloader_state.size() + vbmeta_digest.size(); 1282 } SerializeConfigureVerifiedBootInfoRequest1283 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1284 buf = append_collection_to_buf(buf, end, boot_state); 1285 buf = append_collection_to_buf(buf, end, bootloader_state); 1286 return append_collection_to_buf(buf, end, vbmeta_digest); 1287 } DeserializeConfigureVerifiedBootInfoRequest1288 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1289 return copy_collection_from_buf(buf_ptr, end, &boot_state) && 1290 copy_collection_from_buf(buf_ptr, end, &bootloader_state) && 1291 copy_collection_from_buf(buf_ptr, end, &vbmeta_digest); 1292 } 1293 1294 std::string boot_state; 1295 std::string bootloader_state; 1296 std::vector<uint8_t> vbmeta_digest; 1297 }; 1298 1299 using ConfigureVerifiedBootInfoResponse = EmptyKeymasterResponse; 1300 1301 struct GetRootOfTrustRequest : public KeymasterMessage { GetRootOfTrustRequestGetRootOfTrustRequest1302 explicit GetRootOfTrustRequest(int32_t ver) : GetRootOfTrustRequest(ver, {}) {} GetRootOfTrustRequestGetRootOfTrustRequest1303 GetRootOfTrustRequest(int32_t ver, std::vector<uint8_t> challenge_param) 1304 : KeymasterMessage(ver), challenge(std::move(challenge_param)){}; 1305 SerializedSizeGetRootOfTrustRequest1306 size_t SerializedSize() const override { return sizeof(uint32_t) + challenge.size(); } SerializeGetRootOfTrustRequest1307 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1308 return append_collection_to_buf(buf, end, challenge); 1309 } DeserializeGetRootOfTrustRequest1310 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1311 return copy_collection_from_buf(buf_ptr, end, &challenge); 1312 } 1313 1314 std::vector<uint8_t> challenge; 1315 }; 1316 1317 struct GetRootOfTrustResponse : public KeymasterResponse { GetRootOfTrustResponseGetRootOfTrustResponse1318 explicit GetRootOfTrustResponse(uint32_t ver) : GetRootOfTrustResponse(ver, {}) {} GetRootOfTrustResponseGetRootOfTrustResponse1319 GetRootOfTrustResponse(uint32_t ver, std::vector<uint8_t> rootOfTrust_param) 1320 : KeymasterResponse(ver), rootOfTrust(std::move(rootOfTrust_param)){}; 1321 NonErrorSerializedSizeGetRootOfTrustResponse1322 size_t NonErrorSerializedSize() const override { return sizeof(uint32_t) + rootOfTrust.size(); } NonErrorSerializeGetRootOfTrustResponse1323 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 1324 return append_collection_to_buf(buf, end, rootOfTrust); 1325 } NonErrorDeserializeGetRootOfTrustResponse1326 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1327 return copy_collection_from_buf(buf_ptr, end, &rootOfTrust); 1328 } 1329 1330 std::vector<uint8_t> rootOfTrust; 1331 }; 1332 1333 struct GetHwInfoRequest : public EmptyKeymasterRequest { GetHwInfoRequestGetHwInfoRequest1334 explicit GetHwInfoRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 1335 }; 1336 1337 struct GetHwInfoResponse : public KeymasterResponse { GetHwInfoResponseGetHwInfoResponse1338 explicit GetHwInfoResponse(int32_t ver) : KeymasterResponse(ver) {} 1339 NonErrorSerializedSizeGetHwInfoResponse1340 size_t NonErrorSerializedSize() const override { 1341 return sizeof(version) + sizeof(uint32_t) + rpcAuthorName.size() + 1342 sizeof(supportedEekCurve) + sizeof(uint32_t) + uniqueId.size() + 1343 sizeof(supportedNumKeysInCsr); 1344 } NonErrorSerializeGetHwInfoResponse1345 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 1346 buf = append_uint32_to_buf(buf, end, version); 1347 buf = append_collection_to_buf(buf, end, rpcAuthorName); 1348 buf = append_uint32_to_buf(buf, end, supportedEekCurve); 1349 buf = append_collection_to_buf(buf, end, uniqueId); 1350 return append_uint32_to_buf(buf, end, supportedNumKeysInCsr); 1351 } NonErrorDeserializeGetHwInfoResponse1352 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1353 return copy_uint32_from_buf(buf_ptr, end, &version) && 1354 copy_collection_from_buf(buf_ptr, end, &rpcAuthorName) && 1355 copy_uint32_from_buf(buf_ptr, end, &supportedEekCurve) && 1356 copy_collection_from_buf(buf_ptr, end, &uniqueId) && 1357 copy_uint32_from_buf(buf_ptr, end, &supportedNumKeysInCsr); 1358 } 1359 1360 uint32_t version; 1361 std::string rpcAuthorName; 1362 uint32_t supportedEekCurve; 1363 std::string uniqueId; 1364 uint32_t supportedNumKeysInCsr; 1365 }; 1366 1367 } // namespace keymaster 1368