1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Permission is hereby granted, free of charge, to any person 5 * obtaining a copy of this software and associated documentation 6 * files (the "Software"), to deal in the Software without 7 * restriction, including without limitation the rights to use, copy, 8 * modify, merge, publish, distribute, sublicense, and/or sell copies 9 * of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 */ 24 25 #include <endian.h> 26 #include <string.h> 27 28 #include <gtest/gtest.h> 29 30 #include <libavb/avb_sha.h> 31 #include <libavb/libavb.h> 32 33 #include "avb_unittest_util.h" 34 35 namespace avb { 36 37 // Subclass BaseAvbToolTest to check for memory leaks. 38 class UtilTest : public BaseAvbToolTest { 39 public: 40 UtilTest() {} 41 }; 42 43 TEST_F(UtilTest, RSAPublicKeyHeaderByteswap) { 44 AvbRSAPublicKeyHeader h; 45 AvbRSAPublicKeyHeader s; 46 uint32_t n32; 47 uint64_t n64; 48 49 n32 = 0x11223344; 50 n64 = 0x1122334455667788; 51 52 h.key_num_bits = htobe32(n32); 53 n32++; 54 h.n0inv = htobe32(n32); 55 n32++; 56 57 EXPECT_NE(0, avb_rsa_public_key_header_validate_and_byteswap(&h, &s)); 58 59 n32 = 0x11223344; 60 n64 = 0x1122334455667788; 61 62 EXPECT_EQ(n32, s.key_num_bits); 63 n32++; 64 EXPECT_EQ(n32, s.n0inv); 65 n32++; 66 } 67 68 TEST_F(UtilTest, FooterByteswap) { 69 AvbFooter h; 70 AvbFooter s; 71 AvbFooter other; 72 AvbFooter bad; 73 uint64_t n64; 74 75 n64 = 0x1122334455667788; 76 77 memcpy(h.magic, AVB_FOOTER_MAGIC, AVB_FOOTER_MAGIC_LEN); 78 h.version_major = htobe32(AVB_FOOTER_VERSION_MAJOR); 79 h.version_minor = htobe32(AVB_FOOTER_VERSION_MINOR); 80 h.original_image_size = htobe64(n64); 81 n64++; 82 h.vbmeta_offset = htobe64(n64); 83 n64++; 84 h.vbmeta_size = htobe64(n64); 85 n64++; 86 87 EXPECT_NE(0, avb_footer_validate_and_byteswap(&h, &s)); 88 89 n64 = 0x1122334455667788; 90 91 EXPECT_EQ((uint32_t)AVB_FOOTER_VERSION_MAJOR, s.version_major); 92 EXPECT_EQ((uint32_t)AVB_FOOTER_VERSION_MINOR, s.version_minor); 93 EXPECT_EQ(n64, s.original_image_size); 94 n64++; 95 EXPECT_EQ(n64, s.vbmeta_offset); 96 n64++; 97 EXPECT_EQ(n64, s.vbmeta_size); 98 n64++; 99 100 // Check that the struct still validates if minor is bigger than 101 // what we expect. 102 other = h; 103 h.version_minor = htobe32(AVB_FOOTER_VERSION_MINOR + 1); 104 EXPECT_NE(0, avb_footer_validate_and_byteswap(&other, &s)); 105 106 // Check for bad magic. 107 bad = h; 108 bad.magic[0] = 'x'; 109 EXPECT_EQ(0, avb_footer_validate_and_byteswap(&bad, &s)); 110 111 // Check for bad major version. 112 bad = h; 113 bad.version_major = htobe32(AVB_FOOTER_VERSION_MAJOR + 1); 114 EXPECT_EQ(0, avb_footer_validate_and_byteswap(&bad, &s)); 115 } 116 117 TEST_F(UtilTest, KernelCmdlineDescriptorByteswap) { 118 AvbKernelCmdlineDescriptor h; 119 AvbKernelCmdlineDescriptor s; 120 AvbKernelCmdlineDescriptor bad; 121 uint64_t nbf; 122 uint32_t n32; 123 124 // Specify 40 bytes of data past the end of the descriptor struct. 125 nbf = 40 + sizeof(AvbKernelCmdlineDescriptor) - sizeof(AvbDescriptor); 126 h.parent_descriptor.num_bytes_following = htobe64(nbf); 127 h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_KERNEL_CMDLINE); 128 h.kernel_cmdline_length = htobe32(40); 129 130 n32 = 0x11223344; 131 h.flags = htobe32(n32); 132 n32++; 133 134 EXPECT_NE(0, avb_kernel_cmdline_descriptor_validate_and_byteswap(&h, &s)); 135 136 n32 = 0x11223344; 137 EXPECT_EQ(n32, s.flags); 138 n32++; 139 140 EXPECT_EQ(AVB_DESCRIPTOR_TAG_KERNEL_CMDLINE, s.parent_descriptor.tag); 141 EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following); 142 EXPECT_EQ(40UL, s.kernel_cmdline_length); 143 144 // Check for bad tag. 145 bad = h; 146 bad.parent_descriptor.tag = htobe64(0xf00dd00d); 147 EXPECT_EQ(0, avb_kernel_cmdline_descriptor_validate_and_byteswap(&bad, &s)); 148 149 // Doesn't fit in 41 bytes. 150 bad = h; 151 bad.kernel_cmdline_length = htobe32(41); 152 EXPECT_EQ(0, avb_kernel_cmdline_descriptor_validate_and_byteswap(&bad, &s)); 153 } 154 155 TEST_F(UtilTest, HashtreeDescriptorByteswap) { 156 AvbHashtreeDescriptor h; 157 AvbHashtreeDescriptor s; 158 AvbHashtreeDescriptor bad; 159 uint64_t nbf; 160 uint32_t n32; 161 uint64_t n64; 162 163 // Specify 44 bytes of data past the end of the descriptor struct. 164 nbf = 44 + sizeof(AvbHashtreeDescriptor) - sizeof(AvbDescriptor); 165 h.parent_descriptor.num_bytes_following = htobe64(nbf); 166 h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_HASHTREE); 167 h.partition_name_len = htobe32(10); 168 h.salt_len = htobe32(10); 169 h.root_digest_len = htobe32(10); 170 171 n32 = 0x11223344; 172 n64 = 0x1122334455667788; 173 174 h.dm_verity_version = htobe32(n32); 175 n32++; 176 h.image_size = htobe64(n64); 177 n64++; 178 h.tree_offset = htobe64(n64); 179 n64++; 180 h.tree_size = htobe64(n64); 181 n64++; 182 h.data_block_size = htobe32(n32); 183 n32++; 184 h.hash_block_size = htobe32(n32); 185 n32++; 186 h.fec_num_roots = htobe32(n32); 187 n32++; 188 h.fec_offset = htobe64(n64); 189 n64++; 190 h.fec_size = htobe64(n64); 191 n64++; 192 193 EXPECT_TRUE(avb_hashtree_descriptor_validate_and_byteswap(&h, &s)); 194 195 n32 = 0x11223344; 196 n64 = 0x1122334455667788; 197 198 EXPECT_EQ(n32, s.dm_verity_version); 199 n32++; 200 EXPECT_EQ(n64, s.image_size); 201 n64++; 202 EXPECT_EQ(n64, s.tree_offset); 203 n64++; 204 EXPECT_EQ(n64, s.tree_size); 205 n64++; 206 EXPECT_EQ(n32, s.data_block_size); 207 n32++; 208 EXPECT_EQ(n32, s.hash_block_size); 209 n32++; 210 EXPECT_EQ(n32, s.fec_num_roots); 211 n32++; 212 EXPECT_EQ(n64, s.fec_offset); 213 n64++; 214 EXPECT_EQ(n64, s.fec_size); 215 n64++; 216 217 EXPECT_EQ(AVB_DESCRIPTOR_TAG_HASHTREE, s.parent_descriptor.tag); 218 EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following); 219 EXPECT_EQ(10UL, s.partition_name_len); 220 EXPECT_EQ(10UL, s.salt_len); 221 EXPECT_EQ(10UL, s.root_digest_len); 222 223 // Check for bad tag. 224 bad = h; 225 bad.parent_descriptor.tag = htobe64(0xf00dd00d); 226 EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s)); 227 228 // Doesn't fit in 44 bytes (30 + 10 + 10 = 50). 229 bad = h; 230 bad.partition_name_len = htobe32(30); 231 EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s)); 232 233 // Doesn't fit in 44 bytes (10 + 30 + 10 = 50). 234 bad = h; 235 bad.salt_len = htobe32(30); 236 EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s)); 237 238 // Doesn't fit in 44 bytes (10 + 10 + 30 = 50). 239 bad = h; 240 bad.root_digest_len = htobe32(30); 241 EXPECT_FALSE(avb_hashtree_descriptor_validate_and_byteswap(&bad, &s)); 242 } 243 244 TEST_F(UtilTest, HashDescriptorByteswap) { 245 AvbHashDescriptor h; 246 AvbHashDescriptor s; 247 AvbHashDescriptor bad; 248 uint64_t nbf; 249 250 // Specify 44 bytes of data past the end of the descriptor struct. 251 nbf = 44 + sizeof(AvbHashDescriptor) - sizeof(AvbDescriptor); 252 h.parent_descriptor.num_bytes_following = htobe64(nbf); 253 h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_HASH); 254 h.partition_name_len = htobe32(10); 255 h.salt_len = htobe32(10); 256 h.digest_len = htobe32(10); 257 258 EXPECT_NE(0, avb_hash_descriptor_validate_and_byteswap(&h, &s)); 259 260 EXPECT_EQ(AVB_DESCRIPTOR_TAG_HASH, s.parent_descriptor.tag); 261 EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following); 262 EXPECT_EQ(10UL, s.partition_name_len); 263 EXPECT_EQ(10UL, s.salt_len); 264 EXPECT_EQ(10UL, s.digest_len); 265 266 // Check for bad tag. 267 bad = h; 268 bad.parent_descriptor.tag = htobe64(0xf00dd00d); 269 EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s)); 270 271 // Doesn't fit in 44 bytes (30 + 10 + 10 = 50). 272 bad = h; 273 bad.partition_name_len = htobe32(30); 274 EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s)); 275 276 // Doesn't fit in 44 bytes (10 + 30 + 10 = 50). 277 bad = h; 278 bad.salt_len = htobe32(30); 279 EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s)); 280 281 // Doesn't fit in 44 bytes (10 + 10 + 30 = 50). 282 bad = h; 283 bad.digest_len = htobe32(30); 284 EXPECT_EQ(0, avb_hash_descriptor_validate_and_byteswap(&bad, &s)); 285 } 286 287 TEST_F(UtilTest, ChainPartitionDescriptorByteswap) { 288 AvbChainPartitionDescriptor h; 289 AvbChainPartitionDescriptor s; 290 AvbChainPartitionDescriptor bad; 291 uint64_t nbf; 292 293 // Specify 36 bytes of data past the end of the descriptor struct. 294 nbf = 36 + sizeof(AvbChainPartitionDescriptor) - sizeof(AvbDescriptor); 295 h.parent_descriptor.num_bytes_following = htobe64(nbf); 296 h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_CHAIN_PARTITION); 297 h.rollback_index_location = htobe32(42); 298 h.partition_name_len = htobe32(16); 299 h.public_key_len = htobe32(17); 300 301 EXPECT_NE(0, avb_chain_partition_descriptor_validate_and_byteswap(&h, &s)); 302 303 EXPECT_EQ(AVB_DESCRIPTOR_TAG_CHAIN_PARTITION, s.parent_descriptor.tag); 304 EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following); 305 EXPECT_EQ(42UL, s.rollback_index_location); 306 EXPECT_EQ(16UL, s.partition_name_len); 307 EXPECT_EQ(17UL, s.public_key_len); 308 309 // Check for bad tag. 310 bad = h; 311 bad.parent_descriptor.tag = htobe64(0xf00dd00d); 312 EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s)); 313 314 // Check for bad rollback index slot (must be at least 1). 315 bad = h; 316 bad.rollback_index_location = htobe32(0); 317 EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s)); 318 319 // Doesn't fit in 40 bytes (24 + 17 = 41). 320 bad = h; 321 bad.partition_name_len = htobe32(24); 322 EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s)); 323 324 // Doesn't fit in 40 bytes (16 + 25 = 41). 325 bad = h; 326 bad.public_key_len = htobe32(25); 327 EXPECT_EQ(0, avb_chain_partition_descriptor_validate_and_byteswap(&bad, &s)); 328 } 329 330 TEST_F(UtilTest, PropertyDescriptorByteswap) { 331 AvbPropertyDescriptor h; 332 AvbPropertyDescriptor s; 333 AvbPropertyDescriptor bad; 334 uint64_t nbf; 335 336 // Specify 40 bytes of data past the end of the descriptor struct. 337 nbf = 40 + sizeof(AvbPropertyDescriptor) - sizeof(AvbDescriptor); 338 h.parent_descriptor.num_bytes_following = htobe64(nbf); 339 h.parent_descriptor.tag = htobe64(AVB_DESCRIPTOR_TAG_PROPERTY); 340 h.key_num_bytes = htobe64(16); 341 h.value_num_bytes = htobe64(17); 342 343 EXPECT_NE(0, avb_property_descriptor_validate_and_byteswap(&h, &s)); 344 345 EXPECT_EQ(AVB_DESCRIPTOR_TAG_PROPERTY, s.parent_descriptor.tag); 346 EXPECT_EQ(nbf, s.parent_descriptor.num_bytes_following); 347 EXPECT_EQ(16UL, s.key_num_bytes); 348 EXPECT_EQ(17UL, s.value_num_bytes); 349 350 // Check for bad tag. 351 bad = h; 352 bad.parent_descriptor.tag = htobe64(0xf00dd00d); 353 EXPECT_EQ(0, avb_property_descriptor_validate_and_byteswap(&bad, &s)); 354 355 // Doesn't fit in 40 bytes (22 + 17 + 2 = 41). 356 bad = h; 357 bad.key_num_bytes = htobe64(22); 358 EXPECT_EQ(0, avb_property_descriptor_validate_and_byteswap(&bad, &s)); 359 360 // Doesn't fit in 40 bytes (16 + 23 + 2 = 41). 361 bad = h; 362 bad.value_num_bytes = htobe64(23); 363 EXPECT_EQ(0, avb_property_descriptor_validate_and_byteswap(&bad, &s)); 364 } 365 366 TEST_F(UtilTest, DescriptorByteswap) { 367 AvbDescriptor h; 368 AvbDescriptor s; 369 uint64_t n64; 370 371 n64 = 0x1122334455667788; 372 373 h.num_bytes_following = htobe64(n64); 374 n64++; 375 h.tag = htobe64(n64); 376 n64++; 377 378 EXPECT_NE(0, avb_descriptor_validate_and_byteswap(&h, &s)); 379 380 n64 = 0x1122334455667788; 381 382 EXPECT_EQ(n64, s.num_bytes_following); 383 n64++; 384 EXPECT_EQ(n64, s.tag); 385 n64++; 386 387 // Check that we catch if |num_bytes_following| isn't divisble by 8. 388 h.num_bytes_following = htobe64(7); 389 EXPECT_EQ(0, avb_descriptor_validate_and_byteswap(&h, &s)); 390 } 391 392 TEST_F(UtilTest, SafeAddition) { 393 uint64_t value; 394 uint64_t pow2_60 = 1ULL << 60; 395 396 value = 2; 397 EXPECT_NE(0, avb_safe_add_to(&value, 5)); 398 EXPECT_EQ(7UL, value); 399 400 /* These should not overflow */ 401 value = 1 * pow2_60; 402 EXPECT_NE(0, avb_safe_add_to(&value, 2 * pow2_60)); 403 EXPECT_EQ(3 * pow2_60, value); 404 value = 7 * pow2_60; 405 EXPECT_NE(0, avb_safe_add_to(&value, 8 * pow2_60)); 406 EXPECT_EQ(15 * pow2_60, value); 407 value = 9 * pow2_60; 408 EXPECT_NE(0, avb_safe_add_to(&value, 3 * pow2_60)); 409 EXPECT_EQ(12 * pow2_60, value); 410 value = 0xfffffffffffffffcUL; 411 EXPECT_NE(0, avb_safe_add_to(&value, 2)); 412 EXPECT_EQ(0xfffffffffffffffeUL, value); 413 414 /* These should overflow. */ 415 value = 8 * pow2_60; 416 EXPECT_EQ(0, avb_safe_add_to(&value, 8 * pow2_60)); 417 value = 0xfffffffffffffffcUL; 418 EXPECT_EQ(0, avb_safe_add_to(&value, 4)); 419 } 420 421 static int avb_validate_utf8z(const char* data) { 422 return avb_validate_utf8(reinterpret_cast<const uint8_t*>(data), 423 strlen(data)); 424 } 425 426 TEST_F(UtilTest, UTF8Validation) { 427 // These should succeed. 428 EXPECT_NE(0, avb_validate_utf8z("foo bar")); 429 // Encoding of U+00E6 LATIN SMALL LETTER AE: 430 EXPECT_NE(0, avb_validate_utf8z("foo \xC3\xA6 bar")); 431 // Encoding of U+20AC EURO SIGN: 432 EXPECT_NE(0, avb_validate_utf8z("foo \xE2\x82\xAC bar")); 433 // Encoding of U+1F466 BOY: 434 EXPECT_NE(0, avb_validate_utf8z("foo \xF0\x9F\x91\xA6 bar")); 435 // All three runes following each other. 436 EXPECT_NE(0, avb_validate_utf8z("\xC3\xA6\xE2\x82\xAC\xF0\x9F\x91\xA6")); 437 438 // These should fail. 439 EXPECT_EQ(0, avb_validate_utf8z("foo \xF8 bar")); 440 EXPECT_EQ(0, avb_validate_utf8z("\xF8")); 441 // Stops in the middle of Unicode rune. 442 EXPECT_EQ(0, avb_validate_utf8z("foo \xC3")); 443 } 444 445 TEST_F(UtilTest, StrConcat) { 446 char buf[8]; 447 448 // These should succeed. 449 EXPECT_NE(0, avb_str_concat(buf, sizeof buf, "foo", 3, "bar1", 4)); 450 451 // This should fail: Insufficient space. 452 EXPECT_EQ(0, avb_str_concat(buf, sizeof buf, "foo0", 4, "bar1", 4)); 453 } 454 455 TEST_F(UtilTest, StrStr) { 456 const char* haystack = "abc def abcabc"; 457 458 EXPECT_EQ(nullptr, avb_strstr(haystack, "needle")); 459 EXPECT_EQ(haystack, avb_strstr(haystack, "abc")); 460 EXPECT_EQ(haystack + 4, avb_strstr(haystack, "def")); 461 EXPECT_EQ(haystack, avb_strstr(haystack, haystack)); 462 } 463 464 TEST_F(UtilTest, StrvFindStr) { 465 const char* strings[] = {"abcabc", "abc", "def", nullptr}; 466 467 EXPECT_EQ(nullptr, avb_strv_find_str(strings, "not there", 9)); 468 EXPECT_EQ(strings[1], avb_strv_find_str(strings, "abc", 3)); 469 EXPECT_EQ(strings[2], avb_strv_find_str(strings, "def", 3)); 470 EXPECT_EQ(strings[0], avb_strv_find_str(strings, "abcabc", 6)); 471 } 472 473 TEST_F(UtilTest, StrReplace) { 474 char* str; 475 476 str = avb_replace("$(FOO) blah bah $(FOO $(FOO) blah", "$(FOO)", "OK"); 477 EXPECT_EQ("OK blah bah $(FOO OK blah", std::string(str)); 478 avb_free(str); 479 480 str = avb_replace("$(FOO)", "$(FOO)", "OK"); 481 EXPECT_EQ("OK", std::string(str)); 482 avb_free(str); 483 484 str = avb_replace(" $(FOO)", "$(FOO)", "OK"); 485 EXPECT_EQ(" OK", std::string(str)); 486 avb_free(str); 487 488 str = avb_replace("$(FOO) ", "$(FOO)", "OK"); 489 EXPECT_EQ("OK ", std::string(str)); 490 avb_free(str); 491 492 str = avb_replace("$(FOO)$(FOO)", "$(FOO)", "LONGSTRING"); 493 EXPECT_EQ("LONGSTRINGLONGSTRING", std::string(str)); 494 avb_free(str); 495 } 496 497 TEST_F(UtilTest, StrDupV) { 498 char* str; 499 500 str = avb_strdupv("x", "y", "z", NULL); 501 EXPECT_EQ("xyz", std::string(str)); 502 avb_free(str); 503 504 str = avb_strdupv("Hello", "World", " XYZ", NULL); 505 EXPECT_EQ("HelloWorld XYZ", std::string(str)); 506 avb_free(str); 507 } 508 509 TEST_F(UtilTest, Crc32) { 510 /* Compare with output of crc32(1): 511 * 512 * $ (echo -n foobar > /tmp/crc32_input); crc32 /tmp/crc32_input 513 * 9ef61f95 514 */ 515 EXPECT_EQ(uint32_t(0x9ef61f95), avb_crc32((const uint8_t*)"foobar", 6)); 516 } 517 518 TEST_F(UtilTest, htobe32) { 519 EXPECT_EQ(avb_htobe32(0x12345678), htobe32(0x12345678)); 520 } 521 522 TEST_F(UtilTest, be32toh) { 523 EXPECT_EQ(avb_be32toh(0x12345678), be32toh(0x12345678)); 524 } 525 526 TEST_F(UtilTest, htobe64) { 527 EXPECT_EQ(avb_htobe64(0x123456789abcdef0), htobe64(0x123456789abcdef0)); 528 } 529 530 TEST_F(UtilTest, be64toh) { 531 EXPECT_EQ(avb_be64toh(0x123456789abcdef0), be64toh(0x123456789abcdef0)); 532 } 533 534 TEST_F(UtilTest, Basename) { 535 EXPECT_EQ("foobar.c", std::string(avb_basename("foobar.c"))); 536 EXPECT_EQ("foobar.c", std::string(avb_basename("/path/to/foobar.c"))); 537 EXPECT_EQ("foobar.c", std::string(avb_basename("a/foobar.c"))); 538 EXPECT_EQ("baz.c", std::string(avb_basename("/baz.c"))); 539 EXPECT_EQ("some_dir/", std::string(avb_basename("some_dir/"))); 540 EXPECT_EQ("some_dir/", std::string(avb_basename("/path/to/some_dir/"))); 541 EXPECT_EQ("some_dir/", std::string(avb_basename("a/some_dir/"))); 542 EXPECT_EQ("some_dir/", std::string(avb_basename("/some_dir/"))); 543 EXPECT_EQ("/", std::string(avb_basename("/"))); 544 } 545 546 TEST_F(UtilTest, Sha256) { 547 AvbSHA256Ctx ctx; 548 549 /* Compare with 550 * 551 * $ echo -n foobar |sha256sum 552 * c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2 - 553 */ 554 avb_sha256_init(&ctx); 555 avb_sha256_update(&ctx, (const uint8_t*)"foobar", 6); 556 EXPECT_EQ("c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2", 557 mem_to_hexstring(avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE)); 558 } 559 560 // Disabled for now because it takes ~30 seconds to run. 561 TEST_F(UtilTest, DISABLED_Sha256Large) { 562 AvbSHA256Ctx ctx; 563 564 /* Also check we this works with greater than 4GiB input. Compare with 565 * 566 * $ dd if=/dev/zero bs=1048576 count=4097 |sha256sum 567 * 829816e339ff597ec3ada4c30fc840d3f2298444169d242952a54bcf3fcd7747 - 568 */ 569 const size_t kMebibyte = 1048576; 570 uint8_t* megabuf; 571 megabuf = new uint8_t[kMebibyte]; 572 memset((char*)megabuf, '\0', kMebibyte); 573 avb_sha256_init(&ctx); 574 for (size_t n = 0; n < 4097; n++) { 575 avb_sha256_update(&ctx, megabuf, kMebibyte); 576 } 577 EXPECT_EQ("829816e339ff597ec3ada4c30fc840d3f2298444169d242952a54bcf3fcd7747", 578 mem_to_hexstring(avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE)); 579 delete[] megabuf; 580 } 581 582 TEST_F(UtilTest, Sha512) { 583 AvbSHA512Ctx ctx; 584 585 /* Compare with 586 * 587 * $ echo -n foobar |sha512sum 588 * 0a50261ebd1a390fed2bf326f2673c145582a6342d523204973d0219337f81616a8069b012587cf5635f6925f1b56c360230c19b273500ee013e030601bf2425 589 * - 590 */ 591 avb_sha512_init(&ctx); 592 avb_sha512_update(&ctx, (const uint8_t*)"foobar", 6); 593 EXPECT_EQ( 594 "0a50261ebd1a390fed2bf326f2673c145582a6342d523204973d0219337f81616a8069b0" 595 "12587cf5635f6925f1b56c360230c19b273500ee013e030601bf2425", 596 mem_to_hexstring(avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE)); 597 } 598 599 // Disabled for now because it takes ~30 seconds to run. 600 TEST_F(UtilTest, DISABLED_Sha512Large) { 601 AvbSHA512Ctx ctx; 602 603 /* Also check we this works with greater than 4GiB input. Compare with 604 * 605 * $ dd if=/dev/zero bs=1048576 count=4097 |sha512sum 606 * eac1685671cc2060315888746de072398116c0c83b7ee9463f0576e11bfdea9cdd5ddbf291fb3ffc4ee8a1b459c798d9fb9b50b7845e2871c4b1402470aaf4c0 607 * - 608 */ 609 const size_t kMebibyte = 1048576; 610 uint8_t* megabuf; 611 megabuf = new uint8_t[kMebibyte]; 612 memset((char*)megabuf, '\0', kMebibyte); 613 avb_sha512_init(&ctx); 614 for (size_t n = 0; n < 4097; n++) { 615 avb_sha512_update(&ctx, megabuf, kMebibyte); 616 } 617 EXPECT_EQ( 618 "eac1685671cc2060315888746de072398116c0c83b7ee9463f0576e11bfdea9cdd5ddbf2" 619 "91fb3ffc4ee8a1b459c798d9fb9b50b7845e2871c4b1402470aaf4c0", 620 mem_to_hexstring(avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE)); 621 delete[] megabuf; 622 } 623 624 } // namespace avb 625
