Switch to standard integer types in crypto/.

crypto/p224_spake.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.
 
 // This code implements SPAKE2, a variant of EKE:
 //  http://www.di.ens.fr/~pointche/pub.php?reference=AbPo04
 
 #include <crypto/p224_spake.h>
 
 #include <algorithm>
@@ skipping 185 matching lines @@
   if (is_server_) {
     client_masked_dh = message.as_string();
     server_masked_dh = next_message_;
   } else {
     client_masked_dh = next_message_;
     server_masked_dh = message.as_string();
   }
 
   // Now we calculate the hashes that each side will use to prove to the other
   // that they derived the correct value for K.
-  uint8 client_hash[kSHA256Length], server_hash[kSHA256Length];
+  uint8_t client_hash[kSHA256Length], server_hash[kSHA256Length];
   CalculateHash(kPeerTypeClient, client_masked_dh, server_masked_dh, key_,
                 client_hash);
   CalculateHash(kPeerTypeServer, client_masked_dh, server_masked_dh, key_,
                 server_hash);
 
-  const uint8* my_hash = is_server_ ? server_hash : client_hash;
-  const uint8* their_hash = is_server_ ? client_hash : server_hash;
+  const uint8_t* my_hash = is_server_ ? server_hash : client_hash;
+  const uint8_t* their_hash = is_server_ ? client_hash : server_hash;
 
   next_message_ =
       std::string(reinterpret_cast<const char*>(my_hash), kSHA256Length);
   memcpy(expected_authenticator_, their_hash, kSHA256Length);
   state_ = kStateSendHash;
   return kResultPending;
 }
 
 void P224EncryptedKeyExchange::CalculateHash(
     PeerType peer_type,
     const std::string& client_masked_dh,
     const std::string& server_masked_dh,
     const std::string& k,
-    uint8* out_digest) {
+    uint8_t* out_digest) {
   std::string hash_contents;
 
   if (peer_type == kPeerTypeServer) {
     hash_contents = "server";
   } else {
     hash_contents = "client";
   }
 
   hash_contents += client_masked_dh;
   hash_contents += server_masked_dh;
@@ skipping 21 matching lines @@
   return key_;
 }
 
 void P224EncryptedKeyExchange::SetXForTesting(const std::string& x) {
   memset(&x_, 0, sizeof(x_));
   memcpy(&x_, x.data(), std::min(x.size(), sizeof(x_)));
   Init();
 }
 
 }  // namespace crypto