rsa_context Class Reference

#include <rsa_context.hh>

Inheritance diagram for rsa_context:

[legend]

Public Member Functions
	rsa_context (int keylen)
	rsa_context (const std::string &filename, const std::string &passwd)
	rsa_context (const char *filename, const char *passwd)
int	get_key_bits ()
int	max_ptext_bytes ()
bool	is_crt_available ()
virtual void	pub_encrypt (unsigned char *out, int *out_len, const unsigned char *in, int in_len)
virtual void	priv_decrypt (unsigned char *out, int *out_len, const unsigned char *in, int in_len)
virtual void	priv_decrypt_batch (unsigned char **out, int *out_len, const unsigned char **in, const int *in_len, int n)

---

Detailed Description

class rsa_context

Interface for RSA processing.

---

Constructor & Destructor Documentation

rsa_context::rsa_context

(

int

keylen

)

Constructor. It will randomly generate the RSA key pair with the given key length.

Parameters:

keylen

Length of key in bits. Supported length are 512, 1024, 2048, and 4096 bits.

{
        assert(keylen == 512 || keylen == 1024 || keylen == 2048 || keylen == 4096);

        BIGNUM *e = BN_new();
        BN_set_word(e, RSA_F4 /* 65537 */);

        rsa = RSA_new();
        RSA_generate_key_ex(rsa, keylen, e, NULL);
        assert(RSA_check_key(rsa));
        BN_free(e);

        set_crt();

        bn_ctx = BN_CTX_new();
        elapsed_ms_kernel = 0.0f;
};

Here is the caller graph for this function:

rsa_context::rsa_context	(	const std::string &	filename,
		const std::string &	passwd
	)

Constructor. It will load key from the file using the given password. Currently supports PEM format only

Parameters:

	filename	file path that contains the rsa private key
	passwd	password used to encrypt the private key

{
        rsa_context(filename.c_str(), passwd.c_str());
}

Here is the call graph for this function:

rsa_context::rsa_context	(	const char *	filename,
		const char *	passwd
	)

Constructor. It will load key from the file using the given password. Currently supports PEM format only

Parameters:

	filename	file path that contains the rsa private key
	passwd	password used to encrypt the private key

{
        BIO *key;
        OpenSSL_add_all_algorithms();

        key = BIO_new(BIO_s_file());
        assert(key != NULL);
        assert(BIO_read_filename(key, filename) == 1);
        rsa = PEM_read_bio_RSAPrivateKey(key, NULL, NULL, (void *)passwd);
        ERR_print_errors_fp(stdout);
        BIO_free(key);

        set_crt();

        bn_ctx = BN_CTX_new();
        elapsed_ms_kernel = 0.0f;
};

---

Member Function Documentation

int rsa_context::get_key_bits

(

)

Return key length.

Returns:

key length in bits.

{
        return RSA_size(rsa) * 8;
}

Here is the caller graph for this function:

bool rsa_context::is_crt_available

(

)

Return whether chinese remainder theorem (CRT) is used for processing or not.

Returns:

true if CRT is enabled, false otherwise.

{
        return crt_available;
}

Here is the caller graph for this function:

int rsa_context::max_ptext_bytes

(

)

Return a maximum amount of plain text that can be encrypted.

Returns:

maximum plain text size in bytes.

{
        return RSA_size(rsa) - 11;
}

Here is the caller graph for this function:

void rsa_context::priv_decrypt	(	unsigned char *	out,
		int *	out_len,
		const unsigned char *	in,
		int	in_len
	)			[virtual]

Decrypt the data with RSA algorithm using private key. All encryption/decryption methods assume RSA_PKCS1_PADDING

Parameters:

	out	Buffer for output.
	out_len	In: allocated buffer space for output result, Out: output size.
	in	Buffer that stores cipher text.
	in_len	Length of cipher text

Reimplemented in rsa_context_mp.

{
#if 0
        if (is_crt_available()) {
                // This is only for debugging purpose.
                // RSA_private_decrypt() is enough.
                BIGNUM *c = BN_bin2bn(in, in_len, NULL);
                assert(c != NULL);
                assert(BN_cmp(c, rsa->n) == -1);

                BIGNUM *m1 = BN_new();
                BIGNUM *m2 = BN_new();
                BIGNUM *t = BN_new();

                BN_nnmod(t, c, rsa->p, bn_ctx);
                BN_mod_exp(m1, t, rsa->dmp1, rsa->p, bn_ctx);
                BN_nnmod(t, c, rsa->q, bn_ctx);
                BN_mod_exp(m2, t, rsa->dmq1, rsa->q, bn_ctx);
                
                BN_sub(t, m1, m2);
                BN_mod_mul(t, t, rsa->iqmp, rsa->p, bn_ctx);
                BN_mul(t, t, rsa->q, bn_ctx);
                BN_add(t, m2, t);

                int ret = remove_padding(out, out_len, t);
                assert(ret != -1);

                BN_free(c);
                BN_free(m1);
                BN_free(m2);
                BN_free(t);
        } else {
#endif
                int bytes_needed = get_key_bits() / 8;
                assert(*out_len >= bytes_needed);

                *out_len = RSA_private_decrypt(in_len, in, out, rsa, 
                                RSA_PKCS1_PADDING);
                assert(*out_len != -1);
#if 0
        }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rsa_context::priv_decrypt_batch	(	unsigned char **	out,
		int *	out_len,
		const unsigned char **	in,
		const int *	in_len,
		int	n
	)			[virtual]

Decrypt the data with RSA algorithm using private key in a batch All encryption/decryption methods assume RSA_PKCS1_PADDING

Parameters:

	out	Buffers for plain text.
	out_len	In: allocated buffer space for output results, Out: output sizes.
	in	Buffers that stores ciphertext.
	in_len	Length of cipher texts.
	n	Ciphertexts count.

Reimplemented in rsa_context_mp.

{
        assert(0 < n && n <= max_batch);

        for (int i = 0; i < n; i++)
                priv_decrypt(out[i], &out_len[i], in[i], in_len[i]);
}

Here is the call graph for this function:

void rsa_context::pub_encrypt	(	unsigned char *	out,
		int *	out_len,
		const unsigned char *	in,
		int	in_len
	)			[virtual]

Encrypts the data with RSA algorithm using public key. All encryption/decryption methods assume RSA_PKCS1_PADDING

Parameters:

	out	Buffer for output.
	out_len	In: allocated buffer space for output result, Out: out put size.
	in	Intput plain text.
	in_len	Intpu plain text size.

{
        int bytes_needed = get_key_bits() / 8;
        assert(*out_len >= bytes_needed);

        assert(in_len <= max_ptext_bytes());

        *out_len = RSA_public_encrypt(in_len, in, out, rsa, RSA_PKCS1_PADDING);
        assert(*out_len != -1);
}

Here is the call graph for this function: