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 #include "android_keymaster_test_utils.h" 18 19 #include <algorithm> 20 21 #include <openssl/rand.h> 22 23 #include <keymaster/android_keymaster_messages.h> 24 #include <keymaster/android_keymaster_utils.h> 25 26 using std::is_permutation; 27 using std::ostream; 28 using std::string; 29 using std::vector; 30 31 std::ostream& operator<<(std::ostream& os, const keymaster_key_param_t& param) { 32 os << "Tag: " << keymaster_tag_mask_type(param.tag); 33 switch (keymaster_tag_get_type(param.tag)) { 34 case KM_INVALID: 35 os << " Invalid"; 36 break; 37 case KM_UINT_REP: 38 os << " (Rep)"; 39 /* Falls through */ 40 case KM_UINT: 41 os << " Int: " << param.integer; 42 break; 43 case KM_ENUM_REP: 44 os << " (Rep)"; 45 /* Falls through */ 46 case KM_ENUM: 47 os << " Enum: " << param.enumerated; 48 break; 49 case KM_ULONG_REP: 50 os << " (Rep)"; 51 /* Falls through */ 52 case KM_ULONG: 53 os << " Long: " << param.long_integer; 54 break; 55 case KM_DATE: 56 os << " Date: " << param.date_time; 57 break; 58 case KM_BOOL: 59 os << " Bool: " << param.boolean; 60 break; 61 case KM_BIGNUM: 62 os << " Bignum: "; 63 break; 64 case KM_BYTES: 65 os << " Bytes: "; 66 break; 67 } 68 return os; 69 } 70 71 bool operator==(const keymaster_key_param_t& a, const keymaster_key_param_t& b) { 72 if (a.tag != b.tag) { 73 return false; 74 } 75 76 switch (keymaster_tag_get_type(a.tag)) { 77 case KM_INVALID: 78 return true; 79 case KM_UINT_REP: 80 case KM_UINT: 81 return a.integer == b.integer; 82 case KM_ENUM_REP: 83 case KM_ENUM: 84 return a.enumerated == b.enumerated; 85 case KM_ULONG: 86 case KM_ULONG_REP: 87 return a.long_integer == b.long_integer; 88 case KM_DATE: 89 return a.date_time == b.date_time; 90 case KM_BOOL: 91 return a.boolean == b.boolean; 92 case KM_BIGNUM: 93 case KM_BYTES: 94 if ((a.blob.data == NULL || b.blob.data == NULL) && a.blob.data != b.blob.data) 95 return false; 96 return a.blob.data_length == b.blob.data_length && 97 (memcmp(a.blob.data, b.blob.data, a.blob.data_length) == 0); 98 } 99 100 return false; 101 } 102 103 static char hex_value[256] = { 104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 106 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, // '0'..'9' 107 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'A'..'F' 108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15, 0, 109 0, 0, 0, 0, 0, 0, 0, 0, // 'a'..'f' 110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 111 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 116 117 string hex2str(string a) { 118 string b; 119 size_t num = a.size() / 2; 120 b.resize(num); 121 for (size_t i = 0; i < num; i++) { 122 b[i] = (hex_value[a[i * 2] & 0xFF] << 4) + (hex_value[a[i * 2 + 1] & 0xFF]); 123 } 124 return b; 125 } 126 127 namespace keymaster { 128 129 bool operator==(const AuthorizationSet& a, const AuthorizationSet& b) { 130 if (a.size() != b.size()) 131 return false; 132 133 for (size_t i = 0; i < a.size(); ++i) 134 if (!(a[i] == b[i])) 135 return false; 136 return true; 137 } 138 139 bool operator!=(const AuthorizationSet& a, const AuthorizationSet& b) { 140 return !(a == b); 141 } 142 143 std::ostream& operator<<(std::ostream& os, const AuthorizationSet& set) { 144 if (set.size() == 0) 145 os << "(Empty)" << std::endl; 146 for (size_t i = 0; i < set.size(); ++i) { 147 os << set[i] << std::endl; 148 } 149 return os; 150 } 151 152 namespace test { 153 154 Keymaster1Test::Keymaster1Test() : op_handle_(OP_HANDLE_SENTINEL), characteristics_(NULL) { 155 blob_.key_material = NULL; 156 RAND_seed("foobar", 6); 157 blob_.key_material = 0; 158 device_ = GetParam()->CreateDevice(); 159 } 160 161 Keymaster1Test::~Keymaster1Test() { 162 FreeCharacteristics(); 163 FreeKeyBlob(); 164 device_->common.close(reinterpret_cast<hw_device_t*>(device_)); 165 } 166 167 keymaster1_device_t* Keymaster1Test::device() { 168 return device_; 169 } 170 171 keymaster_error_t Keymaster1Test::GenerateKey(const AuthorizationSetBuilder& builder) { 172 AuthorizationSet params(builder.build()); 173 params.push_back(UserAuthParams()); 174 params.push_back(ClientParams()); 175 176 FreeKeyBlob(); 177 FreeCharacteristics(); 178 return device()->generate_key(device(), ¶ms, &blob_, &characteristics_); 179 } 180 181 keymaster_error_t Keymaster1Test::ImportKey(const AuthorizationSetBuilder& builder, 182 keymaster_key_format_t format, 183 const string& key_material) { 184 AuthorizationSet params(builder.build()); 185 params.push_back(UserAuthParams()); 186 params.push_back(ClientParams()); 187 188 FreeKeyBlob(); 189 FreeCharacteristics(); 190 keymaster_blob_t key = {reinterpret_cast<const uint8_t*>(key_material.c_str()), 191 key_material.length()}; 192 return device()->import_key(device(), ¶ms, format, &key, &blob_, &characteristics_); 193 } 194 195 AuthorizationSet Keymaster1Test::UserAuthParams() { 196 AuthorizationSet set; 197 set.push_back(TAG_USER_ID, 7); 198 set.push_back(TAG_USER_AUTH_TYPE, HW_AUTH_PASSWORD); 199 set.push_back(TAG_AUTH_TIMEOUT, 300); 200 return set; 201 } 202 203 AuthorizationSet Keymaster1Test::ClientParams() { 204 AuthorizationSet set; 205 set.push_back(TAG_APPLICATION_ID, "app_id", 6); 206 return set; 207 } 208 209 keymaster_error_t Keymaster1Test::BeginOperation(keymaster_purpose_t purpose) { 210 AuthorizationSet in_params(client_params()); 211 keymaster_key_param_set_t out_params; 212 keymaster_error_t error = 213 device()->begin(device(), purpose, &blob_, &in_params, &out_params, &op_handle_); 214 EXPECT_EQ(0U, out_params.length); 215 EXPECT_TRUE(out_params.params == nullptr); 216 return error; 217 } 218 219 keymaster_error_t Keymaster1Test::BeginOperation(keymaster_purpose_t purpose, 220 const AuthorizationSet& input_set, 221 AuthorizationSet* output_set) { 222 keymaster_key_param_set_t out_params; 223 keymaster_error_t error = 224 device()->begin(device(), purpose, &blob_, &input_set, &out_params, &op_handle_); 225 if (error == KM_ERROR_OK) { 226 if (output_set) { 227 output_set->Reinitialize(out_params); 228 } else { 229 EXPECT_EQ(0U, out_params.length); 230 EXPECT_TRUE(out_params.params == nullptr); 231 } 232 keymaster_free_param_set(&out_params); 233 } 234 return error; 235 } 236 237 keymaster_error_t Keymaster1Test::UpdateOperation(const string& message, string* output, 238 size_t* input_consumed) { 239 EXPECT_NE(op_handle_, OP_HANDLE_SENTINEL); 240 keymaster_blob_t input = {reinterpret_cast<const uint8_t*>(message.c_str()), message.length()}; 241 keymaster_blob_t out_tmp; 242 keymaster_key_param_set_t out_params; 243 keymaster_error_t error = device()->update(device(), op_handle_, nullptr /* params */, &input, 244 input_consumed, &out_params, &out_tmp); 245 if (error == KM_ERROR_OK && out_tmp.data) 246 output->append(reinterpret_cast<const char*>(out_tmp.data), out_tmp.data_length); 247 free(const_cast<uint8_t*>(out_tmp.data)); 248 return error; 249 } 250 251 keymaster_error_t Keymaster1Test::UpdateOperation(const AuthorizationSet& additional_params, 252 const string& message, 253 AuthorizationSet* output_params, string* output, 254 size_t* input_consumed) { 255 EXPECT_NE(op_handle_, OP_HANDLE_SENTINEL); 256 keymaster_blob_t input = {reinterpret_cast<const uint8_t*>(message.c_str()), message.length()}; 257 keymaster_blob_t out_tmp; 258 keymaster_key_param_set_t out_params; 259 keymaster_error_t error = device()->update(device(), op_handle_, &additional_params, &input, 260 input_consumed, &out_params, &out_tmp); 261 if (error == KM_ERROR_OK && out_tmp.data) 262 output->append(reinterpret_cast<const char*>(out_tmp.data), out_tmp.data_length); 263 free((void*)out_tmp.data); 264 if (output_params) 265 output_params->Reinitialize(out_params); 266 keymaster_free_param_set(&out_params); 267 return error; 268 } 269 270 keymaster_error_t Keymaster1Test::FinishOperation(string* output) { 271 return FinishOperation("", output); 272 } 273 274 keymaster_error_t Keymaster1Test::FinishOperation(const string& signature, string* output) { 275 AuthorizationSet additional_params; 276 AuthorizationSet output_params; 277 return FinishOperation(additional_params, signature, &output_params, output); 278 } 279 280 keymaster_error_t Keymaster1Test::FinishOperation(const AuthorizationSet& additional_params, 281 const string& signature, 282 AuthorizationSet* output_params, string* output) { 283 keymaster_blob_t sig = {reinterpret_cast<const uint8_t*>(signature.c_str()), 284 signature.length()}; 285 keymaster_blob_t out_tmp; 286 keymaster_key_param_set_t out_params; 287 keymaster_error_t error = 288 device()->finish(device(), op_handle_, &additional_params, &sig, &out_params, &out_tmp); 289 if (error != KM_ERROR_OK) { 290 EXPECT_TRUE(out_tmp.data == nullptr); 291 EXPECT_TRUE(out_params.params == nullptr); 292 return error; 293 } 294 295 if (out_tmp.data) 296 output->append(reinterpret_cast<const char*>(out_tmp.data), out_tmp.data_length); 297 free((void*)out_tmp.data); 298 if (output_params) 299 output_params->Reinitialize(out_params); 300 keymaster_free_param_set(&out_params); 301 return error; 302 } 303 304 keymaster_error_t Keymaster1Test::AbortOperation() { 305 return device()->abort(device(), op_handle_); 306 } 307 308 string Keymaster1Test::ProcessMessage(keymaster_purpose_t purpose, const string& message) { 309 EXPECT_EQ(KM_ERROR_OK, BeginOperation(purpose, client_params(), NULL /* output_params */)); 310 311 string result; 312 size_t input_consumed; 313 EXPECT_EQ(KM_ERROR_OK, UpdateOperation(message, &result, &input_consumed)); 314 EXPECT_EQ(message.size(), input_consumed); 315 EXPECT_EQ(KM_ERROR_OK, FinishOperation(&result)); 316 return result; 317 } 318 319 string Keymaster1Test::ProcessMessage(keymaster_purpose_t purpose, const string& message, 320 const AuthorizationSet& begin_params, 321 const AuthorizationSet& update_params, 322 AuthorizationSet* begin_out_params) { 323 EXPECT_EQ(KM_ERROR_OK, BeginOperation(purpose, begin_params, begin_out_params)); 324 325 string result; 326 size_t input_consumed; 327 EXPECT_EQ(KM_ERROR_OK, UpdateOperation(update_params, message, nullptr /* output_params */, 328 &result, &input_consumed)); 329 EXPECT_EQ(message.size(), input_consumed); 330 EXPECT_EQ(KM_ERROR_OK, FinishOperation(update_params, "", &result)); 331 return result; 332 } 333 334 string Keymaster1Test::ProcessMessage(keymaster_purpose_t purpose, const string& message, 335 const string& signature, const AuthorizationSet& begin_params, 336 const AuthorizationSet& update_params, 337 AuthorizationSet* output_params) { 338 EXPECT_EQ(KM_ERROR_OK, BeginOperation(purpose, begin_params, output_params)); 339 340 string result; 341 size_t input_consumed; 342 EXPECT_EQ(KM_ERROR_OK, UpdateOperation(update_params, message, nullptr /* output_params */, 343 &result, &input_consumed)); 344 EXPECT_EQ(message.size(), input_consumed); 345 EXPECT_EQ(KM_ERROR_OK, FinishOperation(update_params, signature, &result)); 346 return result; 347 } 348 349 string Keymaster1Test::ProcessMessage(keymaster_purpose_t purpose, const string& message, 350 const string& signature) { 351 EXPECT_EQ(KM_ERROR_OK, BeginOperation(purpose, client_params(), NULL /* output_params */)); 352 353 string result; 354 size_t input_consumed; 355 EXPECT_EQ(KM_ERROR_OK, UpdateOperation(message, &result, &input_consumed)); 356 EXPECT_EQ(message.size(), input_consumed); 357 EXPECT_EQ(KM_ERROR_OK, FinishOperation(signature, &result)); 358 return result; 359 } 360 361 void Keymaster1Test::SignMessage(const string& message, string* signature, 362 keymaster_digest_t digest) { 363 SCOPED_TRACE("SignMessage"); 364 AuthorizationSet input_params(AuthorizationSet(client_params_, array_length(client_params_))); 365 input_params.push_back(TAG_DIGEST, digest); 366 AuthorizationSet update_params; 367 AuthorizationSet output_params; 368 *signature = 369 ProcessMessage(KM_PURPOSE_SIGN, message, input_params, update_params, &output_params); 370 EXPECT_GT(signature->size(), 0U); 371 } 372 373 void Keymaster1Test::SignMessage(const string& message, string* signature, 374 keymaster_digest_t digest, keymaster_padding_t padding) { 375 SCOPED_TRACE("SignMessage"); 376 AuthorizationSet input_params(AuthorizationSet(client_params_, array_length(client_params_))); 377 input_params.push_back(TAG_DIGEST, digest); 378 input_params.push_back(TAG_PADDING, padding); 379 AuthorizationSet update_params; 380 AuthorizationSet output_params; 381 *signature = 382 ProcessMessage(KM_PURPOSE_SIGN, message, input_params, update_params, &output_params); 383 EXPECT_GT(signature->size(), 0U); 384 } 385 386 void Keymaster1Test::MacMessage(const string& message, string* signature, size_t mac_length) { 387 SCOPED_TRACE("SignMessage"); 388 AuthorizationSet input_params(AuthorizationSet(client_params_, array_length(client_params_))); 389 input_params.push_back(TAG_MAC_LENGTH, mac_length); 390 AuthorizationSet update_params; 391 AuthorizationSet output_params; 392 *signature = 393 ProcessMessage(KM_PURPOSE_SIGN, message, input_params, update_params, &output_params); 394 EXPECT_GT(signature->size(), 0U); 395 } 396 397 void Keymaster1Test::VerifyMessage(const string& message, const string& signature, 398 keymaster_digest_t digest) { 399 SCOPED_TRACE("VerifyMessage"); 400 AuthorizationSet input_params(client_params()); 401 input_params.push_back(TAG_DIGEST, digest); 402 AuthorizationSet update_params; 403 AuthorizationSet output_params; 404 ProcessMessage(KM_PURPOSE_VERIFY, message, signature, input_params, update_params, 405 &output_params); 406 } 407 408 void Keymaster1Test::VerifyMessage(const string& message, const string& signature, 409 keymaster_digest_t digest, keymaster_padding_t padding) { 410 SCOPED_TRACE("VerifyMessage"); 411 AuthorizationSet input_params(client_params()); 412 input_params.push_back(TAG_DIGEST, digest); 413 input_params.push_back(TAG_PADDING, padding); 414 AuthorizationSet update_params; 415 AuthorizationSet output_params; 416 ProcessMessage(KM_PURPOSE_VERIFY, message, signature, input_params, update_params, 417 &output_params); 418 } 419 420 void Keymaster1Test::VerifyMac(const string& message, const string& signature) { 421 SCOPED_TRACE("VerifyMac"); 422 ProcessMessage(KM_PURPOSE_VERIFY, message, signature); 423 } 424 425 string Keymaster1Test::EncryptMessage(const string& message, keymaster_padding_t padding, 426 string* generated_nonce) { 427 SCOPED_TRACE("EncryptMessage"); 428 AuthorizationSet begin_params(client_params()), output_params; 429 begin_params.push_back(TAG_PADDING, padding); 430 AuthorizationSet update_params; 431 string ciphertext = 432 ProcessMessage(KM_PURPOSE_ENCRYPT, message, begin_params, update_params, &output_params); 433 if (generated_nonce) { 434 keymaster_blob_t nonce_blob; 435 EXPECT_TRUE(output_params.GetTagValue(TAG_NONCE, &nonce_blob)); 436 *generated_nonce = make_string(nonce_blob.data, nonce_blob.data_length); 437 } else { 438 EXPECT_EQ(-1, output_params.find(TAG_NONCE)); 439 } 440 return ciphertext; 441 } 442 443 string Keymaster1Test::EncryptMessage(const string& message, keymaster_digest_t digest, 444 keymaster_padding_t padding, string* generated_nonce) { 445 AuthorizationSet update_params; 446 return EncryptMessage(update_params, message, digest, padding, generated_nonce); 447 } 448 449 string Keymaster1Test::EncryptMessage(const string& message, keymaster_block_mode_t block_mode, 450 keymaster_padding_t padding, string* generated_nonce) { 451 AuthorizationSet update_params; 452 return EncryptMessage(update_params, message, block_mode, padding, generated_nonce); 453 } 454 455 string Keymaster1Test::EncryptMessage(const AuthorizationSet& update_params, const string& message, 456 keymaster_digest_t digest, keymaster_padding_t padding, 457 string* generated_nonce) { 458 SCOPED_TRACE("EncryptMessage"); 459 AuthorizationSet begin_params(client_params()), output_params; 460 begin_params.push_back(TAG_PADDING, padding); 461 begin_params.push_back(TAG_DIGEST, digest); 462 string ciphertext = 463 ProcessMessage(KM_PURPOSE_ENCRYPT, message, begin_params, update_params, &output_params); 464 if (generated_nonce) { 465 keymaster_blob_t nonce_blob; 466 EXPECT_TRUE(output_params.GetTagValue(TAG_NONCE, &nonce_blob)); 467 *generated_nonce = make_string(nonce_blob.data, nonce_blob.data_length); 468 } else { 469 EXPECT_EQ(-1, output_params.find(TAG_NONCE)); 470 } 471 return ciphertext; 472 } 473 474 string Keymaster1Test::EncryptMessage(const AuthorizationSet& update_params, const string& message, 475 keymaster_block_mode_t block_mode, 476 keymaster_padding_t padding, string* generated_nonce) { 477 SCOPED_TRACE("EncryptMessage"); 478 AuthorizationSet begin_params(client_params()), output_params; 479 begin_params.push_back(TAG_PADDING, padding); 480 begin_params.push_back(TAG_BLOCK_MODE, block_mode); 481 string ciphertext = 482 ProcessMessage(KM_PURPOSE_ENCRYPT, message, begin_params, update_params, &output_params); 483 if (generated_nonce) { 484 keymaster_blob_t nonce_blob; 485 EXPECT_TRUE(output_params.GetTagValue(TAG_NONCE, &nonce_blob)); 486 *generated_nonce = make_string(nonce_blob.data, nonce_blob.data_length); 487 } else { 488 EXPECT_EQ(-1, output_params.find(TAG_NONCE)); 489 } 490 return ciphertext; 491 } 492 493 string Keymaster1Test::EncryptMessageWithParams(const string& message, 494 const AuthorizationSet& begin_params, 495 const AuthorizationSet& update_params, 496 AuthorizationSet* output_params) { 497 SCOPED_TRACE("EncryptMessageWithParams"); 498 return ProcessMessage(KM_PURPOSE_ENCRYPT, message, begin_params, update_params, output_params); 499 } 500 501 string Keymaster1Test::DecryptMessage(const string& ciphertext, keymaster_padding_t padding) { 502 SCOPED_TRACE("DecryptMessage"); 503 AuthorizationSet begin_params(client_params()); 504 begin_params.push_back(TAG_PADDING, padding); 505 AuthorizationSet update_params; 506 return ProcessMessage(KM_PURPOSE_DECRYPT, ciphertext, begin_params, update_params); 507 } 508 509 string Keymaster1Test::DecryptMessage(const string& ciphertext, keymaster_digest_t digest, 510 keymaster_padding_t padding) { 511 SCOPED_TRACE("DecryptMessage"); 512 AuthorizationSet begin_params(client_params()); 513 begin_params.push_back(TAG_PADDING, padding); 514 begin_params.push_back(TAG_DIGEST, digest); 515 AuthorizationSet update_params; 516 return ProcessMessage(KM_PURPOSE_DECRYPT, ciphertext, begin_params, update_params); 517 } 518 519 string Keymaster1Test::DecryptMessage(const string& ciphertext, keymaster_block_mode_t block_mode, 520 keymaster_padding_t padding) { 521 SCOPED_TRACE("DecryptMessage"); 522 AuthorizationSet begin_params(client_params()); 523 begin_params.push_back(TAG_PADDING, padding); 524 begin_params.push_back(TAG_BLOCK_MODE, block_mode); 525 AuthorizationSet update_params; 526 return ProcessMessage(KM_PURPOSE_DECRYPT, ciphertext, begin_params, update_params); 527 } 528 529 string Keymaster1Test::DecryptMessage(const string& ciphertext, keymaster_digest_t digest, 530 keymaster_padding_t padding, const string& nonce) { 531 SCOPED_TRACE("DecryptMessage"); 532 AuthorizationSet begin_params(client_params()); 533 begin_params.push_back(TAG_PADDING, padding); 534 begin_params.push_back(TAG_DIGEST, digest); 535 begin_params.push_back(TAG_NONCE, nonce.data(), nonce.size()); 536 AuthorizationSet update_params; 537 return ProcessMessage(KM_PURPOSE_DECRYPT, ciphertext, begin_params, update_params); 538 } 539 540 string Keymaster1Test::DecryptMessage(const string& ciphertext, keymaster_block_mode_t block_mode, 541 keymaster_padding_t padding, const string& nonce) { 542 SCOPED_TRACE("DecryptMessage"); 543 AuthorizationSet begin_params(client_params()); 544 begin_params.push_back(TAG_PADDING, padding); 545 begin_params.push_back(TAG_BLOCK_MODE, block_mode); 546 begin_params.push_back(TAG_NONCE, nonce.data(), nonce.size()); 547 AuthorizationSet update_params; 548 return ProcessMessage(KM_PURPOSE_DECRYPT, ciphertext, begin_params, update_params); 549 } 550 551 string Keymaster1Test::DecryptMessage(const AuthorizationSet& update_params, 552 const string& ciphertext, keymaster_digest_t digest, 553 keymaster_padding_t padding, const string& nonce) { 554 SCOPED_TRACE("DecryptMessage"); 555 AuthorizationSet begin_params(client_params()); 556 begin_params.push_back(TAG_PADDING, padding); 557 begin_params.push_back(TAG_DIGEST, digest); 558 begin_params.push_back(TAG_NONCE, nonce.data(), nonce.size()); 559 return ProcessMessage(KM_PURPOSE_DECRYPT, ciphertext, begin_params, update_params); 560 } 561 562 keymaster_error_t Keymaster1Test::GetCharacteristics() { 563 FreeCharacteristics(); 564 return device()->get_key_characteristics(device(), &blob_, &client_id_, NULL /* app_data */, 565 &characteristics_); 566 } 567 568 keymaster_error_t Keymaster1Test::ExportKey(keymaster_key_format_t format, string* export_data) { 569 keymaster_blob_t export_tmp; 570 keymaster_error_t error = device()->export_key(device(), format, &blob_, &client_id_, 571 NULL /* app_data */, &export_tmp); 572 573 if (error != KM_ERROR_OK) 574 return error; 575 576 *export_data = string(reinterpret_cast<const char*>(export_tmp.data), export_tmp.data_length); 577 free((void*)export_tmp.data); 578 return error; 579 } 580 581 void Keymaster1Test::CheckHmacTestVector(string key, string message, keymaster_digest_t digest, 582 string expected_mac) { 583 ASSERT_EQ(KM_ERROR_OK, ImportKey(AuthorizationSetBuilder() 584 .HmacKey(key.size() * 8) 585 .Authorization(TAG_MIN_MAC_LENGTH, expected_mac.size() * 8) 586 .Digest(digest), 587 KM_KEY_FORMAT_RAW, key)); 588 string signature; 589 MacMessage(message, &signature, expected_mac.size() * 8); 590 EXPECT_EQ(expected_mac, signature) << "Test vector didn't match for digest " << (int)digest; 591 } 592 593 void Keymaster1Test::CheckAesCtrTestVector(const string& key, const string& nonce, 594 const string& message, 595 const string& expected_ciphertext) { 596 ASSERT_EQ(KM_ERROR_OK, ImportKey(AuthorizationSetBuilder() 597 .AesEncryptionKey(key.size() * 8) 598 .Authorization(TAG_BLOCK_MODE, KM_MODE_CTR) 599 .Authorization(TAG_CALLER_NONCE) 600 .Padding(KM_PAD_NONE), 601 KM_KEY_FORMAT_RAW, key)); 602 603 AuthorizationSet begin_params(client_params()), update_params, output_params; 604 begin_params.push_back(TAG_NONCE, nonce.data(), nonce.size()); 605 begin_params.push_back(TAG_BLOCK_MODE, KM_MODE_CTR); 606 begin_params.push_back(TAG_PADDING, KM_PAD_NONE); 607 string ciphertext = 608 EncryptMessageWithParams(message, begin_params, update_params, &output_params); 609 EXPECT_EQ(expected_ciphertext, ciphertext); 610 } 611 612 AuthorizationSet Keymaster1Test::hw_enforced() { 613 EXPECT_TRUE(characteristics_ != NULL); 614 return AuthorizationSet(characteristics_->hw_enforced); 615 } 616 617 AuthorizationSet Keymaster1Test::sw_enforced() { 618 EXPECT_TRUE(characteristics_ != NULL); 619 return AuthorizationSet(characteristics_->sw_enforced); 620 } 621 622 void Keymaster1Test::FreeCharacteristics() { 623 keymaster_free_characteristics(characteristics_); 624 free(characteristics_); 625 characteristics_ = NULL; 626 } 627 628 void Keymaster1Test::FreeKeyBlob() { 629 free(const_cast<uint8_t*>(blob_.key_material)); 630 blob_.key_material = NULL; 631 } 632 633 void Keymaster1Test::corrupt_key_blob() { 634 assert(blob_.key_material); 635 uint8_t* tmp = const_cast<uint8_t*>(blob_.key_material); 636 ++tmp[blob_.key_material_size / 2]; 637 } 638 639 } // namespace test 640 } // namespace keymaster 641
