/* read */
static int unsigned_read(void *a, unsigned char *b, unsigned long len)
{
LTC_ARGCHK(a != NULL);
LTC_ARGCHK(b != NULL);
fp_read_unsigned_bin(a, b, len);
return CRYPT_OK;
}
void fp_read_signed_bin(fp_int *a, const unsigned char *b, int c)
{
/* read magnitude */
fp_read_unsigned_bin (a, b + 1, c - 1);
/* first byte is 0 for positive, non-zero for negative */
if (b[0] == 0) {
a->sign = FP_ZPOS;
} else {
a->sign = FP_NEG;
}
}
static void
BN2mpz(fp_int *s, const BIGNUM *bn)
{
size_t len;
void *p;
len = BN_num_bytes(bn);
p = malloc(len);
BN_bn2bin(bn, p);
fp_read_unsigned_bin(s, p, len);
free(p);
}
static int
random_num(fp_int *num, size_t len)
{
unsigned char *p;
len = (len + 7) / 8;
p = malloc(len);
if (p == NULL)
return 1;
if (RAND_bytes(p, len) != 1) {
free(p);
return 1;
}
fp_read_unsigned_bin(num, p, len);
free(p);
return 0;
}
static int
tfm_rsa_private_decrypt(int flen, const unsigned char* from,
unsigned char* to, RSA* rsa, int padding)
{
unsigned char *ptr;
int res;
int size;
fp_int in, out, n, e;
if (padding != RSA_PKCS1_PADDING)
return -1;
size = RSA_size(rsa);
if (flen > size)
return -2;
fp_init_multi(&in, &out, NULL);
BN2mpz(&n, rsa->n);
BN2mpz(&e, rsa->e);
fp_read_unsigned_bin(&in, rk_UNCONST(from), flen);
if(fp_isneg(&in) || fp_cmp(&in, &n) >= 0) {
size = -2;
goto out;
}
if (rsa->p && rsa->q && rsa->dmp1 && rsa->dmq1 && rsa->iqmp) {
fp_int p, q, dmp1, dmq1, iqmp;
BN2mpz(&p, rsa->p);
BN2mpz(&q, rsa->q);
BN2mpz(&dmp1, rsa->dmp1);
BN2mpz(&dmq1, rsa->dmq1);
BN2mpz(&iqmp, rsa->iqmp);
res = tfm_rsa_private_calculate(&in, &p, &q, &dmp1, &dmq1, &iqmp, &out);
fp_zero_multi(&p, &q, &dmp1, &dmq1, &iqmp, NULL);
if (res != 0) {
size = -3;
goto out;
}
} else {
fp_int d;
if(fp_isneg(&in) || fp_cmp(&in, &n) >= 0)
return -4;
BN2mpz(&d, rsa->d);
res = fp_exptmod(&in, &d, &n, &out);
fp_zero(&d);
if (res != 0) {
size = -5;
goto out;
}
}
ptr = to;
{
size_t ssize;
ssize = fp_unsigned_bin_size(&out);
assert(size >= ssize);
fp_to_unsigned_bin(&out, ptr);
size = ssize;
}
/* head zero was skipped by mp_int_to_unsigned */
if (*ptr != 2) {
size = -6;
goto out;
}
size--; ptr++;
while (size && *ptr != 0) {
size--; ptr++;
}
if (size == 0)
return -7;
size--; ptr++;
memmove(to, ptr, size);
out:
fp_zero_multi(&e, &n, &in, &out, NULL);
return size;
}
static int
tfm_rsa_private_encrypt(int flen, const unsigned char* from,
unsigned char* to, RSA* rsa, int padding)
{
unsigned char *p, *p0;
int res;
int size;
fp_int in, out, n, e;
if (padding != RSA_PKCS1_PADDING)
return -1;
size = RSA_size(rsa);
if (size < RSA_PKCS1_PADDING_SIZE || size - RSA_PKCS1_PADDING_SIZE < flen)
return -2;
p0 = p = malloc(size);
*p++ = 0;
*p++ = 1;
memset(p, 0xff, size - flen - 3);
p += size - flen - 3;
*p++ = 0;
memcpy(p, from, flen);
p += flen;
assert((p - p0) == size);
BN2mpz(&n, rsa->n);
BN2mpz(&e, rsa->e);
fp_init_multi(&in, &out, NULL);
fp_read_unsigned_bin(&in, p0, size);
free(p0);
if(fp_isneg(&in) || fp_cmp(&in, &n) >= 0) {
size = -3;
goto out;
}
if (rsa->p && rsa->q && rsa->dmp1 && rsa->dmq1 && rsa->iqmp) {
fp_int p, q, dmp1, dmq1, iqmp;
BN2mpz(&p, rsa->p);
BN2mpz(&q, rsa->q);
BN2mpz(&dmp1, rsa->dmp1);
BN2mpz(&dmq1, rsa->dmq1);
BN2mpz(&iqmp, rsa->iqmp);
res = tfm_rsa_private_calculate(&in, &p, &q, &dmp1, &dmq1, &iqmp, &out);
fp_zero_multi(&p, &q, &dmp1, &dmq1, &iqmp, NULL);
if (res != 0) {
size = -4;
goto out;
}
} else {
fp_int d;
BN2mpz(&d, rsa->d);
res = fp_exptmod(&in, &d, &n, &out);
fp_zero(&d);
if (res != 0) {
size = -5;
goto out;
}
}
if (size > 0) {
size_t ssize;
ssize = fp_unsigned_bin_size(&out);
assert(size >= ssize);
fp_to_unsigned_bin(&out, to);
size = ssize;
}
out:
fp_zero_multi(&e, &n, &in, &out, NULL);
return size;
}
static int
tfm_rsa_public_decrypt(int flen, const unsigned char* from,
unsigned char* to, RSA* rsa, int padding)
{
unsigned char *p;
int res;
size_t size;
fp_int s, us, n, e;
if (padding != RSA_PKCS1_PADDING)
return -1;
if (flen > RSA_size(rsa))
return -2;
BN2mpz(&n, rsa->n);
BN2mpz(&e, rsa->e);
#if 0
/* Check that the exponent is larger then 3 */
if (mp_int_compare_value(&e, 3) <= 0) {
fp_zero_multi(&e, &n, NULL);
return -3;
}
#endif
fp_init_multi(&s, &us, NULL);
fp_read_unsigned_bin(&s, rk_UNCONST(from), flen);
if (fp_cmp(&s, &n) >= 0) {
fp_zero_multi(&e, &n, NULL);
return -4;
}
res = fp_exptmod(&s, &e, &n, &us);
fp_zero_multi(&s, &e, &n, NULL);
if (res != 0)
return -5;
p = to;
size = fp_unsigned_bin_size(&us);
assert(size <= RSA_size(rsa));
fp_to_unsigned_bin(&us, p);
fp_zero(&us);
/* head zero was skipped by fp_to_unsigned_bin */
if (*p == 0)
return -6;
if (*p != 1)
return -7;
size--; p++;
while (size && *p == 0xff) {
size--; p++;
}
if (size == 0 || *p != 0)
return -8;
size--; p++;
memmove(to, p, size);
return size;
}
static int
tfm_rsa_public_encrypt(int flen, const unsigned char* from,
unsigned char* to, RSA* rsa, int padding)
{
unsigned char *p, *p0;
int res;
size_t size, padlen;
fp_int enc, dec, n, e;
if (padding != RSA_PKCS1_PADDING)
return -1;
size = RSA_size(rsa);
if (size < RSA_PKCS1_PADDING_SIZE || size - RSA_PKCS1_PADDING_SIZE < flen)
return -2;
BN2mpz(&n, rsa->n);
BN2mpz(&e, rsa->e);
p = p0 = malloc(size - 1);
if (p0 == NULL) {
fp_zero_multi(&e, &n, NULL);
return -3;
}
padlen = size - flen - 3;
*p++ = 2;
if (RAND_bytes(p, padlen) != 1) {
fp_zero_multi(&e, &n, NULL);
free(p0);
return -4;
}
while(padlen) {
if (*p == 0)
*p = 1;
padlen--;
p++;
}
*p++ = 0;
memcpy(p, from, flen);
p += flen;
assert((p - p0) == size - 1);
fp_init_multi(&enc, &dec, NULL);
fp_read_unsigned_bin(&dec, p0, size - 1);
free(p0);
res = fp_exptmod(&dec, &e, &n, &enc);
fp_zero_multi(&dec, &e, &n, NULL);
if (res != 0)
return -4;
{
size_t ssize;
ssize = fp_unsigned_bin_size(&enc);
assert(size >= ssize);
fp_to_unsigned_bin(&enc, to);
size = ssize;
}
fp_zero(&enc);
return size;
}
