1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// 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/encryptor.h"
#include <string.h>
#include "base/string_util.h"
#include "crypto/symmetric_key.h"
namespace crypto {
namespace {
// On success, returns the block size (in bytes) for the algorithm that |key|
// is for. On failure, returns 0.
DWORD GetCipherBlockSize(HCRYPTKEY key) {
DWORD block_size_in_bits = 0;
DWORD param_size = sizeof(block_size_in_bits);
BOOL ok = CryptGetKeyParam(key, KP_BLOCKLEN,
reinterpret_cast<BYTE*>(&block_size_in_bits),
¶m_size, 0);
if (!ok)
return 0;
return block_size_in_bits / 8;
}
} // namespace
Encryptor::Encryptor()
: key_(NULL),
mode_(CBC),
block_size_(0) {
}
Encryptor::~Encryptor() {
}
bool Encryptor::Init(SymmetricKey* key,
Mode mode,
const base::StringPiece& iv) {
DCHECK(key);
DCHECK_EQ(CBC, mode) << "Unsupported mode of operation";
// In CryptoAPI, the IV, padding mode, and feedback register (for a chaining
// mode) are properties of a key, so we have to create a copy of the key for
// the Encryptor. See the Remarks section of the CryptEncrypt MSDN page.
BOOL ok = CryptDuplicateKey(key->key(), NULL, 0, capi_key_.receive());
if (!ok)
return false;
// CRYPT_MODE_CBC is the default for Microsoft Base Cryptographic Provider,
// but we set it anyway to be safe.
DWORD cipher_mode = CRYPT_MODE_CBC;
ok = CryptSetKeyParam(capi_key_.get(), KP_MODE,
reinterpret_cast<BYTE*>(&cipher_mode), 0);
if (!ok)
return false;
block_size_ = GetCipherBlockSize(capi_key_.get());
if (block_size_ == 0)
return false;
if (iv.size() != block_size_)
return false;
ok = CryptSetKeyParam(capi_key_.get(), KP_IV,
reinterpret_cast<const BYTE*>(iv.data()), 0);
if (!ok)
return false;
DWORD padding_method = PKCS5_PADDING;
ok = CryptSetKeyParam(capi_key_.get(), KP_PADDING,
reinterpret_cast<BYTE*>(&padding_method), 0);
if (!ok)
return false;
return true;
}
bool Encryptor::Encrypt(const base::StringPiece& plaintext,
std::string* ciphertext) {
DWORD data_len = plaintext.size();
CHECK((data_len > 0u) || (mode_ == CBC));
DWORD total_len = data_len + block_size_;
CHECK_GT(total_len, 0u);
CHECK_GT(total_len + 1, data_len);
// CryptoAPI encrypts/decrypts in place.
char* ciphertext_data = WriteInto(ciphertext, total_len + 1);
memcpy(ciphertext_data, plaintext.data(), data_len);
BOOL ok = CryptEncrypt(capi_key_.get(), NULL, TRUE, 0,
reinterpret_cast<BYTE*>(ciphertext_data), &data_len,
total_len);
if (!ok) {
ciphertext->clear();
return false;
}
ciphertext->resize(data_len);
return true;
}
bool Encryptor::Decrypt(const base::StringPiece& ciphertext,
std::string* plaintext) {
DWORD data_len = ciphertext.size();
CHECK_GT(data_len, 0u);
CHECK_GT(data_len + 1, data_len);
// CryptoAPI encrypts/decrypts in place.
char* plaintext_data = WriteInto(plaintext, data_len + 1);
memcpy(plaintext_data, ciphertext.data(), data_len);
BOOL ok = CryptDecrypt(capi_key_.get(), NULL, TRUE, 0,
reinterpret_cast<BYTE*>(plaintext_data), &data_len);
if (!ok) {
plaintext->clear();
return false;
}
plaintext->resize(data_len);
return true;
}
} // namespace crypto
|
