verity: do all hashing in dm-bht.c

dm-bht_unittest.cc

 // Copyright (C) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by the GPL v2 license that can
 // be found in the LICENSE file.
 //
 // Basic unittesting of dm-bht using google-gtest.
 
 #include <base/basictypes.h>
 #include <base/logging.h>
 #include <base/scoped_ptr.h>
 #include <gtest/gtest.h>
@@ skipping 89 matching lines @@
       hash_data_.reset(new u8[to_bytes(sectors_)]);
     }
     dm_bht_set_write_cb(bht_.get(), MemoryBhtTest::WriteCallback);
     dm_bht_set_read_cb(bht_.get(), MemoryBhtTest::ReadCallback);
   }
   void SetupBht(const unsigned int depth,
                 const unsigned int total_blocks,
                 const char *digest_algorithm) {
     NewBht(depth, total_blocks, digest_algorithm);
 
-    u8 data[PAGE_SIZE];
-    // Store all the block hashes of blocks of 0.
-    memset(reinterpret_cast<void *>(data), 0, sizeof(data));
+    u8 data[PAGE_SIZE] = { 0 };
     unsigned int blocks = total_blocks;
     do {
       EXPECT_EQ(dm_bht_store_block(bht_.get(), blocks - 1, data), 0);
     } while (--blocks > 0);
 
     dm_bht_set_read_cb(bht_.get(), dm_bht_zeroread_callback);
     EXPECT_EQ(0, dm_bht_compute(bht_.get(), NULL));
     EXPECT_EQ(0, dm_bht_sync(bht_.get(), reinterpret_cast<void *>(this)));
     u8 digest[1024];
     dm_bht_root_hexdigest(bht_.get(), digest, sizeof(digest));
@@ skipping 21 matching lines @@
   scoped_ptr<struct dm_bht> bht_;
   scoped_array<u8> hash_data_;
   sector_t sectors_;
 };
 
 TEST_F(MemoryBhtTest, CreateThenVerifyOk) {
   static const unsigned int total_blocks = 16384;
   // Set the root hash for a 0-filled image
   static const char kRootDigest[] =
     "45d65d6f9e5a962f4d80b5f1bd7a918152251c27bdad8c5f52b590c129833372";
-  // This should match what dm_bht_store_block computed earlier.
-  static const char kZeroDigest[] =
-    "ad7facb2586fc6e966c004d7d1d16b024f5805ff7cb47c7a85dabd8b48892ca7";
-  u8 digest[(sizeof(kZeroDigest) - 1) >> 1];
-  // TODO(wad) write a test for hex_to_bin and bin_to_hex
-  unsigned int digest_size = strlen(kZeroDigest) >> 1;
-
-  dm_bht_hex_to_bin(digest,
-                    reinterpret_cast<const u8 *>(kZeroDigest),
-                    digest_size);
+  // A page of all zeros
+  static const char kZeroPage[PAGE_SIZE] = { 0 };
 
   SetupBht(2, total_blocks, "sha256");
   dm_bht_set_root_hexdigest(bht_.get(),
                             reinterpret_cast<const u8 *>(kRootDigest));
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks, digest, digest_size));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks, kZeroPage));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
 }
 
 TEST_F(MemoryBhtTest, CreateThenVerifyMultipleLevels) {
   static const unsigned int total_blocks = 16384;
   // Set the root hash for a 0-filled image
   static const char kRootDigest[] =
     "c86619624d3456f711dbb94d4ad79a4b029f6fd3b5a4a90b155c856bf5b3409b";
-  // This should match what dm_bht_store_block computed earlier.
-  static const char kZeroDigest[] =
-    "ad7facb2586fc6e966c004d7d1d16b024f5805ff7cb47c7a85dabd8b48892ca7";
-  u8 digest[(sizeof(kZeroDigest) - 1) >> 1];
-  // TODO(wad) write a test for hex_to_bin and bin_to_hex
-  unsigned int digest_size = strlen(kZeroDigest) >> 1;
-
-  dm_bht_hex_to_bin(digest,
-                    reinterpret_cast<const u8 *>(kZeroDigest),
-                    digest_size);
+  // A page of all zeros
+  static const char kZeroPage[PAGE_SIZE] = { 0 };
 
   SetupBht(4, total_blocks, "sha256");
   dm_bht_set_root_hexdigest(bht_.get(),
                             reinterpret_cast<const u8 *>(kRootDigest));
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks, digest, digest_size));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks, kZeroPage));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
 }
 
 TEST_F(MemoryBhtTest, CreateThenVerifyOddCount) {
   static const unsigned int total_blocks = 16383;
   // Set the root hash for a 0-filled image
   static const char kRootDigest[] =
     "c78d187c430465bd7831fe4908247b6ab5107e3a826d933b71e85aa9a932e03c";
-  // This should match what dm_bht_store_block computed earlier.
-  static const char kZeroDigest[] =
-    "ad7facb2586fc6e966c004d7d1d16b024f5805ff7cb47c7a85dabd8b48892ca7";
-  u8 digest[(sizeof(kZeroDigest) - 1) >> 1];
-  // TODO(wad) write a test for hex_to_bin and bin_to_hex
-  unsigned int digest_size = strlen(kZeroDigest) >> 1;
-
-  dm_bht_hex_to_bin(digest,
-                    reinterpret_cast<const u8 *>(kZeroDigest),
-                    digest_size);
+  // A page of all zeros
+  static const char kZeroPage[PAGE_SIZE] = { 0 };
 
   SetupBht(4, total_blocks, "sha256");
   dm_bht_set_root_hexdigest(bht_.get(),
                             reinterpret_cast<const u8 *>(kRootDigest));
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks, digest, digest_size));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_.get(), blocks, kZeroPage));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
 }
 
