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 <vector> 27 28 #include <keymaster/android_keymaster_utils.h> 29 #include <keymaster/authorization_set.h> 30 #include <keymaster/km_version.h> 31 32 namespace keymaster { 33 34 // Commands 35 enum AndroidKeymasterCommand : uint32_t { 36 GENERATE_KEY = 0, 37 BEGIN_OPERATION = 1, 38 UPDATE_OPERATION = 2, 39 FINISH_OPERATION = 3, 40 ABORT_OPERATION = 4, 41 IMPORT_KEY = 5, 42 EXPORT_KEY = 6, 43 GET_VERSION = 7, 44 ADD_RNG_ENTROPY = 8, 45 GET_SUPPORTED_ALGORITHMS = 9, 46 GET_SUPPORTED_BLOCK_MODES = 10, 47 GET_SUPPORTED_PADDING_MODES = 11, 48 GET_SUPPORTED_DIGESTS = 12, 49 GET_SUPPORTED_IMPORT_FORMATS = 13, 50 GET_SUPPORTED_EXPORT_FORMATS = 14, 51 GET_KEY_CHARACTERISTICS = 15, 52 ATTEST_KEY = 16, 53 UPGRADE_KEY = 17, 54 CONFIGURE = 18, 55 GET_HMAC_SHARING_PARAMETERS = 19, 56 COMPUTE_SHARED_HMAC = 20, 57 VERIFY_AUTHORIZATION = 21, 58 DELETE_KEY = 22, 59 DELETE_ALL_KEYS = 23, 60 DESTROY_ATTESTATION_IDS = 24, 61 IMPORT_WRAPPED_KEY = 25, 62 EARLY_BOOT_ENDED = 26, 63 DEVICE_LOCKED = 27, 64 GET_VERSION_2 = 28, 65 GENERATE_RKP_KEY = 29, 66 GENERATE_CSR = 30, 67 GENERATE_TIMESTAMP_TOKEN = 31, 68 CONFIGURE_VENDOR_PATCHLEVEL = 32, 69 CONFIGURE_BOOT_PATCHLEVEL = 33, 70 CONFIGURE_VERIFIED_BOOT_INFO = 34, 71 GET_ROOT_OF_TRUST = 35, 72 }; 73 74 /** 75 * Keymaster message versions are tied to keymaster versions. We map the keymaster version to a 76 * sequential "message version". The actual message formatting differences are implemented in the 77 * message classes. Note that it is not necessary to increase the message version when new messages 78 * are added, only when the serialized format of one or more messages changes. A message version 79 * argument is provided to the message constructor and when the serialization/deserialization 80 * methods are called the implementations of those methods should examine the message version and 81 * generate/parse the byte stream accordingly. 82 * 83 * The original design of message versioning uses the GetVersion message, sent from client (e.g. HAL 84 * service) to server (e.g. trusted app), and then relies on the client to identify what messages to 85 * send. This architecture assumes that the client is never older than the server. This assumption 86 * turned out not to be true in general. 87 * 88 * The current approach performs a mutual exchange of message version info between client and 89 * server, using the GetVersion2 message. In addition, it defers the specification of the message 90 * ID to the message classes, so a message class can use a different ID when necessary. ID changes 91 * should be rare, in fact the only time they should be required is during the switch from 92 * GetVersion to GetVersion2. 93 * 94 * Assuming both client and server support GetVersion2, the approach is as follows: 95 * 96 * 1. Client sends GetVersion2Request, containing its maximum message version, c_max. 97 * 2. Server replies with GetVersion2Response, containing its maximum message version, s_max. 98 * 3. Both sides proceed to create all messages with version min(c_max, s_max). 99 * 100 * To enable this, the client must always send GetVersion2 as its first message. If the server 101 * doesn't support GetVersion2, it will reply with an error of some sort (the details are likely 102 * environment-specific). If the client gets this error, it must respond by sending GetVersion, and 103 * then must configure its message version according to the response. Note that an acceptable 104 * response to a too-old server version is to return an error to the caller of the client, informing 105 * it of the problem. 106 * 107 * On the server side, a server that supports GetVersion2 must also support GetVersion. If it 108 * received GetVersion2 it should proceed as outline above, and expect that the client will not send 109 * GetVersion. If it received GetVersion, it must assume that the client does not support 110 * GetVersion2 and reply that it is version 2.0.0 and use the corresponding message version (3). 111 */ 112 constexpr int32_t kInvalidMessageVersion = -1; 113 constexpr int32_t kMaxMessageVersion = 4; 114 constexpr int32_t kDefaultMessageVersion = 3; 115 116 /** 117 * MessageVersion returns the message version for a specified KM version and, possibly, KM release 118 * date in YYYYMMDD format (it's not recommended to change message formats within a KM version, but 119 * it could happen). 120 */ 121 inline int32_t MessageVersion(KmVersion version, uint32_t /* km_date */ = 0) { 122 switch (version) { 123 case KmVersion::KEYMASTER_1: 124 return 1; 125 case KmVersion::KEYMASTER_1_1: 126 return 2; 127 case KmVersion::KEYMASTER_2: 128 case KmVersion::KEYMASTER_3: 129 case KmVersion::KEYMASTER_4: 130 case KmVersion::KEYMASTER_4_1: 131 return 3; 132 case KmVersion::KEYMINT_1: 133 case KmVersion::KEYMINT_2: 134 return 4; 135 } 136 return kInvalidMessageVersion; 137 } 138 139 /** 140 * NegotiateMessageVersion implements the client side of the GetVersion protocol, determining the 141 * appropriate message version from the values returned by the server. 142 */ 143 struct GetVersionResponse; 144 int32_t NegotiateMessageVersion(const GetVersionResponse& response, keymaster_error_t* error); 145 146 /** 147 * This MessageVersion overload determines the message version to use given the provided client and 148 * server messages. If the client gets an error when it sends GetVersion2Request, it should send 149 * GetVersionRequest and use the above overload. If the server receives GetVersionRequest, it 150 * should assume it should use message version 3 and return GetVersionResponse(2, 0, 0). 151 */ 152 struct GetVersion2Request; 153 struct GetVersion2Response; 154 int32_t NegotiateMessageVersion(const GetVersion2Request& request, 155 const GetVersion2Response& response); 156 157 struct KeymasterMessage : public Serializable { KeymasterMessageKeymasterMessage158 explicit KeymasterMessage(int32_t ver) : message_version(ver) { assert(ver >= 0); } 159 160 // The message version that should be used for this message. This indicates how the data is 161 // serialized/deserialized. Commonly, higher message versions serialize/deserialize additional 162 // arguments, though there is no specific rule limiting later version to adding parameters. 163 const int32_t message_version; 164 }; 165 166 /** 167 * All responses include an error value, and if the error is not KM_ERROR_OK, return no additional 168 * data. 169 */ 170 struct KeymasterResponse : public KeymasterMessage { KeymasterResponseKeymasterResponse171 explicit KeymasterResponse(int32_t ver) 172 : KeymasterMessage(ver), error(KM_ERROR_UNKNOWN_ERROR) {} 173 174 size_t SerializedSize() const override; 175 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 176 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 177 178 virtual size_t NonErrorSerializedSize() const = 0; 179 virtual uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const = 0; 180 virtual bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) = 0; 181 182 keymaster_error_t error; 183 }; 184 185 // Abstract base for empty requests. 186 struct EmptyKeymasterRequest : public KeymasterMessage { EmptyKeymasterRequestEmptyKeymasterRequest187 explicit EmptyKeymasterRequest(int32_t ver) : KeymasterMessage(ver) {} 188 SerializedSizeEmptyKeymasterRequest189 size_t SerializedSize() const override { return 0; } SerializeEmptyKeymasterRequest190 uint8_t* Serialize(uint8_t* buf, const uint8_t*) const override { return buf; } DeserializeEmptyKeymasterRequest191 bool Deserialize(const uint8_t**, const uint8_t*) override { return true; }; 192 }; 193 194 // Empty response. 195 struct EmptyKeymasterResponse : public KeymasterResponse { EmptyKeymasterResponseEmptyKeymasterResponse196 explicit EmptyKeymasterResponse(int32_t ver) : KeymasterResponse(ver) {} 197 NonErrorSerializedSizeEmptyKeymasterResponse198 size_t NonErrorSerializedSize() const override { return 0; } NonErrorSerializeEmptyKeymasterResponse199 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; } NonErrorDeserializeEmptyKeymasterResponse200 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; } 201 }; 202 203 // TODO(swillden): Remove when Keymaster1 is deleted 204 struct SupportedAlgorithmsRequest : public KeymasterMessage { SupportedAlgorithmsRequestSupportedAlgorithmsRequest205 explicit SupportedAlgorithmsRequest(int32_t ver) : KeymasterMessage(ver) {} 206 SerializedSizeSupportedAlgorithmsRequest207 size_t SerializedSize() const override { return 0; }; SerializeSupportedAlgorithmsRequest208 uint8_t* Serialize(uint8_t* buf, const uint8_t* /* end */) const override { return buf; } DeserializeSupportedAlgorithmsRequest209 bool Deserialize(const uint8_t** /* buf_ptr */, const uint8_t* /* end */) override { 210 return true; 211 } 212 }; 213 214 // TODO(swillden): Remove when Keymaster1 is deleted 215 struct SupportedByAlgorithmRequest : public KeymasterMessage { SupportedByAlgorithmRequestSupportedByAlgorithmRequest216 explicit SupportedByAlgorithmRequest(int32_t ver) : KeymasterMessage(ver) {} 217 SerializedSizeSupportedByAlgorithmRequest218 size_t SerializedSize() const override { return sizeof(uint32_t); }; SerializeSupportedByAlgorithmRequest219 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 220 return append_uint32_to_buf(buf, end, algorithm); 221 } DeserializeSupportedByAlgorithmRequest222 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 223 return copy_uint32_from_buf(buf_ptr, end, &algorithm); 224 } 225 226 keymaster_algorithm_t algorithm; 227 }; 228 229 // TODO(swillden): Remove when Keymaster1 is deleted 230 struct SupportedImportFormatsRequest : public SupportedByAlgorithmRequest { SupportedImportFormatsRequestSupportedImportFormatsRequest231 explicit SupportedImportFormatsRequest(int32_t ver) : SupportedByAlgorithmRequest(ver) {} 232 }; 233 234 // TODO(swillden): Remove when Keymaster1 is deleted 235 struct SupportedExportFormatsRequest : public SupportedByAlgorithmRequest { SupportedExportFormatsRequestSupportedExportFormatsRequest236 explicit SupportedExportFormatsRequest(int32_t ver) : SupportedByAlgorithmRequest(ver) {} 237 }; 238 239 // TODO(swillden): Remove when Keymaster1 is deleted 240 struct SupportedByAlgorithmAndPurposeRequest : public KeymasterMessage { SupportedByAlgorithmAndPurposeRequestSupportedByAlgorithmAndPurposeRequest241 explicit SupportedByAlgorithmAndPurposeRequest(int32_t ver) : KeymasterMessage(ver) {} 242 SerializedSizeSupportedByAlgorithmAndPurposeRequest243 size_t SerializedSize() const override { return sizeof(uint32_t) * 2; }; SerializeSupportedByAlgorithmAndPurposeRequest244 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 245 buf = append_uint32_to_buf(buf, end, algorithm); 246 return append_uint32_to_buf(buf, end, purpose); 247 } DeserializeSupportedByAlgorithmAndPurposeRequest248 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 249 return copy_uint32_from_buf(buf_ptr, end, &algorithm) && 250 copy_uint32_from_buf(buf_ptr, end, &purpose); 251 } 252 253 keymaster_algorithm_t algorithm; 254 keymaster_purpose_t purpose; 255 }; 256 257 // TODO(swillden): Remove when Keymaster1 is deleted 258 struct SupportedBlockModesRequest : public SupportedByAlgorithmAndPurposeRequest { SupportedBlockModesRequestSupportedBlockModesRequest259 explicit SupportedBlockModesRequest(int32_t ver) : SupportedByAlgorithmAndPurposeRequest(ver) {} 260 }; 261 262 // TODO(swillden): Remove when Keymaster1 is deleted 263 struct SupportedPaddingModesRequest : public SupportedByAlgorithmAndPurposeRequest { SupportedPaddingModesRequestSupportedPaddingModesRequest264 explicit SupportedPaddingModesRequest(int32_t ver) 265 : SupportedByAlgorithmAndPurposeRequest(ver) {} 266 }; 267 268 // TODO(swillden): Remove when Keymaster1 is deleted 269 struct SupportedDigestsRequest : public SupportedByAlgorithmAndPurposeRequest { SupportedDigestsRequestSupportedDigestsRequest270 explicit SupportedDigestsRequest(int32_t ver) : SupportedByAlgorithmAndPurposeRequest(ver) {} 271 }; 272 273 // TODO(swillden): Remove when Keymaster1 is deleted 274 template <typename T> struct SupportedResponse : public KeymasterResponse { SupportedResponseSupportedResponse275 explicit SupportedResponse(int32_t ver) 276 : KeymasterResponse(ver), results(nullptr), results_length(0) {} ~SupportedResponseSupportedResponse277 ~SupportedResponse() { delete[] results; } 278 SetResultsSupportedResponse279 template <size_t N> void SetResults(const T (&arr)[N]) { SetResults(arr, N); } 280 SetResultsSupportedResponse281 void SetResults(const T* arr, size_t n) { 282 delete[] results; 283 results_length = 0; 284 results = dup_array(arr, n); 285 if (results == nullptr) { 286 error = KM_ERROR_MEMORY_ALLOCATION_FAILED; 287 } else { 288 results_length = n; 289 error = KM_ERROR_OK; 290 } 291 } 292 NonErrorSerializedSizeSupportedResponse293 size_t NonErrorSerializedSize() const override { 294 return sizeof(uint32_t) + results_length * sizeof(uint32_t); 295 } NonErrorSerializeSupportedResponse296 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 297 return append_uint32_array_to_buf(buf, end, results, results_length); 298 } NonErrorDeserializeSupportedResponse299 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 300 delete[] results; 301 results = nullptr; 302 UniquePtr<T[]> tmp; 303 if (!copy_uint32_array_from_buf(buf_ptr, end, &tmp, &results_length)) return false; 304 results = tmp.release(); 305 return true; 306 } 307 308 T* results; 309 size_t results_length; 310 }; 311 312 // TODO(swillden): Remove when Keymaster1 is deleted 313 struct SupportedAlgorithmsResponse : public SupportedResponse<keymaster_algorithm_t> { SupportedAlgorithmsResponseSupportedAlgorithmsResponse314 explicit SupportedAlgorithmsResponse(int32_t ver) 315 : SupportedResponse<keymaster_algorithm_t>(ver) {} 316 }; 317 318 // TODO(swillden): Remove when Keymaster1 is deleted 319 struct SupportedBlockModesResponse : public SupportedResponse<keymaster_block_mode_t> { SupportedBlockModesResponseSupportedBlockModesResponse320 explicit SupportedBlockModesResponse(int32_t ver) 321 : SupportedResponse<keymaster_block_mode_t>(ver) {} 322 }; 323 324 // TODO(swillden): Remove when Keymaster1 is deleted 325 struct SupportedPaddingModesResponse : public SupportedResponse<keymaster_padding_t> { SupportedPaddingModesResponseSupportedPaddingModesResponse326 explicit SupportedPaddingModesResponse(int32_t ver) 327 : SupportedResponse<keymaster_padding_t>(ver) {} 328 }; 329 330 // TODO(swillden): Remove when Keymaster1 is deleted 331 struct SupportedDigestsResponse : public SupportedResponse<keymaster_digest_t> { SupportedDigestsResponseSupportedDigestsResponse332 explicit SupportedDigestsResponse(int32_t ver) : SupportedResponse<keymaster_digest_t>(ver) {} 333 }; 334 335 // TODO(swillden): Remove when Keymaster1 is deleted 336 struct SupportedImportFormatsResponse : public SupportedResponse<keymaster_key_format_t> { SupportedImportFormatsResponseSupportedImportFormatsResponse337 explicit SupportedImportFormatsResponse(int32_t ver) 338 : SupportedResponse<keymaster_key_format_t>(ver) {} 339 }; 340 341 // TODO(swillden): Remove when Keymaster1 is deleted 342 struct SupportedExportFormatsResponse : public SupportedResponse<keymaster_key_format_t> { SupportedExportFormatsResponseSupportedExportFormatsResponse343 explicit SupportedExportFormatsResponse(int32_t ver) 344 : SupportedResponse<keymaster_key_format_t>(ver) {} 345 }; 346 347 struct GenerateKeyRequest : public KeymasterMessage { GenerateKeyRequestGenerateKeyRequest348 explicit GenerateKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 349 350 size_t SerializedSize() const override; 351 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 352 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 353 354 AuthorizationSet key_description; 355 KeymasterKeyBlob attestation_signing_key_blob; 356 AuthorizationSet attest_key_params; 357 KeymasterBlob issuer_subject; 358 }; 359 360 struct GenerateKeyResponse : public KeymasterResponse { GenerateKeyResponseGenerateKeyResponse361 explicit GenerateKeyResponse(int32_t ver) 362 : KeymasterResponse(ver), key_blob{}, certificate_chain{} {} 363 364 size_t NonErrorSerializedSize() const override; 365 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 366 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 367 368 KeymasterKeyBlob key_blob; 369 AuthorizationSet enforced; 370 AuthorizationSet unenforced; 371 CertificateChain certificate_chain; 372 }; 373 374 struct GenerateRkpKeyRequest : KeymasterMessage { GenerateRkpKeyRequestGenerateRkpKeyRequest375 explicit GenerateRkpKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 376 SerializedSizeGenerateRkpKeyRequest377 size_t SerializedSize() const override { return sizeof(uint8_t); } SerializeGenerateRkpKeyRequest378 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 379 return append_to_buf(buf, end, &test_mode, sizeof(uint8_t)); 380 } DeserializeGenerateRkpKeyRequest381 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 382 return copy_from_buf(buf_ptr, end, &test_mode, sizeof(uint8_t)); 383 } 384 385 bool test_mode = false; 386 }; 387 388 struct GenerateRkpKeyResponse : public KeymasterResponse { GenerateRkpKeyResponseGenerateRkpKeyResponse389 explicit GenerateRkpKeyResponse(int32_t ver) : KeymasterResponse(ver) {} 390 391 size_t NonErrorSerializedSize() const override; 392 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 393 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 394 395 KeymasterKeyBlob key_blob; 396 KeymasterBlob maced_public_key; 397 }; 398 399 struct GenerateCsrRequest : public KeymasterMessage { GenerateCsrRequestGenerateCsrRequest400 explicit GenerateCsrRequest(int32_t ver) : KeymasterMessage(ver) {} 401 ~GenerateCsrRequestGenerateCsrRequest402 ~GenerateCsrRequest() override { delete[] keys_to_sign_array; } 403 404 size_t SerializedSize() const override; 405 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 406 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 407 void SetKeyToSign(uint32_t index, const void* data, size_t length); 408 void SetEndpointEncCertChain(const void* data, size_t length); 409 void SetChallenge(const void* data, size_t length); 410 411 bool test_mode = false; 412 size_t num_keys = 0; 413 KeymasterBlob* keys_to_sign_array = nullptr; 414 KeymasterBlob endpoint_enc_cert_chain; 415 KeymasterBlob challenge; 416 }; 417 418 struct GenerateCsrResponse : public KeymasterResponse { GenerateCsrResponseGenerateCsrResponse419 explicit GenerateCsrResponse(int32_t ver) : KeymasterResponse(ver) {} 420 421 size_t NonErrorSerializedSize() const override; 422 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 423 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 424 425 KeymasterBlob keys_to_sign_mac; 426 KeymasterBlob device_info_blob; 427 KeymasterBlob protected_data_blob; 428 }; 429 430 struct GetKeyCharacteristicsRequest : public KeymasterMessage { GetKeyCharacteristicsRequestGetKeyCharacteristicsRequest431 explicit GetKeyCharacteristicsRequest(int32_t ver) : KeymasterMessage(ver) { 432 key_blob.key_material = nullptr; 433 key_blob.key_material_size = 0; 434 } 435 ~GetKeyCharacteristicsRequest(); 436 437 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialGetKeyCharacteristicsRequest438 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 439 SetKeyMaterial(blob.key_material, blob.key_material_size); 440 } 441 442 size_t SerializedSize() const override; 443 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 444 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 445 446 keymaster_key_blob_t key_blob; 447 AuthorizationSet additional_params; 448 }; 449 450 struct GetKeyCharacteristicsResponse : public KeymasterResponse { GetKeyCharacteristicsResponseGetKeyCharacteristicsResponse451 explicit GetKeyCharacteristicsResponse(int32_t ver) : KeymasterResponse(ver) {} 452 453 size_t NonErrorSerializedSize() const override; 454 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 455 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 456 457 AuthorizationSet enforced; 458 AuthorizationSet unenforced; 459 }; 460 461 struct BeginOperationRequest : public KeymasterMessage { BeginOperationRequestBeginOperationRequest462 explicit BeginOperationRequest(int32_t ver) : KeymasterMessage(ver) { 463 key_blob.key_material = nullptr; 464 key_blob.key_material_size = 0; 465 } ~BeginOperationRequestBeginOperationRequest466 ~BeginOperationRequest() { delete[] key_blob.key_material; } 467 468 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialBeginOperationRequest469 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 470 SetKeyMaterial(blob.key_material, blob.key_material_size); 471 } 472 473 size_t SerializedSize() const override; 474 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 475 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 476 477 keymaster_purpose_t purpose; 478 keymaster_key_blob_t key_blob; 479 AuthorizationSet additional_params; 480 }; 481 482 struct BeginOperationResponse : public KeymasterResponse { BeginOperationResponseBeginOperationResponse483 explicit BeginOperationResponse(int32_t ver) : KeymasterResponse(ver) {} 484 485 size_t NonErrorSerializedSize() const override; 486 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 487 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 488 489 keymaster_operation_handle_t op_handle; 490 AuthorizationSet output_params; 491 }; 492 493 struct UpdateOperationRequest : public KeymasterMessage { UpdateOperationRequestUpdateOperationRequest494 explicit UpdateOperationRequest(int32_t ver) : KeymasterMessage(ver) {} 495 496 size_t SerializedSize() const override; 497 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 498 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 499 500 keymaster_operation_handle_t op_handle; 501 Buffer input; 502 AuthorizationSet additional_params; 503 }; 504 505 struct UpdateOperationResponse : public KeymasterResponse { UpdateOperationResponseUpdateOperationResponse506 explicit UpdateOperationResponse(int32_t ver) : KeymasterResponse(ver), input_consumed(0) {} 507 508 size_t NonErrorSerializedSize() const override; 509 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 510 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 511 512 Buffer output; 513 size_t input_consumed; 514 AuthorizationSet output_params; 515 }; 516 517 struct FinishOperationRequest : public KeymasterMessage { FinishOperationRequestFinishOperationRequest518 explicit FinishOperationRequest(int32_t ver) : KeymasterMessage(ver) {} 519 520 size_t SerializedSize() const override; 521 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 522 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 523 524 keymaster_operation_handle_t op_handle; 525 Buffer input; 526 Buffer signature; 527 AuthorizationSet additional_params; 528 }; 529 530 struct FinishOperationResponse : public KeymasterResponse { FinishOperationResponseFinishOperationResponse531 explicit FinishOperationResponse(int32_t ver) : KeymasterResponse(ver) {} 532 533 size_t NonErrorSerializedSize() const override; 534 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 535 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 536 537 Buffer output; 538 AuthorizationSet output_params; 539 }; 540 541 struct AbortOperationRequest : public KeymasterMessage { AbortOperationRequestAbortOperationRequest542 explicit AbortOperationRequest(int32_t ver) : KeymasterMessage(ver) {} 543 SerializedSizeAbortOperationRequest544 size_t SerializedSize() const override { return sizeof(uint64_t); } SerializeAbortOperationRequest545 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 546 return append_uint64_to_buf(buf, end, op_handle); 547 } DeserializeAbortOperationRequest548 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 549 return copy_uint64_from_buf(buf_ptr, end, &op_handle); 550 } 551 552 keymaster_operation_handle_t op_handle; 553 }; 554 555 using AbortOperationResponse = EmptyKeymasterResponse; 556 557 struct AddEntropyRequest : public KeymasterMessage { AddEntropyRequestAddEntropyRequest558 explicit AddEntropyRequest(int32_t ver) : KeymasterMessage(ver) {} 559 560 size_t SerializedSize() const override; 561 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 562 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 563 564 Buffer random_data; 565 }; 566 567 using AddEntropyResponse = EmptyKeymasterResponse; 568 569 struct ImportKeyRequest : public KeymasterMessage { ImportKeyRequestImportKeyRequest570 explicit ImportKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 571 572 size_t SerializedSize() const override; 573 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 574 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 575 576 AuthorizationSet key_description; 577 keymaster_key_format_t key_format; 578 KeymasterKeyBlob key_data; 579 KeymasterKeyBlob attestation_signing_key_blob; 580 AuthorizationSet attest_key_params; 581 KeymasterBlob issuer_subject; 582 }; 583 584 struct ImportKeyResponse : public KeymasterResponse { ImportKeyResponseImportKeyResponse585 explicit ImportKeyResponse(int32_t ver) 586 : KeymasterResponse(ver), key_blob{}, certificate_chain{} {} 587 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialImportKeyResponse588 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 589 SetKeyMaterial(blob.key_material, blob.key_material_size); 590 } 591 592 size_t NonErrorSerializedSize() const override; 593 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 594 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 595 596 KeymasterKeyBlob key_blob; 597 AuthorizationSet enforced; 598 AuthorizationSet unenforced; 599 CertificateChain certificate_chain; 600 }; 601 602 struct ExportKeyRequest : public KeymasterMessage { ExportKeyRequestExportKeyRequest603 explicit ExportKeyRequest(int32_t ver) : KeymasterMessage(ver) { 604 key_blob.key_material = nullptr; 605 key_blob.key_material_size = 0; 606 } ~ExportKeyRequestExportKeyRequest607 ~ExportKeyRequest() { delete[] key_blob.key_material; } 608 609 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialExportKeyRequest610 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 611 SetKeyMaterial(blob.key_material, blob.key_material_size); 612 } 613 614 size_t SerializedSize() const override; 615 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 616 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 617 618 AuthorizationSet additional_params; 619 keymaster_key_format_t key_format; 620 keymaster_key_blob_t key_blob; 621 }; 622 623 struct ExportKeyResponse : public KeymasterResponse { ExportKeyResponseExportKeyResponse624 explicit ExportKeyResponse(int32_t ver) : KeymasterResponse(ver), key_data(nullptr) {} ~ExportKeyResponseExportKeyResponse625 ~ExportKeyResponse() { delete[] key_data; } 626 627 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialExportKeyResponse628 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 629 SetKeyMaterial(blob.key_material, blob.key_material_size); 630 } 631 632 size_t NonErrorSerializedSize() const override; 633 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 634 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 635 636 uint8_t* key_data; 637 size_t key_data_length; 638 }; 639 640 struct DeleteKeyRequest : public KeymasterMessage { DeleteKeyRequestDeleteKeyRequest641 explicit DeleteKeyRequest(int32_t ver) : KeymasterMessage(ver) { 642 key_blob.key_material = nullptr; 643 key_blob.key_material_size = 0; 644 } ~DeleteKeyRequestDeleteKeyRequest645 ~DeleteKeyRequest() { delete[] key_blob.key_material; } 646 647 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialDeleteKeyRequest648 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 649 SetKeyMaterial(blob.key_material, blob.key_material_size); 650 } 651 652 size_t SerializedSize() const override; 653 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 654 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 655 656 keymaster_key_blob_t key_blob; 657 }; 658 659 using DeleteKeyResponse = EmptyKeymasterResponse; 660 661 struct DeleteAllKeysRequest : public EmptyKeymasterRequest { DeleteAllKeysRequestDeleteAllKeysRequest662 explicit DeleteAllKeysRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 663 }; 664 665 using DeleteAllKeysResponse = EmptyKeymasterResponse; 666 667 struct GetVersionRequest : public EmptyKeymasterRequest { 668 // GetVersionRequest ctor takes a version arg so it has the same signature as others, but the 669 // value is ignored because it is not not versionable. 670 explicit GetVersionRequest(uint32_t /* ver */ = 0) 671 : EmptyKeymasterRequest(0 /* not versionable */) {} 672 }; 673 674 struct GetVersionResponse : public KeymasterResponse { 675 // GetVersionResponse ctor takes a version arg so it has the same signature as others, but the 676 // value is ignored because it is not not versionable. 677 explicit GetVersionResponse(uint32_t /* ver */ = 0) 678 : KeymasterResponse(0 /* not versionable */), major_ver(0), minor_ver(0), subminor_ver(0) {} 679 680 size_t NonErrorSerializedSize() const override; 681 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 682 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 683 684 uint8_t major_ver; 685 uint8_t minor_ver; 686 uint8_t subminor_ver; 687 }; 688 689 struct AttestKeyRequest : public KeymasterMessage { AttestKeyRequestAttestKeyRequest690 explicit AttestKeyRequest(int32_t ver) : KeymasterMessage(ver) { 691 key_blob.key_material = nullptr; 692 key_blob.key_material_size = 0; 693 } 694 ~AttestKeyRequest(); 695 696 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialAttestKeyRequest697 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 698 SetKeyMaterial(blob.key_material, blob.key_material_size); 699 } 700 701 size_t SerializedSize() const override; 702 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 703 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 704 705 keymaster_key_blob_t key_blob; 706 AuthorizationSet attest_params; 707 }; 708 709 struct AttestKeyResponse : public KeymasterResponse { AttestKeyResponseAttestKeyResponse710 explicit AttestKeyResponse(int32_t ver) : KeymasterResponse(ver) {} 711 712 size_t NonErrorSerializedSize() const override; 713 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 714 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 715 716 CertificateChain certificate_chain; 717 }; 718 719 struct UpgradeKeyRequest : public KeymasterMessage { UpgradeKeyRequestUpgradeKeyRequest720 explicit UpgradeKeyRequest(int32_t ver) : KeymasterMessage(ver) { key_blob = {nullptr, 0}; } 721 ~UpgradeKeyRequest(); 722 723 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialUpgradeKeyRequest724 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 725 SetKeyMaterial(blob.key_material, blob.key_material_size); 726 } 727 728 size_t SerializedSize() const override; 729 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 730 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 731 732 keymaster_key_blob_t key_blob; 733 AuthorizationSet upgrade_params; 734 }; 735 736 struct UpgradeKeyResponse : public KeymasterResponse { UpgradeKeyResponseUpgradeKeyResponse737 explicit UpgradeKeyResponse(int32_t ver) : KeymasterResponse(ver) { 738 upgraded_key = {nullptr, 0}; 739 } 740 ~UpgradeKeyResponse(); 741 742 size_t NonErrorSerializedSize() const override; 743 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 744 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 745 746 keymaster_key_blob_t upgraded_key; 747 }; 748 749 struct ConfigureRequest : public KeymasterMessage { ConfigureRequestConfigureRequest750 explicit ConfigureRequest(int32_t ver) : KeymasterMessage(ver) {} 751 SerializedSizeConfigureRequest752 size_t SerializedSize() const override { return sizeof(os_version) + sizeof(os_patchlevel); } SerializeConfigureRequest753 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 754 buf = append_uint32_to_buf(buf, end, os_version); 755 return append_uint32_to_buf(buf, end, os_patchlevel); 756 } DeserializeConfigureRequest757 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 758 return copy_uint32_from_buf(buf_ptr, end, &os_version) && 759 copy_uint32_from_buf(buf_ptr, end, &os_patchlevel); 760 } 761 762 uint32_t os_version; 763 uint32_t os_patchlevel; // YYYYMM 764 }; 765 766 using ConfigureResponse = EmptyKeymasterResponse; 767 768 struct HmacSharingParameters : public Serializable { HmacSharingParametersHmacSharingParameters769 HmacSharingParameters() : seed({}) { memset(nonce, 0, sizeof(nonce)); } HmacSharingParametersHmacSharingParameters770 HmacSharingParameters(HmacSharingParameters&& other) { 771 seed = move(other.seed); 772 memcpy(nonce, other.nonce, sizeof(nonce)); 773 } 774 SetSeedHmacSharingParameters775 void SetSeed(KeymasterBlob&& value) { seed = move(value); } 776 777 size_t SerializedSize() const override; 778 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 779 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 780 781 KeymasterBlob seed{}; 782 uint8_t nonce[32]; 783 }; 784 785 struct HmacSharingParametersArray : public Serializable { HmacSharingParametersArrayHmacSharingParametersArray786 HmacSharingParametersArray() : params_array(nullptr), num_params(0) {} HmacSharingParametersArrayHmacSharingParametersArray787 HmacSharingParametersArray(HmacSharingParametersArray&& other) { 788 delete[] params_array; 789 params_array = other.params_array; 790 num_params = other.num_params; 791 other.params_array = nullptr; 792 other.num_params = 0; 793 } ~HmacSharingParametersArrayHmacSharingParametersArray794 ~HmacSharingParametersArray() override { delete[] params_array; } 795 796 size_t SerializedSize() const override; 797 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 798 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 799 800 HmacSharingParameters* params_array; 801 size_t num_params; 802 }; 803 804 struct GetHmacSharingParametersRequest : public EmptyKeymasterRequest { GetHmacSharingParametersRequestGetHmacSharingParametersRequest805 explicit GetHmacSharingParametersRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 806 }; 807 808 struct GetHmacSharingParametersResponse : public KeymasterResponse { GetHmacSharingParametersResponseGetHmacSharingParametersResponse809 explicit GetHmacSharingParametersResponse(int32_t ver) : KeymasterResponse(ver) {} GetHmacSharingParametersResponseGetHmacSharingParametersResponse810 GetHmacSharingParametersResponse(GetHmacSharingParametersResponse&& other) 811 : KeymasterResponse(other.message_version), params(move(other.params)) {} 812 SetSeedGetHmacSharingParametersResponse813 void SetSeed(KeymasterBlob&& seed_data) { params.SetSeed(move(seed_data)); } 814 NonErrorSerializedSizeGetHmacSharingParametersResponse815 size_t NonErrorSerializedSize() const override { return params.SerializedSize(); } NonErrorSerializeGetHmacSharingParametersResponse816 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 817 return params.Serialize(buf, end); 818 } NonErrorDeserializeGetHmacSharingParametersResponse819 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 820 return params.Deserialize(buf_ptr, end); 821 } 822 823 HmacSharingParameters params; 824 }; 825 826 struct ComputeSharedHmacRequest : public KeymasterMessage { ComputeSharedHmacRequestComputeSharedHmacRequest827 explicit ComputeSharedHmacRequest(int32_t ver) : KeymasterMessage(ver) {} 828 SerializedSizeComputeSharedHmacRequest829 size_t SerializedSize() const override { return params_array.SerializedSize(); } SerializeComputeSharedHmacRequest830 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 831 return params_array.Serialize(buf, end); 832 } DeserializeComputeSharedHmacRequest833 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 834 return params_array.Deserialize(buf_ptr, end); 835 } 836 837 HmacSharingParametersArray params_array; 838 }; 839 840 struct ComputeSharedHmacResponse : public KeymasterResponse { ComputeSharedHmacResponseComputeSharedHmacResponse841 explicit ComputeSharedHmacResponse(int32_t ver) : KeymasterResponse(ver) {} ComputeSharedHmacResponseComputeSharedHmacResponse842 ComputeSharedHmacResponse(ComputeSharedHmacResponse&& other) 843 : KeymasterResponse(other.message_version) { 844 sharing_check = move(other.sharing_check); 845 } 846 847 size_t NonErrorSerializedSize() const override; 848 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 849 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 850 851 KeymasterBlob sharing_check; 852 }; 853 854 struct ImportWrappedKeyRequest : public KeymasterMessage { ImportWrappedKeyRequestImportWrappedKeyRequest855 explicit ImportWrappedKeyRequest(int32_t ver) : KeymasterMessage(ver) {} 856 857 void SetWrappedMaterial(const void* key_material, size_t length); 858 void SetWrappingMaterial(const void* key_material, size_t length); 859 void SetMaskingKeyMaterial(const void* key_material, size_t length); 860 SetKeyMaterialImportWrappedKeyRequest861 void SetKeyMaterial(const keymaster_key_blob_t& wrapped, const keymaster_key_blob_t& wrapping) { 862 SetWrappedMaterial(wrapped.key_material, wrapped.key_material_size); 863 SetWrappingMaterial(wrapping.key_material, wrapping.key_material_size); 864 } 865 866 size_t SerializedSize() const override; 867 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 868 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 869 870 KeymasterKeyBlob wrapped_key; 871 KeymasterKeyBlob wrapping_key; 872 KeymasterKeyBlob masking_key; 873 AuthorizationSet additional_params; 874 uint64_t password_sid; 875 uint64_t biometric_sid; 876 }; 877 878 struct ImportWrappedKeyResponse : public KeymasterResponse { 879 explicit ImportWrappedKeyResponse(int32_t ver = kDefaultMessageVersion) KeymasterResponseImportWrappedKeyResponse880 : KeymasterResponse(ver), key_blob{}, certificate_chain{} {} 881 void SetKeyMaterial(const void* key_material, size_t length); SetKeyMaterialImportWrappedKeyResponse882 void SetKeyMaterial(const keymaster_key_blob_t& blob) { 883 SetKeyMaterial(blob.key_material, blob.key_material_size); 884 } 885 886 size_t NonErrorSerializedSize() const override; 887 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override; 888 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 889 890 KeymasterKeyBlob key_blob; 891 AuthorizationSet enforced; 892 AuthorizationSet unenforced; 893 CertificateChain certificate_chain; 894 }; 895 896 struct HardwareAuthToken : public Serializable { 897 HardwareAuthToken() = default; HardwareAuthTokenHardwareAuthToken898 HardwareAuthToken(HardwareAuthToken&& other) { 899 challenge = other.challenge; 900 user_id = other.user_id; 901 authenticator_id = other.authenticator_id; 902 authenticator_type = other.authenticator_type; 903 timestamp = other.timestamp; 904 mac = move(other.mac); 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 uint64_t challenge{}; 912 uint64_t user_id{}; 913 uint64_t authenticator_id{}; 914 hw_authenticator_type_t authenticator_type{}; 915 uint64_t timestamp{}; 916 KeymasterBlob mac; 917 }; 918 919 struct VerificationToken : public Serializable { 920 VerificationToken() = default; VerificationTokenVerificationToken921 VerificationToken(VerificationToken&& other) { 922 challenge = other.challenge; 923 timestamp = other.timestamp; 924 parameters_verified = move(other.parameters_verified); 925 security_level = other.security_level; 926 mac = move(other.mac); 927 } 928 929 size_t SerializedSize() const override; 930 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override; 931 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 932 933 uint64_t challenge{}; 934 uint64_t timestamp{}; 935 AuthorizationSet parameters_verified{}; 936 keymaster_security_level_t security_level{}; 937 KeymasterBlob mac{}; 938 }; 939 940 struct VerifyAuthorizationRequest : public KeymasterMessage { VerifyAuthorizationRequestVerifyAuthorizationRequest941 explicit VerifyAuthorizationRequest(int32_t ver) : KeymasterMessage(ver) {} 942 VerifyAuthorizationRequest(VerifyAuthorizationRequest&& other) = default; 943 SerializedSizeVerifyAuthorizationRequest944 size_t SerializedSize() const override { 945 return sizeof(challenge) + parameters_to_verify.SerializedSize() + 946 auth_token.SerializedSize(); 947 } 948 SerializeVerifyAuthorizationRequest949 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 950 buf = append_uint64_to_buf(buf, end, challenge); 951 buf = parameters_to_verify.Serialize(buf, end); 952 return auth_token.Serialize(buf, end); 953 } 954 DeserializeVerifyAuthorizationRequest955 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 956 return (copy_uint64_from_buf(buf_ptr, end, &challenge) && 957 parameters_to_verify.Deserialize(buf_ptr, end) && 958 auth_token.Deserialize(buf_ptr, end)); 959 } 960 961 uint64_t challenge{}; 962 AuthorizationSet parameters_to_verify; 963 HardwareAuthToken auth_token; 964 }; 965 966 struct VerifyAuthorizationResponse : public KeymasterResponse { VerifyAuthorizationResponseVerifyAuthorizationResponse967 explicit VerifyAuthorizationResponse(int32_t ver) : KeymasterResponse(ver) {} 968 VerifyAuthorizationResponse(VerifyAuthorizationResponse&& other) = default; 969 NonErrorSerializedSizeVerifyAuthorizationResponse970 size_t NonErrorSerializedSize() const override { 971 return sizeof(error) + token.SerializedSize(); 972 } NonErrorSerializeVerifyAuthorizationResponse973 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 974 buf = append_uint32_to_buf(buf, end, error); 975 return token.Serialize(buf, end); 976 } NonErrorDeserializeVerifyAuthorizationResponse977 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 978 return copy_uint32_from_buf(buf_ptr, end, &error) && token.Deserialize(buf_ptr, end); 979 } 980 981 VerificationToken token; 982 }; 983 984 struct EarlyBootEndedRequest : public EmptyKeymasterRequest { EarlyBootEndedRequestEarlyBootEndedRequest985 explicit EarlyBootEndedRequest(int32_t ver) : EmptyKeymasterRequest(ver) {} 986 }; 987 988 struct EarlyBootEndedResponse : public KeymasterResponse { EarlyBootEndedResponseEarlyBootEndedResponse989 explicit EarlyBootEndedResponse(int32_t ver) : KeymasterResponse(ver) {} 990 NonErrorSerializedSizeEarlyBootEndedResponse991 size_t NonErrorSerializedSize() const override { return 0; } NonErrorSerializeEarlyBootEndedResponse992 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; } NonErrorDeserializeEarlyBootEndedResponse993 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; } 994 }; 995 996 struct DeviceLockedRequest : public KeymasterMessage { DeviceLockedRequestDeviceLockedRequest997 explicit DeviceLockedRequest(int32_t ver) : KeymasterMessage(ver) {} DeviceLockedRequestDeviceLockedRequest998 explicit DeviceLockedRequest(int32_t ver, bool passwordOnly_, VerificationToken&& token_) 999 : KeymasterMessage(ver), passwordOnly(passwordOnly_), token(move(token_)) {} 1000 SerializedSizeDeviceLockedRequest1001 size_t SerializedSize() const override { return 1; } SerializeDeviceLockedRequest1002 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1003 if (buf < end) *buf++ = passwordOnly ? 1 : 0; 1004 return token.Serialize(buf, end); 1005 } DeserializeDeviceLockedRequest1006 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1007 if (*buf_ptr >= end) return false; 1008 passwordOnly = !!*(*buf_ptr)++; 1009 return token.Deserialize(buf_ptr, end); 1010 } 1011 1012 bool passwordOnly; 1013 VerificationToken token; 1014 }; 1015 1016 struct DeviceLockedResponse : public KeymasterResponse { DeviceLockedResponseDeviceLockedResponse1017 explicit DeviceLockedResponse(int32_t ver) : KeymasterResponse(ver) {} 1018 NonErrorSerializedSizeDeviceLockedResponse1019 size_t NonErrorSerializedSize() const override { return 0; } NonErrorSerializeDeviceLockedResponse1020 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; } NonErrorDeserializeDeviceLockedResponse1021 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; } 1022 }; 1023 1024 struct GetVersion2Request : public KeymasterMessage { 1025 // GetVersion2Request ctor takes a version arg so it has the same signature as others, but the 1026 // value is ignored because it's not versionable. 1027 explicit GetVersion2Request(uint32_t /* ver */ = 0) 1028 : KeymasterMessage(0 /* not versionable */) {} 1029 SerializedSizeGetVersion2Request1030 size_t SerializedSize() const override { return sizeof(uint32_t); /* max message version */ } SerializeGetVersion2Request1031 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1032 return append_uint32_to_buf(buf, end, max_message_version); 1033 } DeserializeGetVersion2Request1034 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1035 return copy_uint32_from_buf(buf_ptr, end, &max_message_version); 1036 } 1037 1038 uint32_t max_message_version = kDefaultMessageVersion; 1039 }; 1040 1041 struct GetVersion2Response : public KeymasterResponse { 1042 // GetVersion2Request ctor takes a version arg so it has the same signature as others, but the 1043 // value is ignored because it's not versionable. 1044 explicit GetVersion2Response(uint32_t /* ver */ = 0) 1045 : KeymasterResponse(0 /* not versionable */) {} 1046 1047 size_t NonErrorSerializedSize() const override; 1048 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override; 1049 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override; 1050 1051 uint32_t max_message_version; 1052 KmVersion km_version; 1053 uint32_t km_date; 1054 }; 1055 1056 struct TimestampToken : public Serializable { 1057 explicit TimestampToken() = default; TimestampTokenTimestampToken1058 TimestampToken(TimestampToken&& other) { 1059 challenge = other.challenge; 1060 timestamp = other.timestamp; 1061 security_level = other.security_level; 1062 mac = move(other.mac); 1063 } SerializedSizeTimestampToken1064 size_t SerializedSize() const override { 1065 return sizeof(challenge) + sizeof(timestamp) + sizeof(security_level) + 1066 mac.SerializedSize(); 1067 } SerializeTimestampToken1068 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1069 buf = append_uint64_to_buf(buf, end, challenge); 1070 buf = append_uint64_to_buf(buf, end, timestamp); 1071 buf = append_uint32_to_buf(buf, end, security_level); 1072 return mac.Serialize(buf, end); 1073 } DeserializeTimestampToken1074 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1075 return copy_uint64_from_buf(buf_ptr, end, &challenge) && 1076 copy_uint64_from_buf(buf_ptr, end, ×tamp) && 1077 copy_uint32_from_buf(buf_ptr, end, &security_level) && mac.Deserialize(buf_ptr, end); 1078 } 1079 uint64_t challenge{}; 1080 uint64_t timestamp{}; 1081 keymaster_security_level_t security_level{}; 1082 KeymasterBlob mac{}; 1083 }; 1084 1085 struct GenerateTimestampTokenRequest : public KeymasterMessage { GenerateTimestampTokenRequestGenerateTimestampTokenRequest1086 explicit GenerateTimestampTokenRequest(int32_t ver) : KeymasterMessage(ver), challenge{} {} SerializedSizeGenerateTimestampTokenRequest1087 size_t SerializedSize() const override { return sizeof(challenge); } SerializeGenerateTimestampTokenRequest1088 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1089 return append_uint64_to_buf(buf, end, challenge); 1090 } DeserializeGenerateTimestampTokenRequest1091 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1092 return copy_uint64_from_buf(buf_ptr, end, &challenge); 1093 } 1094 uint64_t challenge; 1095 }; 1096 1097 struct GenerateTimestampTokenResponse : public KeymasterResponse { GenerateTimestampTokenResponseGenerateTimestampTokenResponse1098 explicit GenerateTimestampTokenResponse(int32_t ver) : KeymasterResponse(ver), token{} {} NonErrorSerializedSizeGenerateTimestampTokenResponse1099 size_t NonErrorSerializedSize() const override { return token.SerializedSize(); } NonErrorSerializeGenerateTimestampTokenResponse1100 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 1101 return token.Serialize(buf, end); 1102 } NonErrorDeserializeGenerateTimestampTokenResponse1103 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1104 return token.Deserialize(buf_ptr, end); 1105 } 1106 TimestampToken token; 1107 }; 1108 1109 struct SetAttestationIdsRequest : public KeymasterMessage { SetAttestationIdsRequestSetAttestationIdsRequest1110 explicit SetAttestationIdsRequest(int32_t ver) : KeymasterMessage(ver) {} SerializedSizeSetAttestationIdsRequest1111 size_t SerializedSize() const override { 1112 return brand.SerializedSize() // 1113 + device.SerializedSize() // 1114 + product.SerializedSize() // 1115 + serial.SerializedSize() // 1116 + imei.SerializedSize() // 1117 + meid.SerializedSize() // 1118 + manufacturer.SerializedSize() // 1119 + model.SerializedSize(); 1120 } 1121 SerializeSetAttestationIdsRequest1122 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1123 buf = brand.Serialize(buf, end); 1124 buf = device.Serialize(buf, end); 1125 buf = product.Serialize(buf, end); 1126 buf = serial.Serialize(buf, end); 1127 buf = imei.Serialize(buf, end); 1128 buf = meid.Serialize(buf, end); 1129 buf = manufacturer.Serialize(buf, end); 1130 return model.Serialize(buf, end); 1131 } 1132 DeserializeSetAttestationIdsRequest1133 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1134 return brand.Deserialize(buf_ptr, end) // 1135 && device.Deserialize(buf_ptr, end) // 1136 && product.Deserialize(buf_ptr, end) // 1137 && serial.Deserialize(buf_ptr, end) // 1138 && imei.Deserialize(buf_ptr, end) // 1139 && meid.Deserialize(buf_ptr, end) // 1140 && manufacturer.Deserialize(buf_ptr, end) // 1141 && model.Deserialize(buf_ptr, end); // 1142 } 1143 1144 Buffer brand; 1145 Buffer device; 1146 Buffer product; 1147 Buffer serial; 1148 Buffer imei; 1149 Buffer meid; 1150 Buffer manufacturer; 1151 Buffer model; 1152 }; 1153 1154 using SetAttestationIdsResponse = EmptyKeymasterResponse; 1155 1156 struct ConfigureVendorPatchlevelRequest : public KeymasterMessage { ConfigureVendorPatchlevelRequestConfigureVendorPatchlevelRequest1157 explicit ConfigureVendorPatchlevelRequest(int32_t ver) : KeymasterMessage(ver) {} 1158 SerializedSizeConfigureVendorPatchlevelRequest1159 size_t SerializedSize() const override { return sizeof(vendor_patchlevel); } SerializeConfigureVendorPatchlevelRequest1160 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1161 return append_uint32_to_buf(buf, end, vendor_patchlevel); 1162 } DeserializeConfigureVendorPatchlevelRequest1163 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1164 return copy_uint32_from_buf(buf_ptr, end, &vendor_patchlevel); 1165 } 1166 1167 uint32_t vendor_patchlevel{}; // YYYYMMDD 1168 }; 1169 1170 using ConfigureVendorPatchlevelResponse = EmptyKeymasterResponse; 1171 1172 struct ConfigureBootPatchlevelRequest : public KeymasterMessage { ConfigureBootPatchlevelRequestConfigureBootPatchlevelRequest1173 explicit ConfigureBootPatchlevelRequest(int32_t ver) : KeymasterMessage(ver) {} 1174 SerializedSizeConfigureBootPatchlevelRequest1175 size_t SerializedSize() const override { return sizeof(boot_patchlevel); } SerializeConfigureBootPatchlevelRequest1176 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1177 return append_uint32_to_buf(buf, end, boot_patchlevel); 1178 } DeserializeConfigureBootPatchlevelRequest1179 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1180 return copy_uint32_from_buf(buf_ptr, end, &boot_patchlevel); 1181 } 1182 1183 uint32_t boot_patchlevel{}; // YYYYMMDD 1184 }; 1185 1186 using ConfigureBootPatchlevelResponse = EmptyKeymasterResponse; 1187 1188 struct ConfigureVerifiedBootInfoRequest : public KeymasterMessage { ConfigureVerifiedBootInfoRequestConfigureVerifiedBootInfoRequest1189 explicit ConfigureVerifiedBootInfoRequest(int32_t ver) 1190 : ConfigureVerifiedBootInfoRequest(ver, {}, {}, {}) {} 1191 ConfigureVerifiedBootInfoRequestConfigureVerifiedBootInfoRequest1192 ConfigureVerifiedBootInfoRequest(int32_t ver, std::string_view boot_state_param, 1193 std::string_view bootloader_state_param, 1194 std::vector<uint8_t> vbmeta_digest_param) 1195 : KeymasterMessage(ver), boot_state(boot_state_param), 1196 bootloader_state(bootloader_state_param), vbmeta_digest(std::move(vbmeta_digest_param)) {} 1197 SerializedSizeConfigureVerifiedBootInfoRequest1198 size_t SerializedSize() const override { 1199 return sizeof(uint32_t) + sizeof(uint32_t) + sizeof(uint32_t) // buffer sizes 1200 + boot_state.size() + bootloader_state.size() + vbmeta_digest.size(); 1201 } SerializeConfigureVerifiedBootInfoRequest1202 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1203 buf = append_collection_to_buf(buf, end, boot_state); 1204 buf = append_collection_to_buf(buf, end, bootloader_state); 1205 return append_collection_to_buf(buf, end, vbmeta_digest); 1206 } DeserializeConfigureVerifiedBootInfoRequest1207 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1208 return copy_collection_from_buf(buf_ptr, end, &boot_state) && 1209 copy_collection_from_buf(buf_ptr, end, &bootloader_state) && 1210 copy_collection_from_buf(buf_ptr, end, &vbmeta_digest); 1211 } 1212 1213 std::string boot_state; 1214 std::string bootloader_state; 1215 std::vector<uint8_t> vbmeta_digest; 1216 }; 1217 1218 using ConfigureVerifiedBootInfoResponse = EmptyKeymasterResponse; 1219 1220 struct GetRootOfTrustRequest : public KeymasterMessage { GetRootOfTrustRequestGetRootOfTrustRequest1221 explicit GetRootOfTrustRequest(int32_t ver) : GetRootOfTrustRequest(ver, {}) {} GetRootOfTrustRequestGetRootOfTrustRequest1222 GetRootOfTrustRequest(int32_t ver, std::vector<uint8_t> challenge_param) 1223 : KeymasterMessage(ver), challenge(std::move(challenge_param)){}; 1224 SerializedSizeGetRootOfTrustRequest1225 size_t SerializedSize() const override { return sizeof(uint32_t) + challenge.size(); } SerializeGetRootOfTrustRequest1226 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override { 1227 return append_collection_to_buf(buf, end, challenge); 1228 } DeserializeGetRootOfTrustRequest1229 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1230 return copy_collection_from_buf(buf_ptr, end, &challenge); 1231 } 1232 1233 std::vector<uint8_t> challenge; 1234 }; 1235 1236 struct GetRootOfTrustResponse : public KeymasterResponse { GetRootOfTrustResponseGetRootOfTrustResponse1237 explicit GetRootOfTrustResponse(uint32_t ver) : GetRootOfTrustResponse(ver, {}) {} GetRootOfTrustResponseGetRootOfTrustResponse1238 GetRootOfTrustResponse(uint32_t ver, std::vector<uint8_t> rootOfTrust_param) 1239 : KeymasterResponse(ver), rootOfTrust(std::move(rootOfTrust_param)){}; 1240 NonErrorSerializedSizeGetRootOfTrustResponse1241 size_t NonErrorSerializedSize() const override { return sizeof(uint32_t) + rootOfTrust.size(); } NonErrorSerializeGetRootOfTrustResponse1242 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override { 1243 return append_collection_to_buf(buf, end, rootOfTrust); 1244 } NonErrorDeserializeGetRootOfTrustResponse1245 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override { 1246 return copy_collection_from_buf(buf_ptr, end, &rootOfTrust); 1247 } 1248 1249 std::vector<uint8_t> rootOfTrust; 1250 }; 1251 1252 } // namespace keymaster 1253