|
|
@@ -8,37 +8,11 @@ |
|
|
|
#include <openssl/rand.h> |
|
|
|
#include <assert.h> |
|
|
|
|
|
|
|
struct SyncOperations |
|
|
|
{ |
|
|
|
int (*init)( EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, |
|
|
|
const unsigned char *key, const unsigned char *iv); |
|
|
|
int (*update)(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, |
|
|
|
const unsigned char *in, int inl); |
|
|
|
int (*final)(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); |
|
|
|
}; |
|
|
|
|
|
|
|
struct SyncOperations EncryptOps = { |
|
|
|
.init = EVP_EncryptInit, |
|
|
|
.update = EVP_EncryptUpdate, |
|
|
|
.final = EVP_EncryptFinal |
|
|
|
}; |
|
|
|
|
|
|
|
struct SyncOperations DecryptOps = { |
|
|
|
.init = EVP_DecryptInit, |
|
|
|
.update = EVP_DecryptUpdate, |
|
|
|
.final = EVP_DecryptFinal |
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
struct OpenSSL |
|
|
|
{ |
|
|
|
static uint8_t Cbc(CryptoAttribs_t* i_attribs, |
|
|
|
const Key_t* i_key) |
|
|
|
static Result_t Cbc(CryptoAttribs_t* i_attribs, |
|
|
|
const Key_t* const i_key) |
|
|
|
{ |
|
|
|
struct SyncOperations sop = EncryptOps; |
|
|
|
if(i_attribs->operation == kDecrypt) |
|
|
|
sop = DecryptOps; |
|
|
|
|
|
|
|
if(NULL==i_attribs->output) |
|
|
|
{ |
|
|
|
i_attribs->output = (uint8_t*) malloc(i_attribs->input_len); |
|
|
@@ -47,16 +21,24 @@ struct OpenSSL |
|
|
|
int ret=0; |
|
|
|
EVP_CIPHER_CTX ctx; |
|
|
|
EVP_CIPHER_CTX_init(&ctx); |
|
|
|
sop.init(&ctx, EVP_aes_128_cbc(), i_key->key, i_attribs->iv); |
|
|
|
OP_CHECK( |
|
|
|
EVP_CipherInit_ex(&ctx, EVP_aes_128_cbc(), NULL, i_key->key, i_attribs->iv, |
|
|
|
i_attribs->operation==kEncrypt ? 1 : 0)); |
|
|
|
EVP_CIPHER_CTX_set_padding(&ctx, 0); |
|
|
|
EVP_CIPHER_CTX_set_key_length(&ctx, i_key->len); |
|
|
|
|
|
|
|
sop.update(&ctx, i_attribs->output, &ret, i_attribs->input, |
|
|
|
i_attribs->input_len); |
|
|
|
OP_CHECK( |
|
|
|
EVP_CipherUpdate(&ctx, &i_attribs->output[ret], &ret, i_attribs->input, |
|
|
|
i_attribs->input_len)); |
|
|
|
i_attribs->output_len = ret; |
|
|
|
sop.final (&ctx, (i_attribs->output)+ret, &ret); |
|
|
|
OP_CHECK( |
|
|
|
EVP_CipherFinal_ex(&ctx, &i_attribs->output[ret], &ret)); |
|
|
|
i_attribs->output_len += ret; |
|
|
|
return 1; |
|
|
|
EVP_CIPHER_CTX_cleanup(&ctx); |
|
|
|
return Result_OK; |
|
|
|
|
|
|
|
end: |
|
|
|
return Result_Error; |
|
|
|
} |
|
|
|
}; |
|
|
|
|
|
|
@@ -113,6 +95,37 @@ TCASE(pkcs7_test) |
|
|
|
} |
|
|
|
TCASE_E |
|
|
|
|
|
|
|
TCASE(cbc_decrypt_test) |
|
|
|
{ |
|
|
|
static const uint8_t expected_result[34] = "I'm back and I'm ringin' the bell"; |
|
|
|
CryptoAttribs_t attribs; |
|
|
|
Key_t key; |
|
|
|
Result_t res = Result_Error; |
|
|
|
|
|
|
|
Key_t::Init(&key); |
|
|
|
key.len = 16; |
|
|
|
key.key = (uint8_t*) malloc(key.len); |
|
|
|
memcpy(key.key,"YELLOW SUBMARINE",key.len); |
|
|
|
|
|
|
|
CryptoAttribs_t::Init(&attribs); |
|
|
|
attribs.iv = (uint8_t*) malloc(key.len); |
|
|
|
attribs.iv_len = key.len; |
|
|
|
memset(attribs.iv, 0, attribs.iv_len); |
|
|
|
|
|
|
|
res = load_base64_to_hex( |
|
|
|
"sol/etc/set2_t2.txt", |
|
|
|
&(attribs.input), |
|
|
|
&(attribs.input_len)); |
|
|
|
CHECK(res == Result_OK, (const uint8_t*) "Problem when loading input file"); |
|
|
|
cbc_decrypt(&attribs, &key); |
|
|
|
CHECK( memcmp(expected_result, attribs.output, 33) == 0, (const uint8_t*) |
|
|
|
"Wrong plaintext decrypted"); |
|
|
|
// cleanup |
|
|
|
CryptoAttribs_t::Free(&attribs); |
|
|
|
Key_t::Free(&key); |
|
|
|
} |
|
|
|
TCASE_E |
|
|
|
|
|
|
|
TCASE(cbc_enc_dec_test) |
|
|
|
{ |
|
|
|
static const uint8_t test_text[49] = "The quick brown fox jumps over the lazy mad dog."; |
|
|
@@ -159,38 +172,6 @@ end: |
|
|
|
} |
|
|
|
TCASE_E |
|
|
|
|
|
|
|
TCASE(cbc_decrypt_test) |
|
|
|
{ |
|
|
|
static const uint8_t expected_result[34] = "I'm back and I'm ringin' the bell"; |
|
|
|
CryptoAttribs_t attribs; |
|
|
|
Key_t key; |
|
|
|
Result_t res = Result_Error; |
|
|
|
|
|
|
|
Key_t::Init(&key); |
|
|
|
key.len = 16; |
|
|
|
key.key = (uint8_t*) malloc(key.len); |
|
|
|
memcpy(key.key,"YELLOW SUBMARINE",key.len); |
|
|
|
|
|
|
|
CryptoAttribs_t::Init(&attribs); |
|
|
|
attribs.iv = (uint8_t*) malloc(key.len); |
|
|
|
attribs.iv_len = key.len; |
|
|
|
memset(attribs.iv, 0, attribs.iv_len); |
|
|
|
|
|
|
|
res = load_base64_to_hex( |
|
|
|
"sol/etc/set2_t2.txt", |
|
|
|
&(attribs.input), |
|
|
|
&(attribs.input_len)); |
|
|
|
CHECK(res == Result_OK, (const uint8_t*) "Problem when loading input file"); |
|
|
|
cbc_decrypt(&attribs, &key); |
|
|
|
CHECK( memcmp(expected_result, attribs.output, 33) == 0, (const uint8_t*) |
|
|
|
"Wrong plaintext decrypted"); |
|
|
|
// cleanup |
|
|
|
CryptoAttribs_t::Free(&attribs); |
|
|
|
Key_t::Free(&key); |
|
|
|
} |
|
|
|
TCASE_E |
|
|
|
|
|
|
|
/* |
|
|
|
TCASE(encode_decode_openssl) |
|
|
|
{ |
|
|
|
uint8_t concatenated_blocks[16*3]; |
|
|
@@ -206,34 +187,66 @@ TCASE(encode_decode_openssl) |
|
|
|
memset(&concatenated_blocks[32], 9, 16); |
|
|
|
|
|
|
|
RAND_bytes(iv1, 16); |
|
|
|
Key_t keyObj; |
|
|
|
keyObj.key = &key[0]; |
|
|
|
keyObj.len = 16; |
|
|
|
|
|
|
|
CHECK( 1 == OpenSSL::Cbc(concatenated_blocks, 48, |
|
|
|
iv1, 16, |
|
|
|
key, 16, |
|
|
|
kEncrypt, |
|
|
|
&ciphertext, &ciphertext_len), |
|
|
|
(uint8_t*)"OpenSSL encryption failed"); |
|
|
|
|
|
|
|
// test decryption |
|
|
|
CHECK(ciphertext_len==48, (uint8_t*)"Ciphertext has wrong size"); |
|
|
|
res = decrypt_cbc(iv1, 16, ciphertext, ciphertext_len, key, 16, &out, &out_len ); |
|
|
|
CHECK( Result_OK == res ); |
|
|
|
CHECK( memcmp(concatenated_blocks, out, 48) == 0, (uint8_t*)"Input/Output differs"); |
|
|
|
|
|
|
|
// test encryption |
|
|
|
ciphertext_len = 0; |
|
|
|
out_len = 0; |
|
|
|
res = encrypt_cbc(iv1, 16, concatenated_blocks, 48, key, 16, &ciphertext, &ciphertext_len ); |
|
|
|
CHECK( Result_OK == res ); |
|
|
|
CHECK(ciphertext_len==48, (uint8_t*)"Ciphertext has wrong size"); |
|
|
|
CHECK( 1 == OpenSSL::Cbc(ciphertext, 48, |
|
|
|
iv1, 16, |
|
|
|
key, 16, |
|
|
|
kDecrypt, |
|
|
|
&out, &out_len), |
|
|
|
(uint8_t*)"OpenSSL encryption failed"); |
|
|
|
CHECK(ciphertext_len==48, (uint8_t*)"Ciphertext has wrong size"); |
|
|
|
CHECK( memcmp(concatenated_blocks, out, 48) == 0, (uint8_t*)"Input/Output differs"); |
|
|
|
// 1. decryption test |
|
|
|
{ |
|
|
|
CryptoAttribs_t attribs_openssl_enc; |
|
|
|
CryptoAttribs_t::Init(&attribs_openssl_enc); |
|
|
|
attribs_openssl_enc.input = concatenated_blocks; |
|
|
|
attribs_openssl_enc.input_len = sizeof(concatenated_blocks); |
|
|
|
attribs_openssl_enc.output = (uint8_t*)malloc(attribs_openssl_enc.input_len); |
|
|
|
attribs_openssl_enc.output_len; |
|
|
|
attribs_openssl_enc.iv = &iv1[0]; |
|
|
|
attribs_openssl_enc.iv_len = sizeof(iv1); |
|
|
|
attribs_openssl_enc.operation = kEncrypt; |
|
|
|
CHECK(OpenSSL::Cbc(&attribs_openssl_enc, &keyObj)==Result_OK); |
|
|
|
CHECK(attribs_openssl_enc.output_len==48, (uint8_t*)"Ciphertext has wrong size"); |
|
|
|
|
|
|
|
CryptoAttribs_t cbc_attribs; |
|
|
|
CryptoAttribs_t::Init(&cbc_attribs); |
|
|
|
cbc_attribs.input = attribs_openssl_enc.output; |
|
|
|
cbc_attribs.input_len = attribs_openssl_enc.output_len; |
|
|
|
cbc_attribs.iv = &iv1[0]; |
|
|
|
cbc_attribs.iv_len = sizeof(iv1); |
|
|
|
CHECK( Result_OK == cbc_decrypt(&cbc_attribs, &keyObj) ); |
|
|
|
CHECK( |
|
|
|
memcmp( concatenated_blocks, |
|
|
|
cbc_attribs.output, |
|
|
|
cbc_attribs.output_len) == 0, |
|
|
|
(uint8_t*)"Input/Output differs"); |
|
|
|
::free(attribs_openssl_enc.output); |
|
|
|
::free(cbc_attribs.output); |
|
|
|
} |
|
|
|
// 2. encryption test |
|
|
|
{ |
|
|
|
CryptoAttribs_t attribs_enc; |
|
|
|
CryptoAttribs_t::Init(&attribs_enc); |
|
|
|
attribs_enc.input = concatenated_blocks; |
|
|
|
attribs_enc.input_len = sizeof(concatenated_blocks); |
|
|
|
attribs_enc.iv = &iv1[0]; |
|
|
|
attribs_enc.iv_len = sizeof(iv1); |
|
|
|
attribs_enc.operation = kEncrypt; |
|
|
|
CHECK( Result_OK == cbc_encrypt(&attribs_enc, &keyObj) ); |
|
|
|
|
|
|
|
CryptoAttribs_t attribs_openssl_dec; |
|
|
|
CryptoAttribs_t::Init(&attribs_openssl_dec); |
|
|
|
attribs_openssl_dec.input = attribs_enc.output; |
|
|
|
attribs_openssl_dec.input_len = attribs_enc.output_len; |
|
|
|
attribs_openssl_dec.iv = &iv1[0]; |
|
|
|
attribs_openssl_dec.iv_len = sizeof(iv1); |
|
|
|
attribs_openssl_dec.operation = kDecrypt; |
|
|
|
CHECK(OpenSSL::Cbc(&attribs_openssl_dec, &keyObj)==Result_OK); |
|
|
|
CHECK(attribs_openssl_dec.output_len==48, (uint8_t*)"Ciphertext has wrong size"); |
|
|
|
CHECK( |
|
|
|
memcmp( concatenated_blocks, |
|
|
|
attribs_openssl_dec.output, |
|
|
|
attribs_openssl_dec.output_len) == 0, |
|
|
|
(uint8_t*)"Input/Output differs"); |
|
|
|
::free(attribs_enc.output); |
|
|
|
::free(attribs_openssl_dec.output); |
|
|
|
} |
|
|
|
} |
|
|
|
TCASE_E |
|
|
|
*/ |