rsa.c File Reference

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include "crypto.h"

Go to the source code of this file.

Functions
void	RSA_priv_key_new (RSA_CTX **ctx, const uint8_t *modulus, int mod_len, const uint8_t *pub_exp, int pub_len, const uint8_t *priv_exp, int priv_len)
	Implements the RSA public encryption algorithm.
void	RSA_pub_key_new (RSA_CTX **ctx, const uint8_t *modulus, int mod_len, const uint8_t *pub_exp, int pub_len)
void	RSA_free (RSA_CTX *rsa_ctx)
	Free up any RSA context resources.
int	RSA_decrypt (const RSA_CTX *ctx, const uint8_t *in_data, uint8_t *out_data, int is_decryption)
	Use PKCS1.5 for decryption/verification.
bigint *	RSA_private (const RSA_CTX *c, bigint *bi_msg)
	Performs m = c^d mod n.
bigint *	RSA_public (const RSA_CTX *c, bigint *bi_msg)
	Performs c = m^e mod n.
int	RSA_encrypt (const RSA_CTX *ctx, const uint8_t *in_data, uint16_t in_len, uint8_t *out_data, int is_signing)
	Use PKCS1.5 for encryption/signing.

---

Function Documentation

void RSA_priv_key_new	(	RSA_CTX **	ctx,
		const uint8_t *	modulus,
		int	mod_len,
		const uint8_t *	pub_exp,
		int	pub_len,
		const uint8_t *	priv_exp,
		int	priv_len
	)

Implements the RSA public encryption algorithm.

Uses the bigint library to perform its calculations.

Definition at line 34 of file rsa.c.

References RSA_CTX::bi_ctx, bi_import(), bi_permanent(), bi_set_mod(), RSA_CTX::d, and RSA_pub_key_new().

{
    RSA_CTX *rsa_ctx;
    BI_CTX *bi_ctx;
    RSA_pub_key_new(ctx, modulus, mod_len, pub_exp, pub_len);
    rsa_ctx = *ctx;
    bi_ctx = rsa_ctx->bi_ctx;
    rsa_ctx->d = bi_import(bi_ctx, priv_exp, priv_len);
    bi_permanent(rsa_ctx->d);

#ifdef CONFIG_BIGINT_CRT
    rsa_ctx->p = bi_import(bi_ctx, p, p_len);
    rsa_ctx->q = bi_import(bi_ctx, q, q_len);
    rsa_ctx->dP = bi_import(bi_ctx, dP, dP_len);
    rsa_ctx->dQ = bi_import(bi_ctx, dQ, dQ_len);
    rsa_ctx->qInv = bi_import(bi_ctx, qInv, qInv_len);
    bi_permanent(rsa_ctx->dP);
    bi_permanent(rsa_ctx->dQ);
    bi_permanent(rsa_ctx->qInv);
    bi_set_mod(bi_ctx, rsa_ctx->p, BIGINT_P_OFFSET);
    bi_set_mod(bi_ctx, rsa_ctx->q, BIGINT_Q_OFFSET);
#endif
}

void RSA_pub_key_new	(	RSA_CTX **	ctx,
		const uint8_t *	modulus,
		int	mod_len,
		const uint8_t *	pub_exp,
		int	pub_len
	)

Definition at line 69 of file rsa.c.

References RSA_CTX::bi_ctx, bi_import(), bi_initialize(), bi_permanent(), bi_set_mod(), BIGINT_M_OFFSET, calloc(), RSA_CTX::e, RSA_CTX::m, and RSA_CTX::num_octets.

Referenced by RSA_priv_key_new(), and tls_send_client_key_exchange().

{
    RSA_CTX *rsa_ctx;
    BI_CTX *bi_ctx = bi_initialize();
    *ctx = (RSA_CTX *)calloc(1, sizeof(RSA_CTX));
    rsa_ctx = *ctx;
    rsa_ctx->bi_ctx = bi_ctx;
    rsa_ctx->num_octets = (mod_len & 0xFFF0);
    rsa_ctx->m = bi_import(bi_ctx, modulus, mod_len);
    bi_set_mod(bi_ctx, rsa_ctx->m, BIGINT_M_OFFSET);
    rsa_ctx->e = bi_import(bi_ctx, pub_exp, pub_len);
    bi_permanent(rsa_ctx->e);
}

void RSA_free

(

RSA_CTX *

rsa_ctx

)

Free up any RSA context resources.

Definition at line 88 of file rsa.c.

References RSA_CTX::bi_ctx, bi_depermanent(), bi_free(), bi_free_mod(), bi_terminate(), BIGINT_M_OFFSET, RSA_CTX::d, RSA_CTX::e, free(), and NULL.

Referenced by tls_send_client_key_exchange().

{
    BI_CTX *bi_ctx;
    if (rsa_ctx == NULL)                /* deal with ptrs that are null */
        return;

    bi_ctx = rsa_ctx->bi_ctx;

    bi_depermanent(rsa_ctx->e);
    bi_free(bi_ctx, rsa_ctx->e);
    bi_free_mod(rsa_ctx->bi_ctx, BIGINT_M_OFFSET);

    if (rsa_ctx->d)
    {
        bi_depermanent(rsa_ctx->d);
        bi_free(bi_ctx, rsa_ctx->d);
#ifdef CONFIG_BIGINT_CRT
        bi_depermanent(rsa_ctx->dP);
        bi_depermanent(rsa_ctx->dQ);
        bi_depermanent(rsa_ctx->qInv);
        bi_free(bi_ctx, rsa_ctx->dP);
        bi_free(bi_ctx, rsa_ctx->dQ);
        bi_free(bi_ctx, rsa_ctx->qInv);
        bi_free_mod(rsa_ctx->bi_ctx, BIGINT_P_OFFSET);
        bi_free_mod(rsa_ctx->bi_ctx, BIGINT_Q_OFFSET);
#endif
    }

    bi_terminate(bi_ctx);
    free(rsa_ctx);
}

