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 #ifndef SYSTEM_KEYMASTER_ANDROID_KEYMASTER_MESSAGES_H_
18 #define SYSTEM_KEYMASTER_ANDROID_KEYMASTER_MESSAGES_H_
19
20 #include <assert.h>
21 #include <stdlib.h>
22 #include <string.h>
23
24 #include <keymaster/android_keymaster_utils.h>
25 #include <keymaster/authorization_set.h>
26
27 namespace keymaster {
28
29 // Commands
30 enum AndroidKeymasterCommand {
31 GENERATE_KEY = 0,
32 BEGIN_OPERATION = 1,
33 UPDATE_OPERATION = 2,
34 FINISH_OPERATION = 3,
35 ABORT_OPERATION = 4,
36 IMPORT_KEY = 5,
37 EXPORT_KEY = 6,
38 GET_VERSION = 7,
39 ADD_RNG_ENTROPY = 8,
40 GET_SUPPORTED_ALGORITHMS = 9,
41 GET_SUPPORTED_BLOCK_MODES = 10,
42 GET_SUPPORTED_PADDING_MODES = 11,
43 GET_SUPPORTED_DIGESTS = 12,
44 GET_SUPPORTED_IMPORT_FORMATS = 13,
45 GET_SUPPORTED_EXPORT_FORMATS = 14,
46 GET_KEY_CHARACTERISTICS = 15,
47 ATTEST_KEY = 16,
48 UPGRADE_KEY = 17,
49 };
50
51 /**
52 * Keymaster message versions are tied to keymaster versions. We map the keymaster
53 * major.minor.subminor version to a sequential "message version".
54 *
55 * Rather than encoding a version number into each message we rely on the client -- who initiates
56 * all requests -- to check the version of the keymaster implementation with the GET_VERSION command
57 * and to send only requests that the implementation can understand. This means that only the
58 * client side needs to manage version compatibility; the implementation can always expect/produce
59 * messages of its format.
60 *
61 * Because message version selection is purely a client-side issue, all messages default to using
62 * the latest version (MAX_MESSAGE_VERSION). Client code must take care to check versions and pass
63 * correct version values to message constructors. The AndroidKeymaster implementation always uses
64 * the default, latest.
65 *
66 * Note that this approach implies that GetVersionRequest and GetVersionResponse cannot be
67 * versioned.
68 */
69 const int32_t MAX_MESSAGE_VERSION = 3;
MessageVersion(uint8_t major_ver,uint8_t minor_ver,uint8_t)70 inline int32_t MessageVersion(uint8_t major_ver, uint8_t minor_ver, uint8_t /* subminor_ver */) {
71 int32_t message_version = -1;
72 switch (major_ver) {
73 case 0:
74 // For the moment we still support version 0, though in general the plan is not to support
75 // non-matching major versions.
76 message_version = 0;
77 break;
78 case 1:
79 switch (minor_ver) {
80 case 0:
81 message_version = 1;
82 break;
83 case 1:
84 message_version = 2;
85 break;
86 }
87 break;
88 case 2:
89 message_version = 3;
90 break;
91 };
92 return message_version;
93 }
94
95 struct KeymasterMessage : public Serializable {
KeymasterMessageKeymasterMessage96 KeymasterMessage(int32_t ver) : message_version(ver) { assert(ver >= 0); }
97 uint32_t message_version;
98 };
99
100 /**
101 * All responses include an error value, and if the error is not KM_ERROR_OK, return no additional
102 * data. This abstract class factors out the common serialization functionality for all of the
103 * responses, so we only have to implement it once. Inheritance for reuse is generally not a great
104 * structure, but in this case it's the cleanest option.
105 */
106 struct KeymasterResponse : public KeymasterMessage {
KeymasterResponseKeymasterResponse107 explicit KeymasterResponse(int32_t ver)
108 : KeymasterMessage(ver), error(KM_ERROR_UNKNOWN_ERROR) {}
109
110 size_t SerializedSize() const override;
111 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
112 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
113
114 virtual size_t NonErrorSerializedSize() const = 0;
115 virtual uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const = 0;
116 virtual bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) = 0;
117
118 keymaster_error_t error;
119 };
120
121 struct SupportedAlgorithmsRequest : public KeymasterMessage {
122 explicit SupportedAlgorithmsRequest(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterMessageSupportedAlgorithmsRequest123 : KeymasterMessage(ver) {}
124
SerializedSizeSupportedAlgorithmsRequest125 size_t SerializedSize() const override { return 0; };
SerializeSupportedAlgorithmsRequest126 uint8_t* Serialize(uint8_t* buf, const uint8_t* /* end */) const override { return buf; }
DeserializeSupportedAlgorithmsRequest127 bool Deserialize(const uint8_t** /* buf_ptr */, const uint8_t* /* end */) override {
128 return true;
129 }
130 };
131
132 struct SupportedByAlgorithmRequest : public KeymasterMessage {
SupportedByAlgorithmRequestSupportedByAlgorithmRequest133 explicit SupportedByAlgorithmRequest(int32_t ver) : KeymasterMessage(ver) {}
134
SerializedSizeSupportedByAlgorithmRequest135 size_t SerializedSize() const override { return sizeof(uint32_t); };
SerializeSupportedByAlgorithmRequest136 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override {
137 return append_uint32_to_buf(buf, end, algorithm);
138 }
DeserializeSupportedByAlgorithmRequest139 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override {
140 return copy_uint32_from_buf(buf_ptr, end, &algorithm);
141 }
142
143 keymaster_algorithm_t algorithm;
144 };
145
146 struct SupportedImportFormatsRequest : public SupportedByAlgorithmRequest {
147 SupportedImportFormatsRequest(int32_t ver = MAX_MESSAGE_VERSION)
SupportedByAlgorithmRequestSupportedImportFormatsRequest148 : SupportedByAlgorithmRequest(ver) {}
149 };
150
151 struct SupportedExportFormatsRequest : public SupportedByAlgorithmRequest {
152 SupportedExportFormatsRequest(int32_t ver = MAX_MESSAGE_VERSION)
SupportedByAlgorithmRequestSupportedExportFormatsRequest153 : SupportedByAlgorithmRequest(ver) {}
154 };
155
156 struct SupportedByAlgorithmAndPurposeRequest : public KeymasterMessage {
157 explicit SupportedByAlgorithmAndPurposeRequest(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterMessageSupportedByAlgorithmAndPurposeRequest158 : KeymasterMessage(ver) {}
159
SerializedSizeSupportedByAlgorithmAndPurposeRequest160 size_t SerializedSize() const override { return sizeof(uint32_t) * 2; };
SerializeSupportedByAlgorithmAndPurposeRequest161 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override {
162 buf = append_uint32_to_buf(buf, end, algorithm);
163 return append_uint32_to_buf(buf, end, purpose);
164 }
DeserializeSupportedByAlgorithmAndPurposeRequest165 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override {
166 return copy_uint32_from_buf(buf_ptr, end, &algorithm) &&
167 copy_uint32_from_buf(buf_ptr, end, &purpose);
168 }
169
170 keymaster_algorithm_t algorithm;
171 keymaster_purpose_t purpose;
172 };
173
174 struct SupportedBlockModesRequest : public SupportedByAlgorithmAndPurposeRequest {
175 SupportedBlockModesRequest(int32_t ver = MAX_MESSAGE_VERSION)
SupportedByAlgorithmAndPurposeRequestSupportedBlockModesRequest176 : SupportedByAlgorithmAndPurposeRequest(ver) {}
177 };
178
179 struct SupportedPaddingModesRequest : public SupportedByAlgorithmAndPurposeRequest {
180 SupportedPaddingModesRequest(int32_t ver = MAX_MESSAGE_VERSION)
SupportedByAlgorithmAndPurposeRequestSupportedPaddingModesRequest181 : SupportedByAlgorithmAndPurposeRequest(ver) {}
182 };
183
184 struct SupportedDigestsRequest : public SupportedByAlgorithmAndPurposeRequest {
185 SupportedDigestsRequest(int32_t ver = MAX_MESSAGE_VERSION)
SupportedByAlgorithmAndPurposeRequestSupportedDigestsRequest186 : SupportedByAlgorithmAndPurposeRequest(ver) {}
187 };
188
189 template <typename T> struct SupportedResponse : public KeymasterResponse {
SupportedResponseSupportedResponse190 explicit SupportedResponse(int32_t ver)
191 : KeymasterResponse(ver), results(nullptr), results_length(0) {}
~SupportedResponseSupportedResponse192 ~SupportedResponse() { delete[] results; }
193
SetResultsSupportedResponse194 template <size_t N> void SetResults(const T (&arr)[N]) { SetResults(arr, N); }
195
SetResultsSupportedResponse196 void SetResults(const T* arr, size_t n) {
197 delete[] results;
198 results_length = 0;
199 results = dup_array(arr, n);
200 if (results == nullptr) {
201 error = KM_ERROR_MEMORY_ALLOCATION_FAILED;
202 } else {
203 results_length = n;
204 error = KM_ERROR_OK;
205 }
206 }
207
NonErrorSerializedSizeSupportedResponse208 size_t NonErrorSerializedSize() const override {
209 return sizeof(uint32_t) + results_length * sizeof(uint32_t);
210 }
NonErrorSerializeSupportedResponse211 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override {
212 return append_uint32_array_to_buf(buf, end, results, results_length);
213 }
NonErrorDeserializeSupportedResponse214 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override {
215 delete[] results;
216 results = nullptr;
217 UniquePtr<T[]> tmp;
218 if (!copy_uint32_array_from_buf(buf_ptr, end, &tmp, &results_length))
219 return false;
220 results = tmp.release();
221 return true;
222 }
223
224 T* results;
225 size_t results_length;
226 };
227
228 struct SupportedAlgorithmsResponse : public SupportedResponse<keymaster_algorithm_t> {
229 SupportedAlgorithmsResponse(int32_t ver = MAX_MESSAGE_VERSION)
230 : SupportedResponse<keymaster_algorithm_t>(ver) {}
231 };
232
233 struct SupportedBlockModesResponse : public SupportedResponse<keymaster_block_mode_t> {
234 SupportedBlockModesResponse(int32_t ver = MAX_MESSAGE_VERSION)
235 : SupportedResponse<keymaster_block_mode_t>(ver) {}
236 };
237
238 struct SupportedPaddingModesResponse : public SupportedResponse<keymaster_padding_t> {
239 SupportedPaddingModesResponse(int32_t ver = MAX_MESSAGE_VERSION)
240 : SupportedResponse<keymaster_padding_t>(ver) {}
241 };
242
243 struct SupportedDigestsResponse : public SupportedResponse<keymaster_digest_t> {
244 SupportedDigestsResponse(int32_t ver = MAX_MESSAGE_VERSION)
245 : SupportedResponse<keymaster_digest_t>(ver) {}
246 };
247
248 struct SupportedImportFormatsResponse : public SupportedResponse<keymaster_key_format_t> {
249 SupportedImportFormatsResponse(int32_t ver = MAX_MESSAGE_VERSION)
250 : SupportedResponse<keymaster_key_format_t>(ver) {}
251 };
252
253 struct SupportedExportFormatsResponse : public SupportedResponse<keymaster_key_format_t> {
254 SupportedExportFormatsResponse(int32_t ver = MAX_MESSAGE_VERSION)
255 : SupportedResponse<keymaster_key_format_t>(ver) {}
256 };
257
258 struct GenerateKeyRequest : public KeymasterMessage {
KeymasterMessageGenerateKeyRequest259 explicit GenerateKeyRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {}
260
SerializedSizeGenerateKeyRequest261 size_t SerializedSize() const override { return key_description.SerializedSize(); }
SerializeGenerateKeyRequest262 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override {
263 return key_description.Serialize(buf, end);
264 }
DeserializeGenerateKeyRequest265 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override {
266 return key_description.Deserialize(buf_ptr, end);
267 }
268
269 AuthorizationSet key_description;
270 };
271
272 struct GenerateKeyResponse : public KeymasterResponse {
KeymasterResponseGenerateKeyResponse273 explicit GenerateKeyResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {
274 key_blob.key_material = nullptr;
275 key_blob.key_material_size = 0;
276 }
277 ~GenerateKeyResponse();
278
279 size_t NonErrorSerializedSize() const override;
280 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
281 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
282
283 keymaster_key_blob_t key_blob;
284 AuthorizationSet enforced;
285 AuthorizationSet unenforced;
286 };
287
288 struct GetKeyCharacteristicsRequest : public KeymasterMessage {
289 explicit GetKeyCharacteristicsRequest(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterMessageGetKeyCharacteristicsRequest290 : KeymasterMessage(ver) {
291 key_blob.key_material = nullptr;
292 key_blob.key_material_size = 0;
293 }
294 ~GetKeyCharacteristicsRequest();
295
296 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialGetKeyCharacteristicsRequest297 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
298 SetKeyMaterial(blob.key_material, blob.key_material_size);
299 }
300
301 size_t SerializedSize() const override;
302 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
303 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
304
305 keymaster_key_blob_t key_blob;
306 AuthorizationSet additional_params;
307 };
308
309 struct GetKeyCharacteristicsResponse : public KeymasterResponse {
310 explicit GetKeyCharacteristicsResponse(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterResponseGetKeyCharacteristicsResponse311 : KeymasterResponse(ver) {}
312 size_t NonErrorSerializedSize() const override;
313 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
314 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
315
316 AuthorizationSet enforced;
317 AuthorizationSet unenforced;
318 };
319
320 struct BeginOperationRequest : public KeymasterMessage {
KeymasterMessageBeginOperationRequest321 explicit BeginOperationRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {
322 key_blob.key_material = nullptr;
323 key_blob.key_material_size = 0;
324 }
~BeginOperationRequestBeginOperationRequest325 ~BeginOperationRequest() { delete[] key_blob.key_material; }
326
327 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialBeginOperationRequest328 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
329 SetKeyMaterial(blob.key_material, blob.key_material_size);
330 }
331
332 size_t SerializedSize() const;
333 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
334 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
335
336 keymaster_purpose_t purpose;
337 keymaster_key_blob_t key_blob;
338 AuthorizationSet additional_params;
339 };
340
341 struct BeginOperationResponse : public KeymasterResponse {
KeymasterResponseBeginOperationResponse342 explicit BeginOperationResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {}
343
344 size_t NonErrorSerializedSize() const override;
345 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
346 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
347
348 keymaster_operation_handle_t op_handle;
349 AuthorizationSet output_params;
350 };
351
352 struct UpdateOperationRequest : public KeymasterMessage {
KeymasterMessageUpdateOperationRequest353 explicit UpdateOperationRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {}
354
355 size_t SerializedSize() const override;
356 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
357 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
358
359 keymaster_operation_handle_t op_handle;
360 Buffer input;
361 AuthorizationSet additional_params;
362 };
363
364 struct UpdateOperationResponse : public KeymasterResponse {
365 explicit UpdateOperationResponse(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterResponseUpdateOperationResponse366 : KeymasterResponse(ver), input_consumed(0) {}
367
368 size_t NonErrorSerializedSize() const override;
369 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
370 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
371
372 Buffer output;
373 size_t input_consumed;
374 AuthorizationSet output_params;
375 };
376
377 struct FinishOperationRequest : public KeymasterMessage {
KeymasterMessageFinishOperationRequest378 explicit FinishOperationRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {}
379
380 size_t SerializedSize() const override;
381 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
382 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
383
384 keymaster_operation_handle_t op_handle;
385 Buffer input;
386 Buffer signature;
387 AuthorizationSet additional_params;
388 };
389
390 struct FinishOperationResponse : public KeymasterResponse {
KeymasterResponseFinishOperationResponse391 explicit FinishOperationResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {}
392
393 size_t NonErrorSerializedSize() const override;
394 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
395 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
396
397 Buffer output;
398 AuthorizationSet output_params;
399 };
400
401 struct AbortOperationRequest : public KeymasterMessage {
KeymasterMessageAbortOperationRequest402 explicit AbortOperationRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {}
403
SerializedSizeAbortOperationRequest404 size_t SerializedSize() const override { return sizeof(uint64_t); }
SerializeAbortOperationRequest405 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override {
406 return append_uint64_to_buf(buf, end, op_handle);
407 }
DeserializeAbortOperationRequest408 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override {
409 return copy_uint64_from_buf(buf_ptr, end, &op_handle);
410 }
411
412 keymaster_operation_handle_t op_handle;
413 };
414
415 struct AbortOperationResponse : public KeymasterResponse {
KeymasterResponseAbortOperationResponse416 explicit AbortOperationResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {}
417
NonErrorSerializedSizeAbortOperationResponse418 size_t NonErrorSerializedSize() const override { return 0; }
NonErrorSerializeAbortOperationResponse419 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; }
NonErrorDeserializeAbortOperationResponse420 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; }
421 };
422
423 struct AddEntropyRequest : public KeymasterMessage {
KeymasterMessageAddEntropyRequest424 explicit AddEntropyRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {}
425
426 size_t SerializedSize() const override;
427 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
428 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
429
430 Buffer random_data;
431 };
432
433 struct AddEntropyResponse : public KeymasterResponse {
KeymasterResponseAddEntropyResponse434 explicit AddEntropyResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {}
435
NonErrorSerializedSizeAddEntropyResponse436 size_t NonErrorSerializedSize() const override { return 0; }
NonErrorSerializeAddEntropyResponse437 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* /* end */) const override {
438 return buf;
439 }
NonErrorDeserializeAddEntropyResponse440 bool NonErrorDeserialize(const uint8_t** /* buf_ptr */, const uint8_t* /* end */) override {
441 return true;
442 }
443 };
444
445 struct ImportKeyRequest : public KeymasterMessage {
446 explicit ImportKeyRequest(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterMessageImportKeyRequest447 : KeymasterMessage(ver), key_data(nullptr) {}
~ImportKeyRequestImportKeyRequest448 ~ImportKeyRequest() { delete[] key_data; }
449
450 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialImportKeyRequest451 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
452 SetKeyMaterial(blob.key_material, blob.key_material_size);
453 }
454
455 size_t SerializedSize() const override;
456 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
457 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
458
459 AuthorizationSet key_description;
460 keymaster_key_format_t key_format;
461 uint8_t* key_data;
462 size_t key_data_length;
463 };
464
465 struct ImportKeyResponse : public KeymasterResponse {
KeymasterResponseImportKeyResponse466 explicit ImportKeyResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {
467 key_blob.key_material = nullptr;
468 key_blob.key_material_size = 0;
469 }
~ImportKeyResponseImportKeyResponse470 ~ImportKeyResponse() { delete[] key_blob.key_material; }
471
472 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialImportKeyResponse473 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
474 SetKeyMaterial(blob.key_material, blob.key_material_size);
475 }
476
477 size_t NonErrorSerializedSize() const override;
478 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
479 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
480
481 keymaster_key_blob_t key_blob;
482 AuthorizationSet enforced;
483 AuthorizationSet unenforced;
484 };
485
486 struct ExportKeyRequest : public KeymasterMessage {
KeymasterMessageExportKeyRequest487 explicit ExportKeyRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {
488 key_blob.key_material = nullptr;
489 key_blob.key_material_size = 0;
490 }
~ExportKeyRequestExportKeyRequest491 ~ExportKeyRequest() { delete[] key_blob.key_material; }
492
493 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialExportKeyRequest494 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
495 SetKeyMaterial(blob.key_material, blob.key_material_size);
496 }
497
498 size_t SerializedSize() const override;
499 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
500 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
501
502 AuthorizationSet additional_params;
503 keymaster_key_format_t key_format;
504 keymaster_key_blob_t key_blob;
505 };
506
507 struct ExportKeyResponse : public KeymasterResponse {
508 explicit ExportKeyResponse(int32_t ver = MAX_MESSAGE_VERSION)
KeymasterResponseExportKeyResponse509 : KeymasterResponse(ver), key_data(nullptr) {}
~ExportKeyResponseExportKeyResponse510 ~ExportKeyResponse() { delete[] key_data; }
511
512 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialExportKeyResponse513 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
514 SetKeyMaterial(blob.key_material, blob.key_material_size);
515 }
516
517 size_t NonErrorSerializedSize() const override;
518 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
519 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
520
521 uint8_t* key_data;
522 size_t key_data_length;
523 };
524
525 struct DeleteKeyRequest : public KeymasterMessage {
KeymasterMessageDeleteKeyRequest526 explicit DeleteKeyRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {
527 key_blob.key_material = nullptr;
528 key_blob.key_material_size = 0;
529 }
~DeleteKeyRequestDeleteKeyRequest530 ~DeleteKeyRequest() { delete[] key_blob.key_material; }
531
532 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialDeleteKeyRequest533 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
534 SetKeyMaterial(blob.key_material, blob.key_material_size);
535 }
536
537 size_t SerializedSize() const override;
538 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
539 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
540
541 keymaster_key_blob_t key_blob;
542 };
543
544 struct DeleteKeyResponse : public KeymasterResponse {
KeymasterResponseDeleteKeyResponse545 explicit DeleteKeyResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {}
546
NonErrorSerializedSizeDeleteKeyResponse547 size_t NonErrorSerializedSize() const override { return 0; }
NonErrorSerializeDeleteKeyResponse548 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; }
NonErrorDeserializeDeleteKeyResponse549 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; }
550 };
551
552 struct DeleteAllKeysRequest : public KeymasterMessage {
KeymasterMessageDeleteAllKeysRequest553 explicit DeleteAllKeysRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {}
554
SerializedSizeDeleteAllKeysRequest555 size_t SerializedSize() const override { return 0; }
SerializeDeleteAllKeysRequest556 uint8_t* Serialize(uint8_t* buf, const uint8_t*) const override { return buf; }
DeserializeDeleteAllKeysRequest557 bool Deserialize(const uint8_t**, const uint8_t*) override { return true; };
558 };
559
560 struct DeleteAllKeysResponse : public KeymasterResponse {
KeymasterResponseDeleteAllKeysResponse561 explicit DeleteAllKeysResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {}
562
NonErrorSerializedSizeDeleteAllKeysResponse563 size_t NonErrorSerializedSize() const override { return 0; }
NonErrorSerializeDeleteAllKeysResponse564 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t*) const override { return buf; }
NonErrorDeserializeDeleteAllKeysResponse565 bool NonErrorDeserialize(const uint8_t**, const uint8_t*) override { return true; }
566 };
567
568 struct GetVersionRequest : public KeymasterMessage {
GetVersionRequestGetVersionRequest569 GetVersionRequest() : KeymasterMessage(0 /* not versionable */) {}
570
SerializedSizeGetVersionRequest571 size_t SerializedSize() const override { return 0; }
SerializeGetVersionRequest572 uint8_t* Serialize(uint8_t* buf, const uint8_t*) const override { return buf; }
DeserializeGetVersionRequest573 bool Deserialize(const uint8_t**, const uint8_t*) override { return true; };
574 };
575
576 struct GetVersionResponse : public KeymasterResponse {
GetVersionResponseGetVersionResponse577 GetVersionResponse()
578 : KeymasterResponse(0 /* not versionable */), major_ver(0), minor_ver(0), subminor_ver(0) {}
579
580 size_t NonErrorSerializedSize() const override;
581 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
582 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
583
584 uint8_t major_ver;
585 uint8_t minor_ver;
586 uint8_t subminor_ver;
587 };
588
589 struct AttestKeyRequest : public KeymasterMessage {
KeymasterMessageAttestKeyRequest590 explicit AttestKeyRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {
591 key_blob.key_material = nullptr;
592 key_blob.key_material_size = 0;
593 }
594 ~AttestKeyRequest();
595
596 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialAttestKeyRequest597 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
598 SetKeyMaterial(blob.key_material, blob.key_material_size);
599 }
600
601 size_t SerializedSize() const override;
602 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
603 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
604
605 keymaster_key_blob_t key_blob;
606 AuthorizationSet attest_params;
607 };
608
609 struct AttestKeyResponse : public KeymasterResponse {
KeymasterResponseAttestKeyResponse610 explicit AttestKeyResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {
611 certificate_chain.entry_count = 0;
612 certificate_chain.entries = nullptr;
613 }
614 ~AttestKeyResponse();
615
616 bool AllocateChain(size_t entry_count);
617
618 size_t NonErrorSerializedSize() const override;
619 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
620 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
621
622 keymaster_cert_chain_t certificate_chain;
623 };
624
625 struct UpgradeKeyRequest : public KeymasterMessage {
KeymasterMessageUpgradeKeyRequest626 explicit UpgradeKeyRequest(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterMessage(ver) {
627 key_blob = {nullptr, 0};
628 }
629 ~UpgradeKeyRequest();
630
631 void SetKeyMaterial(const void* key_material, size_t length);
SetKeyMaterialUpgradeKeyRequest632 void SetKeyMaterial(const keymaster_key_blob_t& blob) {
633 SetKeyMaterial(blob.key_material, blob.key_material_size);
634 }
635
636 size_t SerializedSize() const override;
637 uint8_t* Serialize(uint8_t* buf, const uint8_t* end) const override;
638 bool Deserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
639
640 keymaster_key_blob_t key_blob;
641 AuthorizationSet upgrade_params;
642 };
643
644 struct UpgradeKeyResponse : public KeymasterResponse {
KeymasterResponseUpgradeKeyResponse645 explicit UpgradeKeyResponse(int32_t ver = MAX_MESSAGE_VERSION) : KeymasterResponse(ver) {
646 upgraded_key = {nullptr, 0};
647 }
648 ~UpgradeKeyResponse();
649
650 size_t NonErrorSerializedSize() const override;
651 uint8_t* NonErrorSerialize(uint8_t* buf, const uint8_t* end) const override;
652 bool NonErrorDeserialize(const uint8_t** buf_ptr, const uint8_t* end) override;
653
654 keymaster_key_blob_t upgraded_key;
655 };
656
657 } // namespace keymaster
658
659 #endif // SYSTEM_KEYMASTER_ANDROID_KEYMASTER_MESSAGES_H_
660