Implement PBKDF2-based key derivation, random key generation,...

base/crypto/rsa_private_key_win.cc

 // Copyright (c) 2009 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 "base/crypto/rsa_private_key.h"
 
 #include <iostream>
 #include <list>
 
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 // static
 RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) {
   scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey);
   if (!result->InitProvider())
     return NULL;
 
   DWORD flags = CRYPT_EXPORTABLE;
 
   // The size is encoded as the upper 16 bits of the flags. :: sigh ::.
   flags |= (num_bits << 16);
-  if (!CryptGenKey(result->provider_, CALG_RSA_SIGN, flags, &result->key_))
+  if (!CryptGenKey(result->provider_, CALG_RSA_SIGN, flags,
+                   result->key_.receive()))
     return NULL;
 
   return result.release();
 }
 
 // static
 RSAPrivateKey* RSAPrivateKey::CreateFromPrivateKeyInfo(
     const std::vector<uint8>& input) {
   scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey);
   if (!result->InitProvider())
@@ skipping 42 matching lines @@
   dest += pki.exponent1()->size();
   memcpy(dest, &pki.exponent2()->front(), pki.exponent2()->size());
   dest += pki.exponent2()->size();
   memcpy(dest, &pki.coefficient()->front(), pki.coefficient()->size());
   dest += pki.coefficient()->size();
   memcpy(dest, &pki.private_exponent()->front(), pki.private_exponent()->size());
   dest += pki.private_exponent()->size();
 
   READ_ASSERT(dest == blob.get() + blob_size);
   if (!CryptImportKey(
-      result->provider_, reinterpret_cast<uint8*>(public_key_struc), blob_size,
-      NULL, CRYPT_EXPORTABLE, &result->key_)) {
+      result->provider_, reinterpret_cast<uint8*>(public_key_struc),
+      blob_size, NULL, CRYPT_EXPORTABLE, result->key_.receive())) {
     return NULL;
   }
 
   return result.release();
 }
 
 RSAPrivateKey::RSAPrivateKey() : provider_(NULL), key_(NULL) {}
 
-RSAPrivateKey::~RSAPrivateKey() {
-  if (key_) {
-    if (!CryptDestroyKey(key_))
-      NOTREACHED();
-  }
-
-  if (provider_) {
-    if (!CryptReleaseContext(provider_, 0))
-      NOTREACHED();
-  }
-}
+RSAPrivateKey::~RSAPrivateKey() {}
 
 bool RSAPrivateKey::InitProvider() {
-  return FALSE != CryptAcquireContext(&provider_, NULL, NULL,
+  return FALSE != CryptAcquireContext(provider_.receive(), NULL, NULL,
                                       PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 }
 
 bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8>* output) {
   // Export the key
   DWORD blob_length = 0;
   if (!CryptExportKey(key_, NULL, PRIVATEKEYBLOB, 0, NULL, &blob_length)) {
     NOTREACHED();
     return false;
   }
@@ skipping 79 matching lines @@
     return false;
   }
 
   for (size_t i = 0; i < encoded_length; ++i)
     output->push_back(encoded[i]);
 
   return true;
 }
 
 }  // namespace base