Switch to standard integer types in crypto/.

crypto/symmetric_key_win.cc

 // Copyright (c) 2012 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/symmetric_key.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <vector>
 
 // TODO(wtc): replace scoped_array by std::vector.
 #include "base/memory/scoped_ptr.h"
 #include "base/sys_byteorder.h"
 
 namespace crypto {
 
 namespace {
 
@@ skipping 215 matching lines @@
 // Computes a block of the derived key using the PBKDF2 function F for the
 // specified |block_index| using the PRF |hash|, writing the output to
 // |output_buf|.
 // |output_buf| must have enough space to accomodate the output of the PRF
 // specified by |hash|.
 // Returns true if the block was successfully computed.
 bool ComputePBKDF2Block(HCRYPTHASH hash,
                         DWORD hash_size,
                         const std::string& salt,
                         size_t iterations,
-                        uint32 block_index,
+                        uint32_t block_index,
                         BYTE* output_buf) {
   // From RFC 2898:
   // 3. <snip> The function F is defined as the exclusive-or sum of the first
   //    c iterates of the underlying pseudorandom function PRF applied to the
   //    password P and the concatenation of the salt S and the block index i:
   //      F (P, S, c, i) = U_1 \xor U_2 \xor ... \xor U_c
   //    where
   //      U_1 = PRF(P, S || INT (i))
   //      U_2 = PRF(P, U_1)
   //      ...
   //      U_c = PRF(P, U_{c-1})
   ScopedHCRYPTHASH safe_hash;
   BOOL ok = CryptDuplicateHash(hash, NULL, 0, safe_hash.receive());
   if (!ok)
     return false;
 
   // Iteration U_1: Compute PRF for S.
   ok = CryptHashData(safe_hash, reinterpret_cast<const BYTE*>(salt.data()),
                      static_cast<DWORD>(salt.size()), 0);
   if (!ok)
     return false;
 
   // Iteration U_1: and append (big-endian) INT (i).
-  uint32 big_endian_block_index = base::HostToNet32(block_index);
+  uint32_t big_endian_block_index = base::HostToNet32(block_index);
   ok = CryptHashData(safe_hash,
                      reinterpret_cast<BYTE*>(&big_endian_block_index),
                      sizeof(big_endian_block_index), 0);
 
   std::vector<BYTE> hash_value(hash_size);
 
   DWORD size = hash_size;
   ok = CryptGetHashParam(safe_hash, HP_HASHVAL, &hash_value[0], &size, 0);
   if (!ok  || size != hash_size)
     return false;
@@ skipping 156 matching lines @@
   //    to the password P, the salt S, the iteration count c, and the block
   //    index to compute the block:
   //    T_1 = F (P, S, c, 1)
   //    T_2 = F (P, S, c, 2)
   //    ...
   //    T_l = F (P, S, c, l)
   // <snip>
   // 4. Concatenate the blocks and extract the first dkLen octets to produce
   //    a derived key DK:
   //    DK = T_1 || T_2 || ... || T_l<0..r-1>
-  for (uint32 block_index = 1; block_index <= L; ++block_index) {
+  for (uint32_t block_index = 1; block_index <= L; ++block_index) {
     if (!ComputePBKDF2Block(prf, hLen, salt, iterations, block_index,
                             block_offset))
         return NULL;
     block_offset += hLen;
   }
 
   // Convert the derived key bytes into a key handle for the desired algorithm.
   ScopedHCRYPTKEY key;
   if (!ImportRawKey(provider, alg, &generated_key[0], dkLen, &key))
     return NULL;
@@ skipping 73 matching lines @@
                            HCRYPTKEY key,
                            const void* key_data, size_t key_size_in_bytes)
     : provider_(provider), key_(key) {
   if (key_data) {
     raw_key_.assign(reinterpret_cast<const char*>(key_data),
                     key_size_in_bytes);
   }
 }
 
 }  // namespace crypto