C4Err ECC_Decrypt(ECC_ContextRef privCtx, void *inData, size_t inDataLen, void *outData, size_t bufSize, size_t *outDataLen)
{
C4Err err = kC4Err_NoErr;
int status = CRYPT_OK;
unsigned long length = bufSize;
validateECCContext(privCtx);
ValidateParam(privCtx->isInited);
if(privCtx->isBLCurve)
{
status = ecc_bl_decrypt_key(inData, inDataLen, outData, &length, &privCtx->key);
}
else
{
status = ecc_decrypt_key(inData, inDataLen, outData, &length, &privCtx->key);
}
if(status != CRYPT_OK)
{
err = sCrypt2C4Err(status); CKERR;
}
*outDataLen = length;
done:
return err;
}
/* { ecc_decrypt start } */
int ecc_decrypt(unsigned char* in, unsigned long inLength, unsigned char* out, unsigned long* outLength, ecc_key* key){
int err;
if ((err = ecc_decrypt_key(in,inLength,out,outLength,key)) != CRYPT_OK) {
printf("Error decrypting ,%i, %s\n",err, error_to_string(err));
exit(EXIT_FAILURE);
}
return 0;
}
int TestPK(prng_state * PRNG)
{
int err = CRYPT_OK;
int i;
ecc_key eccKey;
uint8_t PT[PTsize];
uint8_t CT[256];
uint8_t DT[PTsize];
unsigned long z,w;
uint8_t PrivKey[256];
uint8_t PubKey[256];
// uint8_t tempBuf[256];
// unsigned long tempLen;
printf("\nTesting PK\n");
// fill PT
for(i = 0; i< PTsize; i++) PT[i]= i;
DO( ecc_make_key(PRNG, find_prng ("yarrow"), 384/8, &eccKey));
z = sizeof(PubKey);
DO( ecc_export(PubKey, &z, PK_PUBLIC, &eccKey));
printf("\tPub Key (%ld bytes)\n", z);
dumpHex(PubKey, z, 8);
z = sizeof(PrivKey);
DO( ecc_export(PrivKey, &z, PK_PRIVATE, &eccKey));
printf("\n\tPriv Key (%ld bytes)\n", z);
dumpHex(PrivKey, z, 8);
z = 384;
DO( ecc_encrypt_key(PT, PTsize, CT, &z,
PRNG,
find_prng("yarrow"),
find_hash("sha256"),
&eccKey));
printf("\n\tEncrypted message (%ld bytes)\n", z);
dumpHex(CT, z, 0);
DO( ecc_decrypt_key(CT, z, DT, &w, &eccKey));
/* check against know-answer */
DO(compareResults( DT, PT, PTsize , kResultFormat_Byte, "ECC Decrypt"));
printf("\n\tDecrypted OK\n");
dumpHex(DT, w, 0);
ecc_free(&eccKey);
return err;
}
int ecc_tests (void)
{
unsigned char buf[4][4096];
unsigned long x, y, z, s;
int stat, stat2;
ecc_key usera, userb, pubKey, privKey;
DO(ecc_test ());
DO(ecc_test ());
DO(ecc_test ());
DO(ecc_test ());
DO(ecc_test ());
for (s = 0; s < (sizeof(sizes)/sizeof(sizes[0])); s++) {
/* make up two keys */
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &usera));
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &userb));
/* make the shared secret */
x = sizeof(buf[0]);
DO(ecc_shared_secret (&usera, &userb, buf[0], &x));
y = sizeof(buf[1]);
DO(ecc_shared_secret (&userb, &usera, buf[1], &y));
if (y != x) {
fprintf(stderr, "ecc Shared keys are not same size.");
return 1;
}
if (memcmp (buf[0], buf[1], x)) {
fprintf(stderr, "ecc Shared keys not same contents.");
return 1;
}
/* now export userb */
y = sizeof(buf[0]);
DO(ecc_export (buf[1], &y, PK_PUBLIC, &userb));
ecc_free (&userb);
/* import and make the shared secret again */
DO(ecc_import (buf[1], y, &userb));
z = sizeof(buf[0]);
DO(ecc_shared_secret (&usera, &userb, buf[2], &z));
if (z != x) {
fprintf(stderr, "failed. Size don't match?");
return 1;
}
if (memcmp (buf[0], buf[2], x)) {
fprintf(stderr, "Failed. Contents didn't match.");
return 1;
}
/* export with ANSI X9.63 */
y = sizeof(buf[1]);
DO(ecc_ansi_x963_export(&userb, buf[1], &y));
ecc_free (&userb);
/* now import the ANSI key */
DO(ecc_ansi_x963_import(buf[1], y, &userb));
/* shared secret */
z = sizeof(buf[0]);
DO(ecc_shared_secret (&usera, &userb, buf[2], &z));
if (z != x) {
fprintf(stderr, "failed. Size don't match?");
return 1;
}
if (memcmp (buf[0], buf[2], x)) {
fprintf(stderr, "Failed. Contents didn't match.");
return 1;
}
ecc_free (&usera);
ecc_free (&userb);
/* test encrypt_key */
DO(ecc_make_key (&yarrow_prng, find_prng ("yarrow"), sizes[s], &usera));
/* export key */
x = sizeof(buf[0]);
DO(ecc_export(buf[0], &x, PK_PUBLIC, &usera));
DO(ecc_import(buf[0], x, &pubKey));
x = sizeof(buf[0]);
DO(ecc_export(buf[0], &x, PK_PRIVATE, &usera));
DO(ecc_import(buf[0], x, &privKey));
for (x = 0; x < 32; x++) {
buf[0][x] = x;
}
y = sizeof (buf[1]);
DO(ecc_encrypt_key (buf[0], 32, buf[1], &y, &yarrow_prng, find_prng ("yarrow"), find_hash ("sha256"), &pubKey));
zeromem (buf[0], sizeof (buf[0]));
x = sizeof (buf[0]);
DO(ecc_decrypt_key (buf[1], y, buf[0], &x, &privKey));
if (x != 32) {
fprintf(stderr, "Failed (length)");
return 1;
}
for (x = 0; x < 32; x++) {
if (buf[0][x] != x) {
fprintf(stderr, "Failed (contents)");
return 1;
}
}
/* test sign_hash */
for (x = 0; x < 16; x++) {
buf[0][x] = x;
}
x = sizeof (buf[1]);
DO(ecc_sign_hash (buf[0], 16, buf[1], &x, &yarrow_prng, find_prng ("yarrow"), &privKey));
DO(ecc_verify_hash (buf[1], x, buf[0], 16, &stat, &pubKey));
buf[0][0] ^= 1;
DO(ecc_verify_hash (buf[1], x, buf[0], 16, &stat2, &privKey));
if (!(stat == 1 && stat2 == 0)) {
fprintf(stderr, "ecc_verify_hash failed %d, %d, ", stat, stat2);
return 1;
}
ecc_free (&usera);
ecc_free (&pubKey);
ecc_free (&privKey);
}
#ifdef LTC_ECC_SHAMIR
return ecc_test_shamir();
#else
return 0;
#endif
}
