1 /*
2 **
3 ** Copyright 2016, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #define LOG_TAG "android.hardware.keymaster@3.0-impl"
19
20 #include "legacy_keymaster_device_wrapper.h"
21
22 #include <cutils/log.h>
23
24 #include <hardware/keymaster2.h>
25 #include <hardware/keymaster_defs.h>
26 #include <keymaster/keymaster_configuration.h>
27 #include <keymaster/soft_keymaster_device.h>
28
29 namespace android {
30 namespace keystore {
31
32 using ::keymaster::SoftKeymasterDevice;
33
LegacyKeymasterDeviceWrapper(keymaster2_device_t * dev)34 LegacyKeymasterDeviceWrapper::LegacyKeymasterDeviceWrapper(keymaster2_device_t* dev)
35 : keymaster_device_(dev) {}
36
~LegacyKeymasterDeviceWrapper()37 LegacyKeymasterDeviceWrapper::~LegacyKeymasterDeviceWrapper() {
38 if (keymaster_device_) keymaster_device_->common.close(&keymaster_device_->common);
39 }
40
typeFromTag(const keymaster_tag_t tag)41 static inline keymaster_tag_type_t typeFromTag(const keymaster_tag_t tag) {
42 return keymaster_tag_get_type(tag);
43 }
44
45 /**
46 * legacy_enum_conversion converts enums from hidl to keymaster and back. Currently, this is just a
47 * cast to make the compiler happy. One of two thigs should happen though:
48 * TODO The keymaster enums should become aliases for the hidl generated enums so that we have a
49 * single point of truth. Then this cast function can go away.
50 */
legacy_enum_conversion(const Tag value)51 inline static keymaster_tag_t legacy_enum_conversion(const Tag value) {
52 return keymaster_tag_t(value);
53 }
legacy_enum_conversion(const keymaster_tag_t value)54 inline static Tag legacy_enum_conversion(const keymaster_tag_t value) {
55 return Tag(value);
56 }
legacy_enum_conversion(const KeyPurpose value)57 inline static keymaster_purpose_t legacy_enum_conversion(const KeyPurpose value) {
58 return keymaster_purpose_t(value);
59 }
legacy_enum_conversion(const KeyFormat value)60 inline static keymaster_key_format_t legacy_enum_conversion(const KeyFormat value) {
61 return keymaster_key_format_t(value);
62 }
legacy_enum_conversion(const keymaster_error_t value)63 inline static ErrorCode legacy_enum_conversion(const keymaster_error_t value) {
64 return ErrorCode(value);
65 }
66
67 class KmParamSet : public keymaster_key_param_set_t {
68 public:
KmParamSet(const hidl_vec<KeyParameter> & keyParams)69 KmParamSet(const hidl_vec<KeyParameter>& keyParams) {
70 params = new keymaster_key_param_t[keyParams.size()];
71 length = keyParams.size();
72 for (size_t i = 0; i < keyParams.size(); ++i) {
73 auto tag = legacy_enum_conversion(keyParams[i].tag);
74 switch (typeFromTag(tag)) {
75 case KM_ENUM:
76 case KM_ENUM_REP:
77 params[i] = keymaster_param_enum(tag, keyParams[i].f.integer);
78 break;
79 case KM_UINT:
80 case KM_UINT_REP:
81 params[i] = keymaster_param_int(tag, keyParams[i].f.integer);
82 break;
83 case KM_ULONG:
84 case KM_ULONG_REP:
85 params[i] = keymaster_param_long(tag, keyParams[i].f.longInteger);
86 break;
87 case KM_DATE:
88 params[i] = keymaster_param_date(tag, keyParams[i].f.dateTime);
89 break;
90 case KM_BOOL:
91 if (keyParams[i].f.boolValue)
92 params[i] = keymaster_param_bool(tag);
93 else
94 params[i].tag = KM_TAG_INVALID;
95 break;
96 case KM_BIGNUM:
97 case KM_BYTES:
98 params[i] =
99 keymaster_param_blob(tag, &keyParams[i].blob[0], keyParams[i].blob.size());
100 break;
101 case KM_INVALID:
102 default:
103 params[i].tag = KM_TAG_INVALID;
104 /* just skip */
105 break;
106 }
107 }
108 }
KmParamSet(KmParamSet && other)109 KmParamSet(KmParamSet&& other) : keymaster_key_param_set_t{other.params, other.length} {
110 other.length = 0;
111 other.params = nullptr;
112 }
113 KmParamSet(const KmParamSet&) = delete;
~KmParamSet()114 ~KmParamSet() { delete[] params; }
115 };
116
hidlParams2KmParamSet(const hidl_vec<KeyParameter> & params)117 inline static KmParamSet hidlParams2KmParamSet(const hidl_vec<KeyParameter>& params) {
118 return KmParamSet(params);
119 }
120
hidlVec2KmBlob(const hidl_vec<uint8_t> & blob)121 inline static keymaster_blob_t hidlVec2KmBlob(const hidl_vec<uint8_t>& blob) {
122 /* hidl unmarshals funny pointers if the the blob is empty */
123 if (blob.size()) return {&blob[0], blob.size()};
124 return {};
125 }
126
hidlVec2KmKeyBlob(const hidl_vec<uint8_t> & blob)127 inline static keymaster_key_blob_t hidlVec2KmKeyBlob(const hidl_vec<uint8_t>& blob) {
128 /* hidl unmarshals funny pointers if the the blob is empty */
129 if (blob.size()) return {&blob[0], blob.size()};
130 return {};
131 }
132
kmBlob2hidlVec(const keymaster_key_blob_t & blob)133 inline static hidl_vec<uint8_t> kmBlob2hidlVec(const keymaster_key_blob_t& blob) {
134 hidl_vec<uint8_t> result;
135 result.setToExternal(const_cast<unsigned char*>(blob.key_material), blob.key_material_size);
136 return result;
137 }
kmBlob2hidlVec(const keymaster_blob_t & blob)138 inline static hidl_vec<uint8_t> kmBlob2hidlVec(const keymaster_blob_t& blob) {
139 hidl_vec<uint8_t> result;
140 result.setToExternal(const_cast<unsigned char*>(blob.data), blob.data_length);
141 return result;
142 }
143
144 inline static hidl_vec<hidl_vec<uint8_t>>
kmCertChain2Hidl(const keymaster_cert_chain_t * cert_chain)145 kmCertChain2Hidl(const keymaster_cert_chain_t* cert_chain) {
146 hidl_vec<hidl_vec<uint8_t>> result;
147 if (!cert_chain || cert_chain->entry_count == 0 || !cert_chain->entries) return result;
148
149 result.resize(cert_chain->entry_count);
150 for (size_t i = 0; i < cert_chain->entry_count; ++i) {
151 auto& entry = cert_chain->entries[i];
152 result[i] = kmBlob2hidlVec(entry);
153 }
154
155 return result;
156 }
157
kmParamSet2Hidl(const keymaster_key_param_set_t & set)158 static inline hidl_vec<KeyParameter> kmParamSet2Hidl(const keymaster_key_param_set_t& set) {
159 hidl_vec<KeyParameter> result;
160 if (set.length == 0 || set.params == nullptr) return result;
161
162 result.resize(set.length);
163 keymaster_key_param_t* params = set.params;
164 for (size_t i = 0; i < set.length; ++i) {
165 auto tag = params[i].tag;
166 result[i].tag = legacy_enum_conversion(tag);
167 switch (typeFromTag(tag)) {
168 case KM_ENUM:
169 case KM_ENUM_REP:
170 result[i].f.integer = params[i].enumerated;
171 break;
172 case KM_UINT:
173 case KM_UINT_REP:
174 result[i].f.integer = params[i].integer;
175 break;
176 case KM_ULONG:
177 case KM_ULONG_REP:
178 result[i].f.longInteger = params[i].long_integer;
179 break;
180 case KM_DATE:
181 result[i].f.dateTime = params[i].date_time;
182 break;
183 case KM_BOOL:
184 result[i].f.boolValue = params[i].boolean;
185 break;
186 case KM_BIGNUM:
187 case KM_BYTES:
188 result[i].blob.setToExternal(const_cast<unsigned char*>(params[i].blob.data),
189 params[i].blob.data_length);
190 break;
191 case KM_INVALID:
192 default:
193 params[i].tag = KM_TAG_INVALID;
194 /* just skip */
195 break;
196 }
197 }
198 return result;
199 }
200
201 // Methods from ::android::hardware::keymaster::V3_0::IKeymasterDevice follow.
getHardwareFeatures(getHardwareFeatures_cb _hidl_cb)202 Return<void> LegacyKeymasterDeviceWrapper::getHardwareFeatures(getHardwareFeatures_cb _hidl_cb) {
203 _hidl_cb(false, false, false, false, false, "Fallback Device", "Google Android Security");
204 return Void();
205 }
206
addRngEntropy(const hidl_vec<uint8_t> & data)207 Return<ErrorCode> LegacyKeymasterDeviceWrapper::addRngEntropy(const hidl_vec<uint8_t>& data) {
208 return legacy_enum_conversion(
209 keymaster_device_->add_rng_entropy(keymaster_device_, &data[0], data.size()));
210 }
211
generateKey(const hidl_vec<KeyParameter> & keyParams,generateKey_cb _hidl_cb)212 Return<void> LegacyKeymasterDeviceWrapper::generateKey(const hidl_vec<KeyParameter>& keyParams,
213 generateKey_cb _hidl_cb) {
214 // result variables for the wire
215 KeyCharacteristics resultCharacteristics;
216 hidl_vec<uint8_t> resultKeyBlob;
217
218 // result variables the backend understands
219 keymaster_key_blob_t key_blob{nullptr, 0};
220 keymaster_key_characteristics_t key_characteristics{{nullptr, 0}, {nullptr, 0}};
221
222 // convert the parameter set to something our backend understands
223 auto kmParams = hidlParams2KmParamSet(keyParams);
224
225 auto rc = keymaster_device_->generate_key(keymaster_device_, &kmParams, &key_blob,
226 &key_characteristics);
227
228 if (rc == KM_ERROR_OK) {
229 // on success convert the result to wire format
230 resultKeyBlob = kmBlob2hidlVec(key_blob);
231 resultCharacteristics.softwareEnforced = kmParamSet2Hidl(key_characteristics.sw_enforced);
232 resultCharacteristics.teeEnforced = kmParamSet2Hidl(key_characteristics.hw_enforced);
233 }
234
235 // send results off to the client
236 _hidl_cb(legacy_enum_conversion(rc), resultKeyBlob, resultCharacteristics);
237
238 // free buffers that we are responsible for
239 if (key_blob.key_material) free(const_cast<uint8_t*>(key_blob.key_material));
240 keymaster_free_characteristics(&key_characteristics);
241
242 return Void();
243 }
244
getKeyCharacteristics(const hidl_vec<uint8_t> & keyBlob,const hidl_vec<uint8_t> & clientId,const hidl_vec<uint8_t> & appData,getKeyCharacteristics_cb _hidl_cb)245 Return<void> LegacyKeymasterDeviceWrapper::getKeyCharacteristics(
246 const hidl_vec<uint8_t>& keyBlob, const hidl_vec<uint8_t>& clientId,
247 const hidl_vec<uint8_t>& appData, getKeyCharacteristics_cb _hidl_cb) {
248 // result variables for the wire
249 KeyCharacteristics resultCharacteristics;
250
251 // result variables the backend understands
252 keymaster_key_characteristics_t key_characteristics{{nullptr, 0}, {nullptr, 0}};
253
254 auto kmKeyBlob = hidlVec2KmKeyBlob(keyBlob);
255 auto kmClientId = hidlVec2KmBlob(clientId);
256 auto kmAppData = hidlVec2KmBlob(appData);
257
258 auto rc = keymaster_device_->get_key_characteristics(
259 keymaster_device_, keyBlob.size() ? &kmKeyBlob : nullptr,
260 clientId.size() ? &kmClientId : nullptr, appData.size() ? &kmAppData : nullptr,
261 &key_characteristics);
262
263 if (rc == KM_ERROR_OK) {
264 resultCharacteristics.softwareEnforced = kmParamSet2Hidl(key_characteristics.sw_enforced);
265 resultCharacteristics.teeEnforced = kmParamSet2Hidl(key_characteristics.hw_enforced);
266 }
267
268 _hidl_cb(legacy_enum_conversion(rc), resultCharacteristics);
269
270 keymaster_free_characteristics(&key_characteristics);
271
272 return Void();
273 }
274
importKey(const hidl_vec<KeyParameter> & params,KeyFormat keyFormat,const hidl_vec<uint8_t> & keyData,importKey_cb _hidl_cb)275 Return<void> LegacyKeymasterDeviceWrapper::importKey(const hidl_vec<KeyParameter>& params,
276 KeyFormat keyFormat,
277 const hidl_vec<uint8_t>& keyData,
278 importKey_cb _hidl_cb) {
279 // result variables for the wire
280 KeyCharacteristics resultCharacteristics;
281 hidl_vec<uint8_t> resultKeyBlob;
282
283 // result variables the backend understands
284 keymaster_key_blob_t key_blob{nullptr, 0};
285 keymaster_key_characteristics_t key_characteristics{{nullptr, 0}, {nullptr, 0}};
286
287 auto kmParams = hidlParams2KmParamSet(params);
288 auto kmKeyData = hidlVec2KmBlob(keyData);
289
290 auto rc = keymaster_device_->import_key(keymaster_device_, &kmParams,
291 legacy_enum_conversion(keyFormat), &kmKeyData,
292 &key_blob, &key_characteristics);
293
294 if (rc == KM_ERROR_OK) {
295 // on success convert the result to wire format
296 resultKeyBlob = kmBlob2hidlVec(key_blob);
297 resultCharacteristics.softwareEnforced = kmParamSet2Hidl(key_characteristics.sw_enforced);
298 resultCharacteristics.teeEnforced = kmParamSet2Hidl(key_characteristics.hw_enforced);
299 }
300
301 _hidl_cb(legacy_enum_conversion(rc), resultKeyBlob, resultCharacteristics);
302
303 // free buffers that we are responsible for
304 if (key_blob.key_material) free(const_cast<uint8_t*>(key_blob.key_material));
305 keymaster_free_characteristics(&key_characteristics);
306
307 return Void();
308 }
309
exportKey(KeyFormat exportFormat,const hidl_vec<uint8_t> & keyBlob,const hidl_vec<uint8_t> & clientId,const hidl_vec<uint8_t> & appData,exportKey_cb _hidl_cb)310 Return<void> LegacyKeymasterDeviceWrapper::exportKey(KeyFormat exportFormat,
311 const hidl_vec<uint8_t>& keyBlob,
312 const hidl_vec<uint8_t>& clientId,
313 const hidl_vec<uint8_t>& appData,
314 exportKey_cb _hidl_cb) {
315
316 // result variables for the wire
317 hidl_vec<uint8_t> resultKeyBlob;
318
319 // result variables the backend understands
320 keymaster_blob_t out_blob = {};
321
322 auto kmKeyBlob = hidlVec2KmKeyBlob(keyBlob);
323 auto kmClientId = hidlVec2KmBlob(clientId);
324 auto kmAppData = hidlVec2KmBlob(appData);
325
326 auto rc = keymaster_device_->export_key(keymaster_device_, legacy_enum_conversion(exportFormat),
327 keyBlob.size() ? &kmKeyBlob : nullptr,
328 clientId.size() ? &kmClientId : nullptr,
329 appData.size() ? &kmAppData : nullptr, &out_blob);
330
331 if (rc == KM_ERROR_OK) {
332 // on success convert the result to wire format
333 // (Can we assume that key_blob is {nullptr, 0} or a valid buffer description?)
334 resultKeyBlob = kmBlob2hidlVec(out_blob);
335 }
336
337 _hidl_cb(legacy_enum_conversion(rc), resultKeyBlob);
338
339 // free buffers that we are responsible for
340 if (out_blob.data) free(const_cast<uint8_t*>(out_blob.data));
341
342 return Void();
343 }
344
attestKey(const hidl_vec<uint8_t> & keyToAttest,const hidl_vec<KeyParameter> & attestParams,attestKey_cb _hidl_cb)345 Return<void> LegacyKeymasterDeviceWrapper::attestKey(const hidl_vec<uint8_t>& keyToAttest,
346 const hidl_vec<KeyParameter>& attestParams,
347 attestKey_cb _hidl_cb) {
348
349 hidl_vec<hidl_vec<uint8_t>> resultCertChain;
350
351 for (size_t i = 0; i < attestParams.size(); ++i) {
352 switch (attestParams[i].tag) {
353 case Tag::ATTESTATION_ID_BRAND:
354 case Tag::ATTESTATION_ID_DEVICE:
355 case Tag::ATTESTATION_ID_PRODUCT:
356 case Tag::ATTESTATION_ID_SERIAL:
357 case Tag::ATTESTATION_ID_IMEI:
358 case Tag::ATTESTATION_ID_MEID:
359 case Tag::ATTESTATION_ID_MANUFACTURER:
360 case Tag::ATTESTATION_ID_MODEL:
361 // Device id attestation may only be supported if the device is able to permanently
362 // destroy its knowledge of the ids. This device is unable to do this, so it must
363 // never perform any device id attestation.
364 _hidl_cb(ErrorCode::CANNOT_ATTEST_IDS, resultCertChain);
365 return Void();
366 default:
367 break;
368 }
369 }
370
371 keymaster_cert_chain_t cert_chain = {};
372
373 auto kmKeyToAttest = hidlVec2KmKeyBlob(keyToAttest);
374 auto kmAttestParams = hidlParams2KmParamSet(attestParams);
375
376 auto rc = keymaster_device_->attest_key(keymaster_device_, &kmKeyToAttest, &kmAttestParams,
377 &cert_chain);
378
379 if (rc == KM_ERROR_OK) {
380 resultCertChain = kmCertChain2Hidl(&cert_chain);
381 }
382
383 _hidl_cb(legacy_enum_conversion(rc), resultCertChain);
384
385 keymaster_free_cert_chain(&cert_chain);
386
387 return Void();
388 }
389
upgradeKey(const hidl_vec<uint8_t> & keyBlobToUpgrade,const hidl_vec<KeyParameter> & upgradeParams,upgradeKey_cb _hidl_cb)390 Return<void> LegacyKeymasterDeviceWrapper::upgradeKey(const hidl_vec<uint8_t>& keyBlobToUpgrade,
391 const hidl_vec<KeyParameter>& upgradeParams,
392 upgradeKey_cb _hidl_cb) {
393
394 // result variables for the wire
395 hidl_vec<uint8_t> resultKeyBlob;
396
397 // result variables the backend understands
398 keymaster_key_blob_t key_blob = {};
399
400 auto kmKeyBlobToUpgrade = hidlVec2KmKeyBlob(keyBlobToUpgrade);
401 auto kmUpgradeParams = hidlParams2KmParamSet(upgradeParams);
402
403 auto rc = keymaster_device_->upgrade_key(keymaster_device_, &kmKeyBlobToUpgrade,
404 &kmUpgradeParams, &key_blob);
405
406 if (rc == KM_ERROR_OK) {
407 // on success convert the result to wire format
408 resultKeyBlob = kmBlob2hidlVec(key_blob);
409 }
410
411 _hidl_cb(legacy_enum_conversion(rc), resultKeyBlob);
412
413 if (key_blob.key_material) free(const_cast<uint8_t*>(key_blob.key_material));
414
415 return Void();
416 }
417
deleteKey(const hidl_vec<uint8_t> & keyBlob)418 Return<ErrorCode> LegacyKeymasterDeviceWrapper::deleteKey(const hidl_vec<uint8_t>& keyBlob) {
419 auto kmKeyBlob = hidlVec2KmKeyBlob(keyBlob);
420 return legacy_enum_conversion(keymaster_device_->delete_key(keymaster_device_, &kmKeyBlob));
421 }
422
deleteAllKeys()423 Return<ErrorCode> LegacyKeymasterDeviceWrapper::deleteAllKeys() {
424 return legacy_enum_conversion(keymaster_device_->delete_all_keys(keymaster_device_));
425 }
426
destroyAttestationIds()427 Return<ErrorCode> LegacyKeymasterDeviceWrapper::destroyAttestationIds() {
428 return ErrorCode::UNIMPLEMENTED;
429 }
430
begin(KeyPurpose purpose,const hidl_vec<uint8_t> & key,const hidl_vec<KeyParameter> & inParams,begin_cb _hidl_cb)431 Return<void> LegacyKeymasterDeviceWrapper::begin(KeyPurpose purpose, const hidl_vec<uint8_t>& key,
432 const hidl_vec<KeyParameter>& inParams,
433 begin_cb _hidl_cb) {
434
435 // result variables for the wire
436 hidl_vec<KeyParameter> resultParams;
437 uint64_t resultOpHandle = 0;
438
439 // result variables the backend understands
440 keymaster_key_param_set_t out_params{nullptr, 0};
441 keymaster_operation_handle_t& operation_handle = resultOpHandle;
442
443 auto kmKey = hidlVec2KmKeyBlob(key);
444 auto kmInParams = hidlParams2KmParamSet(inParams);
445
446 auto rc = keymaster_device_->begin(keymaster_device_, legacy_enum_conversion(purpose), &kmKey,
447 &kmInParams, &out_params, &operation_handle);
448
449 if (rc == KM_ERROR_OK) resultParams = kmParamSet2Hidl(out_params);
450
451 _hidl_cb(legacy_enum_conversion(rc), resultParams, resultOpHandle);
452
453 keymaster_free_param_set(&out_params);
454
455 return Void();
456 }
457
update(uint64_t operationHandle,const hidl_vec<KeyParameter> & inParams,const hidl_vec<uint8_t> & input,update_cb _hidl_cb)458 Return<void> LegacyKeymasterDeviceWrapper::update(uint64_t operationHandle,
459 const hidl_vec<KeyParameter>& inParams,
460 const hidl_vec<uint8_t>& input,
461 update_cb _hidl_cb) {
462 // result variables for the wire
463 uint32_t resultConsumed = 0;
464 hidl_vec<KeyParameter> resultParams;
465 hidl_vec<uint8_t> resultBlob;
466
467 // result variables the backend understands
468 size_t consumed = 0;
469 keymaster_key_param_set_t out_params = {};
470 keymaster_blob_t out_blob = {};
471
472 auto kmInParams = hidlParams2KmParamSet(inParams);
473 auto kmInput = hidlVec2KmBlob(input);
474
475 auto rc = keymaster_device_->update(keymaster_device_, operationHandle, &kmInParams, &kmInput,
476 &consumed, &out_params, &out_blob);
477
478 if (rc == KM_ERROR_OK) {
479 resultConsumed = consumed;
480 resultParams = kmParamSet2Hidl(out_params);
481 resultBlob = kmBlob2hidlVec(out_blob);
482 }
483
484 _hidl_cb(legacy_enum_conversion(rc), resultConsumed, resultParams, resultBlob);
485
486 keymaster_free_param_set(&out_params);
487 if (out_blob.data) free(const_cast<uint8_t*>(out_blob.data));
488
489 return Void();
490 }
491
finish(uint64_t operationHandle,const hidl_vec<KeyParameter> & inParams,const hidl_vec<uint8_t> & input,const hidl_vec<uint8_t> & signature,finish_cb _hidl_cb)492 Return<void> LegacyKeymasterDeviceWrapper::finish(uint64_t operationHandle,
493 const hidl_vec<KeyParameter>& inParams,
494 const hidl_vec<uint8_t>& input,
495 const hidl_vec<uint8_t>& signature,
496 finish_cb _hidl_cb) {
497 // result variables for the wire
498 hidl_vec<KeyParameter> resultParams;
499 hidl_vec<uint8_t> resultBlob;
500
501 // result variables the backend understands
502 keymaster_key_param_set_t out_params = {};
503 keymaster_blob_t out_blob = {};
504
505 auto kmInParams = hidlParams2KmParamSet(inParams);
506 auto kmInput = hidlVec2KmBlob(input);
507 auto kmSignature = hidlVec2KmBlob(signature);
508
509 auto rc = keymaster_device_->finish(keymaster_device_, operationHandle, &kmInParams, &kmInput,
510 &kmSignature, &out_params, &out_blob);
511
512 if (rc == KM_ERROR_OK) {
513 resultParams = kmParamSet2Hidl(out_params);
514 resultBlob = kmBlob2hidlVec(out_blob);
515 }
516
517 _hidl_cb(legacy_enum_conversion(rc), resultParams, resultBlob);
518
519 keymaster_free_param_set(&out_params);
520 if (out_blob.data) free(const_cast<uint8_t*>(out_blob.data));
521
522 return Void();
523 }
524
abort(uint64_t operationHandle)525 Return<ErrorCode> LegacyKeymasterDeviceWrapper::abort(uint64_t operationHandle) {
526 return legacy_enum_conversion(keymaster_device_->abort(keymaster_device_, operationHandle));
527 }
528
makeSoftwareKeymasterDevice()529 sp<IKeymasterDevice> makeSoftwareKeymasterDevice() {
530 keymaster2_device_t* dev = nullptr;
531 dev = (new SoftKeymasterDevice)->keymaster2_device();
532
533 auto kmrc = ::keymaster::ConfigureDevice(dev);
534 if (kmrc != KM_ERROR_OK) {
535 dev->common.close(&dev->common);
536 return nullptr;
537 }
538
539 return new LegacyKeymasterDeviceWrapper(dev);
540 }
541
542 } // namespace keystore
543 } // namespace android
544