Move crypto files out of base, to a top level directory.

net/http/des.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "net/http/des.h"
 
 #include "base/logging.h"
 
 #if defined(USE_OPENSSL)
 #include <openssl/des.h>
-#include "base/openssl_util.h"
+#include "crypto/openssl_util.h"
 #elif defined(USE_NSS)
 #include <nss.h>
 #include <pk11pub.h>
-#include "base/nss_util.h"
+#include "crypto/nss_util.h"
 #elif defined(OS_MACOSX)
 #include <CommonCrypto/CommonCryptor.h>
 #elif defined(OS_WIN)
 #include <windows.h>
 #include <wincrypt.h>
-#include "base/crypto/scoped_capi_types.h"
+#include "crypto/scoped_capi_types.h"
 #endif
 
 // The Mac and Windows (CryptoAPI) versions of DESEncrypt are our own code.
 // DESSetKeyParity, DESMakeKey, and the Linux (NSS) version of DESEncrypt are
 // based on mozilla/security/manager/ssl/src/nsNTLMAuthModule.cpp,
 // CVS rev. 1.14.
 
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 51 matching lines @@
   key[3] = DESSetKeyParity((raw[2] << 5) | (raw[3] >> 3));
   key[4] = DESSetKeyParity((raw[3] << 4) | (raw[4] >> 4));
   key[5] = DESSetKeyParity((raw[4] << 3) | (raw[5] >> 5));
   key[6] = DESSetKeyParity((raw[5] << 2) | (raw[6] >> 6));
   key[7] = DESSetKeyParity((raw[6] << 1));
 }
 
 #if defined(USE_OPENSSL)
 
 void DESEncrypt(const uint8* key, const uint8* src, uint8* hash) {
-  base::EnsureOpenSSLInit();
+  crypto::EnsureOpenSSLInit();
 
   DES_key_schedule ks;
   DES_set_key_unchecked(
       reinterpret_cast<const_DES_cblock*>(const_cast<uint8*>(key)), &ks);
 
   DES_ecb_encrypt(reinterpret_cast<const_DES_cblock*>(const_cast<uint8*>(src)),
                   reinterpret_cast<DES_cblock*>(hash), &ks, DES_ENCRYPT);
 }
 
 #elif defined(USE_NSS)
 
 void DESEncrypt(const uint8* key, const uint8* src, uint8* hash) {
   CK_MECHANISM_TYPE cipher_mech = CKM_DES_ECB;
   PK11SlotInfo* slot = NULL;
   PK11SymKey* symkey = NULL;
   PK11Context* ctxt = NULL;
   SECItem key_item;
   SECItem* param = NULL;
   SECStatus rv;
   unsigned int n;
 
-  base::EnsureNSSInit();
+  crypto::EnsureNSSInit();
 
   slot = PK11_GetBestSlot(cipher_mech, NULL);
   if (!slot)
     goto done;
 
   key_item.data = const_cast<uint8*>(key);
   key_item.len = 8;
   symkey = PK11_ImportSymKey(slot, cipher_mech,
                              PK11_OriginUnwrap, CKA_ENCRYPT,
                              &key_item, NULL);
@@ skipping 38 matching lines @@
   size_t data_out_moved = 0;
   status = CCCrypt(kCCEncrypt, kCCAlgorithmDES, kCCOptionECBMode,
                    key, 8, NULL, src, 8, hash, 8, &data_out_moved);
   DCHECK(status == kCCSuccess);
   DCHECK(data_out_moved == 8);
 }
 
 #elif defined(OS_WIN)
 
 void DESEncrypt(const uint8* key, const uint8* src, uint8* hash) {
-  base::ScopedHCRYPTPROV provider;
+  crypto::ScopedHCRYPTPROV provider;
   if (!CryptAcquireContext(provider.receive(), NULL, NULL, PROV_RSA_FULL,
                            CRYPT_VERIFYCONTEXT))
     return;
 
   {
     // Import the DES key.
     struct KeyBlob {
       BLOBHEADER header;
       DWORD key_size;
       BYTE key_data[8];
     };
     KeyBlob key_blob;
     key_blob.header.bType = PLAINTEXTKEYBLOB;
     key_blob.header.bVersion = CUR_BLOB_VERSION;
     key_blob.header.reserved = 0;
     key_blob.header.aiKeyAlg = CALG_DES;
     key_blob.key_size = 8;  // 64 bits
     memcpy(key_blob.key_data, key, 8);
 
-    base::ScopedHCRYPTKEY key;
+    crypto::ScopedHCRYPTKEY key;
     BOOL import_ok = CryptImportKey(provider,
                                     reinterpret_cast<BYTE*>(&key_blob),
                                     sizeof key_blob, 0, 0, key.receive());
     // Destroy the copy of the key.
     SecureZeroMemory(key_blob.key_data, sizeof key_blob.key_data);
     if (!import_ok)
       return;
 
     // No initialization vector required.
     DWORD cipher_mode = CRYPT_MODE_ECB;
     if (!CryptSetKeyParam(key, KP_MODE, reinterpret_cast<BYTE*>(&cipher_mode),
                           0))
       return;
 
     // CryptoAPI requires us to copy the plaintext to the output buffer first.
     CopyMemory(hash, src, 8);
     // Pass a 'Final' of FALSE, otherwise CryptEncrypt appends one additional
     // block of padding to the data.
     DWORD hash_len = 8;
     CryptEncrypt(key, 0, FALSE, 0, hash, &hash_len, 8);
   }
 }
 
 #endif
 
 }  // namespace net