d2b5af56cf
This reverts commits:8d79ed674019fdcb52348d79ed6740Because WebRTC (at least) includes our headers in an extern "C" block, which precludes having any C++ in them. Change-Id: Ia849f43795a40034cbd45b22ea680b51aab28b2d
301 lines
9.8 KiB
C++
301 lines
9.8 KiB
C++
/*
|
|
* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
|
|
* project.
|
|
*/
|
|
/* ====================================================================
|
|
* Copyright (c) 2015 The OpenSSL Project. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* 3. All advertising materials mentioning features or use of this
|
|
* software must display the following acknowledgment:
|
|
* "This product includes software developed by the OpenSSL Project
|
|
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|
*
|
|
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
|
* endorse or promote products derived from this software without
|
|
* prior written permission. For written permission, please contact
|
|
* licensing@OpenSSL.org.
|
|
*
|
|
* 5. Products derived from this software may not be called "OpenSSL"
|
|
* nor may "OpenSSL" appear in their names without prior written
|
|
* permission of the OpenSSL Project.
|
|
*
|
|
* 6. Redistributions of any form whatsoever must retain the following
|
|
* acknowledgment:
|
|
* "This product includes software developed by the OpenSSL Project
|
|
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
|
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
|
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
* ====================================================================
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <openssl/cipher.h>
|
|
#include <openssl/crypto.h>
|
|
#include <openssl/err.h>
|
|
|
|
#include "../test/file_test.h"
|
|
#include "../test/scoped_types.h"
|
|
|
|
|
|
namespace bssl {
|
|
|
|
static const EVP_CIPHER *GetCipher(const std::string &name) {
|
|
if (name == "DES-CBC") {
|
|
return EVP_des_cbc();
|
|
} else if (name == "DES-ECB") {
|
|
return EVP_des_ecb();
|
|
} else if (name == "DES-EDE") {
|
|
return EVP_des_ede();
|
|
} else if (name == "DES-EDE-CBC") {
|
|
return EVP_des_ede_cbc();
|
|
} else if (name == "DES-EDE3-CBC") {
|
|
return EVP_des_ede3_cbc();
|
|
} else if (name == "RC4") {
|
|
return EVP_rc4();
|
|
} else if (name == "AES-128-ECB") {
|
|
return EVP_aes_128_ecb();
|
|
} else if (name == "AES-256-ECB") {
|
|
return EVP_aes_256_ecb();
|
|
} else if (name == "AES-128-CBC") {
|
|
return EVP_aes_128_cbc();
|
|
} else if (name == "AES-128-GCM") {
|
|
return EVP_aes_128_gcm();
|
|
} else if (name == "AES-128-OFB") {
|
|
return EVP_aes_128_ofb();
|
|
} else if (name == "AES-192-CBC") {
|
|
return EVP_aes_192_cbc();
|
|
} else if (name == "AES-192-ECB") {
|
|
return EVP_aes_192_ecb();
|
|
} else if (name == "AES-256-CBC") {
|
|
return EVP_aes_256_cbc();
|
|
} else if (name == "AES-128-CTR") {
|
|
return EVP_aes_128_ctr();
|
|
} else if (name == "AES-256-CTR") {
|
|
return EVP_aes_256_ctr();
|
|
} else if (name == "AES-256-GCM") {
|
|
return EVP_aes_256_gcm();
|
|
} else if (name == "AES-256-OFB") {
|
|
return EVP_aes_256_ofb();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static bool TestOperation(FileTest *t,
|
|
const EVP_CIPHER *cipher,
|
|
bool encrypt,
|
|
size_t chunk_size,
|
|
const std::vector<uint8_t> &key,
|
|
const std::vector<uint8_t> &iv,
|
|
const std::vector<uint8_t> &plaintext,
|
|
const std::vector<uint8_t> &ciphertext,
|
|
const std::vector<uint8_t> &aad,
|
|
const std::vector<uint8_t> &tag) {
|
|
const std::vector<uint8_t> *in, *out;
|
|
if (encrypt) {
|
|
in = &plaintext;
|
|
out = &ciphertext;
|
|
} else {
|
|
in = &ciphertext;
|
|
out = &plaintext;
|
|
}
|
|
|
|
bool is_aead = EVP_CIPHER_mode(cipher) == EVP_CIPH_GCM_MODE;
|
|
|
|
ScopedEVP_CIPHER_CTX ctx;
|
|
if (!EVP_CipherInit_ex(ctx.get(), cipher, nullptr, nullptr, nullptr,
|
|
encrypt ? 1 : 0)) {
|
|
return false;
|
|
}
|
|
if (t->HasAttribute("IV")) {
|
|
if (is_aead) {
|
|
if (!EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_IVLEN,
|
|
iv.size(), 0)) {
|
|
return false;
|
|
}
|
|
} else if (iv.size() != EVP_CIPHER_CTX_iv_length(ctx.get())) {
|
|
t->PrintLine("Bad IV length.");
|
|
return false;
|
|
}
|
|
}
|
|
if (is_aead && !encrypt &&
|
|
!EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_TAG, tag.size(),
|
|
const_cast<uint8_t*>(tag.data()))) {
|
|
return false;
|
|
}
|
|
// The ciphers are run with no padding. For each of the ciphers we test, the
|
|
// output size matches the input size.
|
|
std::vector<uint8_t> result(in->size());
|
|
if (in->size() != out->size()) {
|
|
t->PrintLine("Input/output size mismatch (%u vs %u).", (unsigned)in->size(),
|
|
(unsigned)out->size());
|
|
return false;
|
|
}
|
|
// Note: the deprecated |EVP_CIPHER|-based AES-GCM API is sensitive to whether
|
|
// parameters are NULL, so it is important to skip the |in| and |aad|
|
|
// |EVP_CipherUpdate| calls when empty.
|
|
int unused, result_len1 = 0, result_len2;
|
|
if (!EVP_CIPHER_CTX_set_key_length(ctx.get(), key.size()) ||
|
|
!EVP_CipherInit_ex(ctx.get(), nullptr, nullptr, key.data(), iv.data(),
|
|
-1) ||
|
|
(!aad.empty() &&
|
|
!EVP_CipherUpdate(ctx.get(), nullptr, &unused, aad.data(),
|
|
aad.size())) ||
|
|
!EVP_CIPHER_CTX_set_padding(ctx.get(), 0)) {
|
|
t->PrintLine("Operation failed.");
|
|
return false;
|
|
}
|
|
if (chunk_size != 0) {
|
|
for (size_t i = 0; i < in->size();) {
|
|
size_t todo = chunk_size;
|
|
if (i + todo > in->size()) {
|
|
todo = in->size() - i;
|
|
}
|
|
|
|
int len;
|
|
if (!EVP_CipherUpdate(ctx.get(), result.data() + result_len1, &len,
|
|
in->data() + i, todo)) {
|
|
t->PrintLine("Operation failed.");
|
|
return false;
|
|
}
|
|
result_len1 += len;
|
|
i += todo;
|
|
}
|
|
} else if (!in->empty() &&
|
|
!EVP_CipherUpdate(ctx.get(), result.data(), &result_len1,
|
|
in->data(), in->size())) {
|
|
t->PrintLine("Operation failed.");
|
|
return false;
|
|
}
|
|
if (!EVP_CipherFinal_ex(ctx.get(), result.data() + result_len1,
|
|
&result_len2)) {
|
|
t->PrintLine("Operation failed.");
|
|
return false;
|
|
}
|
|
result.resize(result_len1 + result_len2);
|
|
if (!t->ExpectBytesEqual(out->data(), out->size(), result.data(),
|
|
result.size())) {
|
|
return false;
|
|
}
|
|
if (encrypt && is_aead) {
|
|
uint8_t rtag[16];
|
|
if (tag.size() > sizeof(rtag)) {
|
|
t->PrintLine("Bad tag length.");
|
|
return false;
|
|
}
|
|
if (!EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_GET_TAG, tag.size(),
|
|
rtag) ||
|
|
!t->ExpectBytesEqual(tag.data(), tag.size(), rtag,
|
|
tag.size())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool TestCipher(FileTest *t, void *arg) {
|
|
std::string cipher_str;
|
|
if (!t->GetAttribute(&cipher_str, "Cipher")) {
|
|
return false;
|
|
}
|
|
const EVP_CIPHER *cipher = GetCipher(cipher_str);
|
|
if (cipher == nullptr) {
|
|
t->PrintLine("Unknown cipher: '%s'.", cipher_str.c_str());
|
|
return false;
|
|
}
|
|
|
|
std::vector<uint8_t> key, iv, plaintext, ciphertext, aad, tag;
|
|
if (!t->GetBytes(&key, "Key") ||
|
|
!t->GetBytes(&plaintext, "Plaintext") ||
|
|
!t->GetBytes(&ciphertext, "Ciphertext")) {
|
|
return false;
|
|
}
|
|
if (EVP_CIPHER_iv_length(cipher) > 0 &&
|
|
!t->GetBytes(&iv, "IV")) {
|
|
return false;
|
|
}
|
|
if (EVP_CIPHER_mode(cipher) == EVP_CIPH_GCM_MODE) {
|
|
if (!t->GetBytes(&aad, "AAD") ||
|
|
!t->GetBytes(&tag, "Tag")) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
enum {
|
|
kEncrypt,
|
|
kDecrypt,
|
|
kBoth,
|
|
} operation = kBoth;
|
|
if (t->HasAttribute("Operation")) {
|
|
const std::string &str = t->GetAttributeOrDie("Operation");
|
|
if (str == "ENCRYPT") {
|
|
operation = kEncrypt;
|
|
} else if (str == "DECRYPT") {
|
|
operation = kDecrypt;
|
|
} else {
|
|
t->PrintLine("Unknown operation: '%s'.", str.c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const std::vector<size_t> chunk_sizes = {0, 1, 2, 5, 7, 8, 9, 15, 16,
|
|
17, 31, 32, 33, 63, 64, 65, 512};
|
|
|
|
for (size_t chunk_size : chunk_sizes) {
|
|
// By default, both directions are run, unless overridden by the operation.
|
|
if (operation != kDecrypt &&
|
|
!TestOperation(t, cipher, true /* encrypt */, chunk_size, key, iv,
|
|
plaintext, ciphertext, aad, tag)) {
|
|
return false;
|
|
}
|
|
|
|
if (operation != kEncrypt &&
|
|
!TestOperation(t, cipher, false /* decrypt */, chunk_size, key, iv,
|
|
plaintext, ciphertext, aad, tag)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace bssl
|
|
|
|
int main(int argc, char **argv) {
|
|
CRYPTO_library_init();
|
|
|
|
if (argc != 2) {
|
|
fprintf(stderr, "%s <test file>\n", argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
return bssl::FileTestMain(bssl::TestCipher, nullptr, argv[1]);
|
|
}
|