int RSA_decrypt	(	const RSA_CTX *	ctx,
		const uint8_t *	in_data,
		uint8_t *	out_data,
		int	is_decryption
	)

Use PKCS1.5 for decryption/verification.

Parameters:

	ctx	[in] The context
	in_data	[in] The data to encrypt (must be < modulus size-11)
	out_data	[out] The encrypted data.
	is_decryption	[in] Decryption or verify operation.

Returns:

The number of bytes that were originally encrypted. -1 on error.

See also:

http://www.rsasecurity.com/rsalabs/node.asp?id=2125

Definition at line 129 of file rsa.c.

References RSA_CTX::bi_ctx, bi_export(), bi_import(), free(), malloc(), memcpy, memset(), RSA_CTX::num_octets, RSA_private(), RSA_public(), and size.

{
    int byte_size = ctx->num_octets;
    uint8_t *block;
    int i, size;
    bigint *decrypted_bi, *dat_bi;

    memset(out_data, 0, byte_size); /* initialise */

    /* decrypt */
    dat_bi = bi_import(ctx->bi_ctx, in_data, byte_size);
#ifdef CONFIG_SSL_CERT_VERIFICATION
    decrypted_bi = is_decryption ?  /* decrypt or verify? */
            RSA_private(ctx, dat_bi) : RSA_public(ctx, dat_bi);
#else   /* always a decryption */
    decrypted_bi = RSA_private(ctx, dat_bi);
#endif

    /* convert to a normal block */
    block = (uint8_t *)malloc(byte_size);
    bi_export(ctx->bi_ctx, decrypted_bi, block, byte_size);

    i = 10; /* start at the first possible non-padded byte */

#ifdef CONFIG_SSL_CERT_VERIFICATION
    if (is_decryption == 0) /* PKCS1.5 signing pads with "0xff"s */
    {
        while (block[i++] == 0xff && i < byte_size);

        if (block[i-2] != 0xff)
            i = byte_size;     /*ensure size is 0 */   
    }
    else                    /* PKCS1.5 encryption padding is random */
#endif
    {
        while (block[i++] && i < byte_size);
    }
    size = byte_size - i;

    /* get only the bit we want */
    if (size > 0)
        memcpy(out_data, &block[i], size);
    
    free(block);
    return size ? size : -1;
}

bigint* RSA_private	(	const RSA_CTX *	c,
		bigint *	bi_msg
	)

Performs m = c^d mod n.

Definition at line 180 of file rsa.c.

References RSA_CTX::bi_ctx, bi_mod_power(), BIGINT_M_OFFSET, RSA_CTX::d, and BI_CTX::mod_offset.

Referenced by RSA_decrypt(), and RSA_encrypt().

{
#ifdef CONFIG_BIGINT_CRT
    return bi_crt(c, bi_msg);
#else
    BI_CTX *ctx = c->bi_ctx;
    ctx->mod_offset = BIGINT_M_OFFSET;
    return bi_mod_power(ctx, bi_msg, c->d);
#endif
}

bigint* RSA_public	(	const RSA_CTX *	c,
		bigint *	bi_msg
	)

Performs c = m^e mod n.

Definition at line 245 of file rsa.c.

References RSA_CTX::bi_ctx, bi_mod_power(), BIGINT_M_OFFSET, RSA_CTX::e, and BI_CTX::mod_offset.

Referenced by RSA_decrypt(), and RSA_encrypt().

{
    c->bi_ctx->mod_offset = BIGINT_M_OFFSET;
    return bi_mod_power(c->bi_ctx, bi_msg, c->e);
}

int RSA_encrypt	(	const RSA_CTX *	ctx,
		const uint8_t *	in_data,
		uint16_t	in_len,
		uint8_t *	out_data,
		int	is_signing
	)

Use PKCS1.5 for encryption/signing.

see http://www.rsasecurity.com/rsalabs/node.asp?id=2125

Definition at line 255 of file rsa.c.

References RSA_CTX::bi_ctx, bi_export(), bi_import(), get_random_NZ(), memcpy, memset(), RSA_CTX::num_octets, RSA_private(), and RSA_public().

Referenced by tls_send_client_key_exchange().

{
    int byte_size = ctx->num_octets;
    int num_pads_needed = byte_size-in_len-3;
    bigint *dat_bi, *encrypt_bi;

    /* note: in_len+11 must be > byte_size */
    out_data[0] = 0;     /* ensure encryption block is < modulus */

    if (is_signing)
    {
        out_data[1] = 1;        /* PKCS1.5 signing pads with "0xff"'s */
        memset(&out_data[2], 0xff, num_pads_needed);
    }
    else /* randomize the encryption padding with non-zero bytes */   
    {
        out_data[1] = 2;
        get_random_NZ(num_pads_needed, &out_data[2]);
    }

    out_data[2+num_pads_needed] = 0;
    memcpy(&out_data[3+num_pads_needed], in_data, in_len);

    /* now encrypt it */
    dat_bi = bi_import(ctx->bi_ctx, out_data, byte_size);
    encrypt_bi = is_signing ? RSA_private(ctx, dat_bi) : 
        RSA_public(ctx, dat_bi);
    bi_export(ctx->bi_ctx, encrypt_bi, out_data, byte_size);
    return byte_size;
}