Added crypto random-number generator

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 "crypto/random.h"
 #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 647 matching lines @@
   // |passphrase|, sets |out_key| to it and returns a Symmetric Key Encrypted
   // packet. See RFC 4880, section 5.3.
   static ByteString SerializeSymmetricKeyEncrypted(base::StringPiece passphrase,
                                                    ByteString *out_key) {
     ByteString ske;
     ske.push_back(4);  // version 4
     ske.push_back(7);  // AES-128
     ske.push_back(3);  // iterated and salted S2K
     ske.push_back(2);  // SHA-1
 
-    uint64 salt64 = base::RandUint64();
+    uint64 salt64;
+    crypto::RandBytes(&salt64, sizeof(salt64));
     ByteString salt(sizeof(salt64), 0);
 
     // It's a random value, so endianness doesn't matter.
     ske += ByteString(reinterpret_cast<uint8*>(&salt64), sizeof(salt64));
     ske.push_back(96);  // iteration count of 65536
 
     uint8 key[16];
     SaltedIteratedS2K(
         sizeof(key), HASH_AlgSHA1, passphrase,
         base::StringPiece(reinterpret_cast<char*>(&salt64), sizeof(salt64)),
         65536, key);
     *out_key = ByteString(key, sizeof(key));
     return MakePacket(kSymmetricKeyEncryptedTag, ske);
   }
 
   // SerializeSymmetricallyEncrypted encrypts |plaintext| with |key| and
   // returns a Symmetrically Encrypted packet containing the ciphertext. See
   // RFC 4880, section 5.7.
   static ByteString SerializeSymmetricallyEncrypted(ByteString plaintext,
                                                     const ByteString& key) {
     // We need this for PK11_CipherOp to write to, but we never check it as we
     // work in ECB mode, one block at a time.
     int out_len;
 
     ByteString packet;
     packet.push_back(1);  // version 1
     static const unsigned kBlockSize = 16;  // AES block size
 
     uint8 prefix[kBlockSize + 2], fre[kBlockSize], iv[kBlockSize];
-    base::RandBytes(iv, kBlockSize);
+    crypto::RandBytes(iv, kBlockSize);
     memset(fre, 0, sizeof(fre));
 
     ScopedPK11Context aes_context;
     CHECK(CreateAESContext(key.data(), key.size(), &aes_context));
 
     PK11_CipherOp(aes_context.get(), fre, &out_len, sizeof(fre), fre,
                   AES_BLOCK_SIZE);
     for (unsigned i = 0; i < 16; i++)
       prefix[i] = iv[i] ^ fre[i];
     PK11_CipherOp(aes_context.get(), fre, &out_len, sizeof(fre), prefix,
@@ skipping 61 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