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) {
-  static const unsigned int total_blocks = 16384;
+  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' };
 
-  // TODO(wad) add tests for partial tree validity/verification
-
-  // Corrupt one block value
-  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, digest, digest_size),
-            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);
-
-  // Verify that the prior entry is untouched and still safe
-  EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock - 1, digest, digest_size),
-            0);
-
-  // Same for the next entry
-  EXPECT_EQ(dm_bht_verify_block(bht_.get(), kBadBlock + bht_->node_count,
-                                digest, digest_size),
-            0);
+  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);

[Will Drewry, 2011/03/16 16:53:37]

This test no longer matches the initial test functionality.  The old one put one
bad page in the blocks, then called verifies around it to trigger failures in
intermediate nodes too.

It's be nice to either add something here or add a second unittest so we don't
lose those tests.  They caught bugs in the past! :)

+  EXPECT_LT(dm_bht_verify_block(bht_.get(), 383, kBadPage), 0);
 
   EXPECT_EQ(0, dm_bht_destroy(bht_.get()));
 }