int fips_cipher_test(int id, EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
const unsigned char *key,
const unsigned char *iv,
const unsigned char *plaintext,
const unsigned char *ciphertext,
int len)
{
unsigned char pltmp[FIPS_MAX_CIPHER_TEST_SIZE];
unsigned char citmp[FIPS_MAX_CIPHER_TEST_SIZE];
int subid = M_EVP_CIPHER_nid(cipher);
int rv = 0;
OPENSSL_assert(len <= FIPS_MAX_CIPHER_TEST_SIZE);
memset(pltmp, 0, FIPS_MAX_CIPHER_TEST_SIZE);
memset(citmp, 0, FIPS_MAX_CIPHER_TEST_SIZE);
if (!fips_post_started(id, subid, NULL))
return 1;
if (FIPS_cipherinit(ctx, cipher, key, iv, 1) <= 0)
goto error;
if (!FIPS_cipher(ctx, citmp, plaintext, len))
goto error;
if (memcmp(citmp, ciphertext, len))
goto error;
if (!fips_post_corrupt(id, subid, NULL))
citmp[0] ^= 0x1;
if (FIPS_cipherinit(ctx, cipher, key, iv, 0) <= 0)
goto error;
FIPS_cipher(ctx, pltmp, citmp, len);
if (memcmp(pltmp, plaintext, len))
goto error;
rv = 1;
error:
if (rv == 0)
{
fips_post_failed(id, subid, NULL);
return 0;
}
return fips_post_success(id, subid, NULL);
}
/* AES: encrypt and decrypt known plaintext, verify result matches original plaintext
*/
static int FIPS_aes_test(void)
{
int ret = 0;
unsigned char pltmp[16];
unsigned char citmp[16];
unsigned char key[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
unsigned char plaintext[16] = "etaonrishdlcu";
EVP_CIPHER_CTX ctx;
FIPS_cipher_ctx_init(&ctx);
if (FIPS_cipherinit(&ctx, EVP_aes_128_ecb(), key, NULL, 1) <= 0)
goto err;
FIPS_cipher(&ctx, citmp, plaintext, 16);
if (FIPS_cipherinit(&ctx, EVP_aes_128_ecb(), key, NULL, 0) <= 0)
goto err;
FIPS_cipher(&ctx, pltmp, citmp, 16);
if (memcmp(pltmp, plaintext, 16))
goto err;
ret = 1;
err:
FIPS_cipher_ctx_cleanup(&ctx);
return ret;
}
static int FIPS_des3_test(void)
{
int ret = 0;
unsigned char pltmp[8];
unsigned char citmp[8];
unsigned char key[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
19,20,21,22,23,24
};
unsigned char plaintext[] = { 'e', 't', 'a', 'o', 'n', 'r', 'i', 's' };
EVP_CIPHER_CTX ctx;
FIPS_cipher_ctx_init(&ctx);
if (FIPS_cipherinit(&ctx, EVP_des_ede3_ecb(), key, NULL, 1) <= 0)
goto err;
FIPS_cipher(&ctx, citmp, plaintext, 8);
if (FIPS_cipherinit(&ctx, EVP_des_ede3_ecb(), key, NULL, 0) <= 0)
goto err;
FIPS_cipher(&ctx, pltmp, citmp, 8);
if (memcmp(pltmp, plaintext, 8))
goto err;
ret = 1;
err:
FIPS_cipher_ctx_cleanup(&ctx);
return ret;
}
static int FIPS_aes_gcm_test(void)
{
int ret = 0;
unsigned char pltmp[16];
unsigned char citmp[16];
unsigned char tagtmp[16];
unsigned char key[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
unsigned char iv[16] = {21,22,23,24,25,26,27,28,29,30,31,32};
unsigned char aad[] = "Some text AAD";
unsigned char plaintext[16] = "etaonrishdlcu";
EVP_CIPHER_CTX ctx;
FIPS_cipher_ctx_init(&ctx);
if (FIPS_cipherinit(&ctx, EVP_aes_128_gcm(), key, iv, 1) <= 0)
goto err;
FIPS_cipher(&ctx, NULL, aad, sizeof(aad));
FIPS_cipher(&ctx, citmp, plaintext, 16);
FIPS_cipher(&ctx, NULL, NULL, 0);
if (!FIPS_cipher_ctx_ctrl(&ctx, EVP_CTRL_GCM_GET_TAG, 16, tagtmp))
goto err;
if (FIPS_cipherinit(&ctx, EVP_aes_128_gcm(), key, iv, 0) <= 0)
goto err;
if (!FIPS_cipher_ctx_ctrl(&ctx, EVP_CTRL_GCM_SET_TAG, 16, tagtmp))
goto err;
FIPS_cipher(&ctx, NULL, aad, sizeof(aad));
FIPS_cipher(&ctx, pltmp, citmp, 16);
if (FIPS_cipher(&ctx, NULL, NULL, 0) < 0)
goto err;
if (memcmp(pltmp, plaintext, 16))
goto err;
ret = 1;
err:
FIPS_cipher_ctx_cleanup(&ctx);
return ret;
}
static int AESTest(EVP_CIPHER_CTX *ctx,
char *amode, int akeysz, unsigned char *aKey,
unsigned char *iVec,
int dir, /* 0 = decrypt, 1 = encrypt */
unsigned char *plaintext, unsigned char *ciphertext, int len)
{
const EVP_CIPHER *cipher = NULL;
if (strcasecmp(amode, "CBC") == 0)
{
switch (akeysz)
{
case 128:
cipher = EVP_aes_128_cbc();
break;
case 192:
cipher = EVP_aes_192_cbc();
break;
case 256:
cipher = EVP_aes_256_cbc();
break;
}
}
else if (strcasecmp(amode, "ECB") == 0)
{
switch (akeysz)
{
case 128:
cipher = EVP_aes_128_ecb();
break;
case 192:
cipher = EVP_aes_192_ecb();
break;
case 256:
cipher = EVP_aes_256_ecb();
break;
}
}
else if (strcasecmp(amode, "CFB128") == 0)
{
switch (akeysz)
{
case 128:
cipher = EVP_aes_128_cfb128();
break;
case 192:
cipher = EVP_aes_192_cfb128();
break;
case 256:
cipher = EVP_aes_256_cfb128();
break;
}
}
else if (strncasecmp(amode, "OFB", 3) == 0)
{
switch (akeysz)
{
case 128:
cipher = EVP_aes_128_ofb();
break;
case 192:
cipher = EVP_aes_192_ofb();
break;
case 256:
cipher = EVP_aes_256_ofb();
break;
}
}
else if(!strcasecmp(amode,"CFB1"))
{
switch (akeysz)
{
case 128:
cipher = EVP_aes_128_cfb1();
break;
case 192:
cipher = EVP_aes_192_cfb1();
break;
case 256:
cipher = EVP_aes_256_cfb1();
break;
}
}
else if(!strcasecmp(amode,"CFB8"))
{
switch (akeysz)
{
case 128:
cipher = EVP_aes_128_cfb8();
break;
case 192:
cipher = EVP_aes_192_cfb8();
break;
case 256:
cipher = EVP_aes_256_cfb8();
break;
}
}
else
{
printf("Unknown mode: %s\n", amode);
return 0;
}
if (!cipher)
{
printf("Invalid key size: %d\n", akeysz);
return 0;
}
if (FIPS_cipherinit(ctx, cipher, aKey, iVec, dir) <= 0)
return 0;
if(!strcasecmp(amode,"CFB1"))
M_EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS);
if (dir)
FIPS_cipher(ctx, ciphertext, plaintext, len);
else
FIPS_cipher(ctx, plaintext, ciphertext, len);
return 1;
}
static int do_mct(char *amode,
int akeysz, unsigned char *aKey,unsigned char *iVec,
int dir, unsigned char *text, int len,
FILE *rfp)
{
int ret = 0;
unsigned char key[101][32];
unsigned char iv[101][AES_BLOCK_SIZE];
unsigned char ptext[1001][32];
unsigned char ctext[1001][32];
unsigned char ciphertext[64+4];
int i, j, n, n1, n2;
int imode = 0, nkeysz = akeysz/8;
EVP_CIPHER_CTX ctx;
FIPS_cipher_ctx_init(&ctx);
if (len > 32)
{
printf("\n>>>> Length exceeds 32 for %s %d <<<<\n\n",
amode, akeysz);
return -1;
}
for (imode = 0; imode < 6; ++imode)
if (strcmp(amode, t_mode[imode]) == 0)
break;
if (imode == 6)
{
printf("Unrecognized mode: %s\n", amode);
return -1;
}
memcpy(key[0], aKey, nkeysz);
if (iVec)
memcpy(iv[0], iVec, AES_BLOCK_SIZE);
if (dir == XENCRYPT)
memcpy(ptext[0], text, len);
else
memcpy(ctext[0], text, len);
for (i = 0; i < 100; ++i)
{
/* printf("Iteration %d\n", i); */
if (i > 0)
{
fprintf(rfp,"COUNT = %d\n",i);
OutputValue("KEY",key[i],nkeysz,rfp,0);
if (imode != ECB) /* ECB */
OutputValue("IV",iv[i],AES_BLOCK_SIZE,rfp,0);
/* Output Ciphertext | Plaintext */
OutputValue(t_tag[dir^1],dir ? ptext[0] : ctext[0],len,rfp,
imode == CFB1);
}
for (j = 0; j < 1000; ++j)
{
switch (imode)
{
case ECB:
if (j == 0)
{ /* set up encryption */
ret = AESTest(&ctx, amode, akeysz, key[i], NULL,
dir, /* 0 = decrypt, 1 = encrypt */
ptext[j], ctext[j], len);
if (dir == XENCRYPT)
memcpy(ptext[j+1], ctext[j], len);
else
memcpy(ctext[j+1], ptext[j], len);
}
else
{
if (dir == XENCRYPT)
{
FIPS_cipher(&ctx, ctext[j], ptext[j], len);
memcpy(ptext[j+1], ctext[j], len);
}
else
{
FIPS_cipher(&ctx, ptext[j], ctext[j], len);
memcpy(ctext[j+1], ptext[j], len);
}
}
break;
case CBC:
case OFB:
case CFB128:
if (j == 0)
{
ret = AESTest(&ctx, amode, akeysz, key[i], iv[i],
dir, /* 0 = decrypt, 1 = encrypt */
ptext[j], ctext[j], len);
if (dir == XENCRYPT)
memcpy(ptext[j+1], iv[i], len);
else
memcpy(ctext[j+1], iv[i], len);
}
else
{
if (dir == XENCRYPT)
{
FIPS_cipher(&ctx, ctext[j], ptext[j], len);
memcpy(ptext[j+1], ctext[j-1], len);
}
else
{
FIPS_cipher(&ctx, ptext[j], ctext[j], len);
memcpy(ctext[j+1], ptext[j-1], len);
}
}
break;
case CFB8:
if (j == 0)
{
ret = AESTest(&ctx, amode, akeysz, key[i], iv[i],
dir, /* 0 = decrypt, 1 = encrypt */
ptext[j], ctext[j], len);
}
else
{
if (dir == XENCRYPT)
FIPS_cipher(&ctx, ctext[j], ptext[j], len);
else
FIPS_cipher(&ctx, ptext[j], ctext[j], len);
}
if (dir == XENCRYPT)
{
if (j < 16)
memcpy(ptext[j+1], &iv[i][j], len);
else
memcpy(ptext[j+1], ctext[j-16], len);
}
else
{
if (j < 16)
memcpy(ctext[j+1], &iv[i][j], len);
else
memcpy(ctext[j+1], ptext[j-16], len);
}
break;
case CFB1:
if(j == 0)
{
#if 0
/* compensate for wrong endianness of input file */
if(i == 0)
ptext[0][0]<<=7;
#endif
ret = AESTest(&ctx,amode,akeysz,key[i],iv[i],dir,
ptext[j], ctext[j], len);
}
else
{
if (dir == XENCRYPT)
FIPS_cipher(&ctx, ctext[j], ptext[j], len);
else
FIPS_cipher(&ctx, ptext[j], ctext[j], len);
}
if(dir == XENCRYPT)
{
if(j < 128)
sb(ptext[j+1],0,gb(iv[i],j));
else
sb(ptext[j+1],0,gb(ctext[j-128],0));
}
else
{
if(j < 128)
sb(ctext[j+1],0,gb(iv[i],j));
else
sb(ctext[j+1],0,gb(ptext[j-128],0));
}
break;
}
}
--j; /* reset to last of range */
/* Output Ciphertext | Plaintext */
OutputValue(t_tag[dir],dir ? ctext[j] : ptext[j],len,rfp,
imode == CFB1);
fprintf(rfp, "\n"); /* add separator */
/* Compute next KEY */
if (dir == XENCRYPT)
{
if (imode == CFB8)
{ /* ct = CT[j-15] || CT[j-14] || ... || CT[j] */
for (n1 = 0, n2 = nkeysz-1; n1 < nkeysz; ++n1, --n2)
ciphertext[n1] = ctext[j-n2][0];
}
else if(imode == CFB1)
{
for(n1=0,n2=akeysz-1 ; n1 < akeysz ; ++n1,--n2)
sb(ciphertext,n1,gb(ctext[j-n2],0));
}
else
switch (akeysz)
{
case 128:
memcpy(ciphertext, ctext[j], 16);
break;
case 192:
memcpy(ciphertext, ctext[j-1]+8, 8);
memcpy(ciphertext+8, ctext[j], 16);
break;
case 256:
memcpy(ciphertext, ctext[j-1], 16);
memcpy(ciphertext+16, ctext[j], 16);
break;
}
}
else
{
if (imode == CFB8)
{ /* ct = CT[j-15] || CT[j-14] || ... || CT[j] */
for (n1 = 0, n2 = nkeysz-1; n1 < nkeysz; ++n1, --n2)
ciphertext[n1] = ptext[j-n2][0];
}
else if(imode == CFB1)
{
for(n1=0,n2=akeysz-1 ; n1 < akeysz ; ++n1,--n2)
sb(ciphertext,n1,gb(ptext[j-n2],0));
}
else
switch (akeysz)
{
case 128:
memcpy(ciphertext, ptext[j], 16);
break;
case 192:
memcpy(ciphertext, ptext[j-1]+8, 8);
memcpy(ciphertext+8, ptext[j], 16);
break;
case 256:
memcpy(ciphertext, ptext[j-1], 16);
memcpy(ciphertext+16, ptext[j], 16);
break;
}
}
/* Compute next key: Key[i+1] = Key[i] xor ct */
for (n = 0; n < nkeysz; ++n)
key[i+1][n] = key[i][n] ^ ciphertext[n];
/* Compute next IV and text */
if (dir == XENCRYPT)
{
switch (imode)
{
case ECB:
memcpy(ptext[0], ctext[j], AES_BLOCK_SIZE);
break;
case CBC:
case OFB:
case CFB128:
memcpy(iv[i+1], ctext[j], AES_BLOCK_SIZE);
memcpy(ptext[0], ctext[j-1], AES_BLOCK_SIZE);
break;
case CFB8:
/* IV[i+1] = ct */
for (n1 = 0, n2 = 15; n1 < 16; ++n1, --n2)
iv[i+1][n1] = ctext[j-n2][0];
ptext[0][0] = ctext[j-16][0];
break;
case CFB1:
for(n1=0,n2=127 ; n1 < 128 ; ++n1,--n2)
sb(iv[i+1],n1,gb(ctext[j-n2],0));
ptext[0][0]=ctext[j-128][0]&0x80;
break;
}
}
else
{
switch (imode)
{
case ECB:
memcpy(ctext[0], ptext[j], AES_BLOCK_SIZE);
break;
case CBC:
case OFB:
case CFB128:
memcpy(iv[i+1], ptext[j], AES_BLOCK_SIZE);
memcpy(ctext[0], ptext[j-1], AES_BLOCK_SIZE);
break;
case CFB8:
for (n1 = 0, n2 = 15; n1 < 16; ++n1, --n2)
iv[i+1][n1] = ptext[j-n2][0];
ctext[0][0] = ptext[j-16][0];
break;
case CFB1:
for(n1=0,n2=127 ; n1 < 128 ; ++n1,--n2)
sb(iv[i+1],n1,gb(ptext[j-n2],0));
ctext[0][0]=ptext[j-128][0]&0x80;
break;
}
}
}
return ret;
}
