Update SHA1_LENGTH -> kSHA1Length to match previous change to SHA256_LENGTH.

crypto/openpgp_symmetric_encryption.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "crypto/openpgp_symmetric_encryption.h"
 
 #include <stdlib.h>
 
 #include <sechash.h>
 #include <cryptohi.h>
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
+#include "base/sha1.h"

[wtc, 2011/09/24 01:39:41]

BUG: please undo the changes in this file.  This file uses
NSS even though that's not obvious from the file name.

 #include "crypto/scoped_nss_types.h"
 #include "crypto/nss_util.h"
 
 namespace crypto {
 
 namespace {
 
 // Reader wraps a StringPiece and provides methods to read several datatypes
 // while advancing the StringPiece.
 class Reader {
@@ skipping 510 matching lines @@
         prefix_copy[AES_BLOCK_SIZE - 1] != prefix_copy[AES_BLOCK_SIZE + 1]) {
       return false;
     }
 
     fre[0] = prefix[AES_BLOCK_SIZE];
     fre[1] = prefix[AES_BLOCK_SIZE + 1];
 
     unsigned out_used = 2;
 
     const size_t plaintext_size = reader->size();
-    if (plaintext_size < SHA1_LENGTH + 2) {
+    if (plaintext_size < kSHA1Length + 2) {
       // Too small to contain an MDC trailer.
       return false;
     }
 
     uint8* plaintext = reinterpret_cast<uint8*>(malloc(plaintext_size));
     arena_.push_back(plaintext);
 
     for (size_t i = 0; i < plaintext_size; i++) {
       uint8 b;
       if (!reader->U8(&b))
         return false;
       if (out_used == AES_BLOCK_SIZE) {
         PK11_CipherOp(decryption_context->get(), fre, &out_len, sizeof(fre),
                       fre, AES_BLOCK_SIZE);
         out_used = 0;
       }
 
       plaintext[i] = b ^ fre[out_used];
       fre[out_used++] = b;
     }
 
     // The plaintext should be followed by a Modification Detection Code
     // packet. This packet is specified such that the header is always
     // serialized as exactly these two bytes:
-    if (plaintext[plaintext_size - SHA1_LENGTH - 2] != 0xd3 ||
-        plaintext[plaintext_size - SHA1_LENGTH - 1] != 0x14) {
+    if (plaintext[plaintext_size - kSHA1Length - 2] != 0xd3 ||
+        plaintext[plaintext_size - kSHA1Length - 1] != 0x14) {
       return false;
     }
 
     HASHContext* hash_context = HASH_Create(HASH_AlgSHA1);
     HASH_Begin(hash_context);
     HASH_Update(hash_context, prefix_copy, sizeof(prefix_copy));
-    HASH_Update(hash_context, plaintext, plaintext_size - SHA1_LENGTH);
-    uint8 digest[SHA1_LENGTH];
+    HASH_Update(hash_context, plaintext, plaintext_size - kSHA1Length);
+    uint8 digest[kSHA1Length];
     unsigned num_hash_bytes;
     HASH_End(hash_context, digest, &num_hash_bytes, sizeof(digest));
     HASH_Destroy(hash_context);
 
-    if (memcmp(digest, &plaintext[plaintext_size - SHA1_LENGTH],
-               SHA1_LENGTH) != 0) {
+    if (memcmp(digest, &plaintext[plaintext_size - kSHA1Length],
+               kSHA1Length) != 0) {
       return false;
     }
 
     *out_plaintext = base::StringPiece(reinterpret_cast<char*>(plaintext),
-                                       plaintext_size - SHA1_LENGTH);
+                                       plaintext_size - kSHA1Length);
     return true;
   }
 
   // ParseLiteralData parses a Literal Data packet. See RFC 4880, section 5.9.
   bool ParseLiteralData(Reader *reader, base::StringPiece *out_data) {
     uint8 is_binary, filename_len;
     if (!reader->U8(&is_binary) ||
         !reader->U8(&filename_len) ||
         !reader->Skip(filename_len) ||
         !reader->Skip(sizeof(uint32) /* mtime */)) {
@@ skipping 127 matching lines @@
 
     ByteString plaintext_copy = plaintext;
     plaintext_copy.push_back(0xd3);  // MDC packet
     plaintext_copy.push_back(20);  // packet length (20 bytes)
 
     HASHContext* hash_context = HASH_Create(HASH_AlgSHA1);
     HASH_Begin(hash_context);
     HASH_Update(hash_context, iv, sizeof(iv));
     HASH_Update(hash_context, iv + kBlockSize - 2, 2);
     HASH_Update(hash_context, plaintext_copy.data(), plaintext_copy.size());
-    uint8 digest[SHA1_LENGTH];
+    uint8 digest[kSHA1Length];
     unsigned num_hash_bytes;
     HASH_End(hash_context, digest, &num_hash_bytes, sizeof(digest));
     HASH_Destroy(hash_context);
 
     plaintext_copy += ByteString(digest, sizeof(digest));
 
     fre[0] = prefix[kBlockSize];
     fre[1] = prefix[kBlockSize+1];
     unsigned out_used = 2;
 
@@ skipping 35 matching lines @@
     base::StringPiece plaintext,
     base::StringPiece passphrase) {
   EnsureNSSInit();
 
   Encrypter::ByteString b =
       Encrypter::Encrypt(plaintext, passphrase);
   return std::string(reinterpret_cast<const char*>(b.data()), b.size());
 }
 
 }  // namespace crypto