-TEST_F(MemoryBhtTest, CreateThenVerifyBad) {
+TEST_F(MemoryBhtTest, CreateThenVerifyBadHashBlock) {
   static const unsigned int total_blocks = 16384;
   SetupBht(2, total_blocks, "sha256");
+  // A page of all zeros
+  static const char kZeroPage[PAGE_SIZE] = { 0 };
   // Set the root hash for a 0-filled image
   static const char kRootDigest[] =
     "45d65d6f9e5a962f4d80b5f1bd7a918152251c27bdad8c5f52b590c129833372";
   dm_bht_set_root_hexdigest(bht_.get(),
                             reinterpret_cast<const u8 *>(kRootDigest));
 
   // TODO(wad) add tests for partial tree validity/verification
 
-  // Corrupt one block value
+  // Corrupt one has hblock
   static const unsigned int kBadBlock = 256;
   u8 data[PAGE_SIZE];
   memset(reinterpret_cast<void *>(data), 'A', sizeof(data));
   EXPECT_EQ(dm_bht_store_block(bht_.get(), kBadBlock, data), 0);
 
-  // This should match what dm_bht_store_block computed earlier.
-  static const char kZeroDigest[] =
-    "ad7facb2586fc6e966c004d7d1d16b024f5805ff7cb47c7a85dabd8b48892ca7";
-  u8 digest[(sizeof(kZeroDigest) - 1) >> 1];
-  // TODO(wad) write a test for hex_to_bin and bin_to_hex
-  unsigned int digest_size = strlen(kZeroDigest) >> 1;
-  dm_bht_hex_to_bin(digest,
-                    reinterpret_cast<const u8 *>(kZeroDigest),
-                    digest_size);
+  // Attempt to verify both the bad block and all the neighbors.
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + 1, kZeroPage), 0);
 
-  // Attempt to verify both the bad block and all the neighbors.
-  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + 1, digest, digest_size),
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + 2, kZeroPage), 0);
+
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + (bht_->node_count / 2),
+                                kZeroPage),
             0);
 
-  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + 2, digest, digest_size),
-            0);
-
-  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock + (bht_->node_count / 2),
-                                digest, digest_size),
-            0);
-
-  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock, digest, digest_size), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), kBadBlock, kZeroPage), 0);
 
   // Verify that the prior entry is untouched and still safe
-  EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock - 1, digest, digest_size),
-            0);
+  EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock - 1, kZeroPage), 0);
 
   // Same for the next entry
   EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock + bht_->node_count,
-                                digest, digest_size),
+                                kZeroPage),
             0);
 
   EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
 }
+
+TEST_F(MemoryBhtTest, CreateThenVerifyBadDataBlock) {
+  static const unsigned int total_blocks = 384;
+  SetupBht(2, total_blocks, "sha256");
+  // Set the root hash for a 0-filled image
+  static const char kRootDigest[] =
+    "45d65d6f9e5a962f4d80b5f1bd7a918152251c27bdad8c5f52b590c129833372";
+  dm_bht_set_root_hexdigest(bht_.get(),
+                            reinterpret_cast<const u8 *>(kRootDigest));
+  // A corrupt page
+  static const u8 kBadPage[PAGE_SIZE] = { 'A' };
+
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 0, kBadPage), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 127, kBadPage), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 128, kBadPage), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 255, kBadPage), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 256, kBadPage), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 383, kBadPage), 0);
+
+  EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
+}