OpenSSL RSA 用法

最新推荐文章于 2023-05-30 17:54:57 发布

转载最新推荐文章于 2023-05-30 17:54:57 发布 · 1.6w 阅读

文章标签：

本文详细介绍了RSA加密算法的基本结构、初始化、生成私钥、位数判断、RSA_METHOD函数、加解密函数、签名函数、文件写入函数、其他函数以及与字符串的转换函数等内容。同时，阐述了基于OpenSSL的程序实现步骤，包括SSL初始化、协议选择、创建会话环境、建立SSL套接字、完成SSL握手、进行数据传输和结束SSL通信。

RSA基本结构
struct

     {

      int pad;

      long version;

      const RSA_METHOD *meth;

      ENGINE *engine;

      BIGNUM *n;         n=p*q

      BIGNUM *e;         公开的加密指数，经常为65537（ox10001）

      BIGNUM *d;         私钥

      BIGNUM *p;         大素数p

      BIGNUM *q;         大素数q

      BIGNUM *dmp1;      d mod (p-1)

      BIGNUM *dmq1;      d mod (q-1)

      BIGNUM *iqmp;      (inverse of q) mod p

      int references;

      int flags;

        // ...

      }RSA；

2．初始化函数
RSA * RSA_new(void);初始化一个RSA结构

void RSA_free(RSA *rsa);释放一个RSA结构

3．RSA私钥产生函数
RSA *RSA_generate_key(int num, unsigned long e,void (*callback)(int,int,void *), void *cb_arg);产生一个模为num位的密钥对，e为公开的加密指数，一般为65537（ox10001），假如后两个参数不为NULL，将有些调用。在产生密钥对之前，一般需要指定随机数种子

4．判断位数函数
int RSA_size(const RSA *rsa);返回RSA模的位数，他用来判断需要给加密值分配空间的大小

int RSA_check_key(RSA *rsa);他测试p,q是否为素数，n=p*q,d*e = 1 mod (p-1*q-1), dmp1, dmq1, iqmp是否均设置正确了。

5．RSA的RSA_METHOD函数
了解RSA的运算那就必须了解RSA_METHOD，下面我们先看看RSA_METHOD结构

typedef struct rsa_meth_st

        {

        const char *name;

        int (*rsa_pub_enc)(int flen,const unsigned char *from,

            unsigned char *to,RSA *rsa,int padding);

        int (*rsa_pub_dec)(int flen,const unsigned char *from,

             unsigned char *to,RSA *rsa,int padding);

        int (*rsa_priv_enc)(int flen,const unsigned char *from,

                unsigned char *to, RSA *rsa,int padding);

        int (*rsa_priv_dec)(int flen,const unsigned char *from,

                unsigned char *to,RSA *rsa,int padding);

        int (*rsa_mod_exp)(BIGNUM *r0,const BIGNUM *I,RSA *rsa);        int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,

                const BIGNUM *m, BN_CTX *ctx,BN_MONT_CTX *m_ctx);

        int (*init)(RSA *rsa);

        int (*finish)(RSA *rsa);

        int flags;

        char *app_data;

        int (*rsa_sign)(int type,const unsigned char *m, unsigned int m_length,unsigned char *sigret, unsigned int *siglen, const RSA *rsa);

        int (*rsa_verify)(int dtype,const unsigned char *m, unsigned int m_length,unsigned char *sigbuf, unsigned int siglen, const RSA *rsa);

        } RSA_METHOD;

const RSA_METHOD *RSA_PKCS1_SSLeay(void);

const RSA_METHOD *RSA_null_method(void);

主要有上面两个函数。第二个函数是定义了RSA_null才会调用，其实要调用这个函数以后几乎什么都不能干，只是输出错误信息。第一个是常用的 METHOD，下面我们看看它的定义

const RSA_METHOD *RSA_PKCS1_SSLeay(void)

        {

        return(&rsa_pkcs1_eay_meth);

        }

static RSA_METHOD rsa_pkcs1_eay_meth={

        Eric Young s PKCS#1 RSA,

        RSA_eay_public_encrypt,

        RSA_eay_public_decrypt,

        RSA_eay_private_encrypt,

        RSA_eay_private_decrypt,

        RSA_eay_mod_exp,

        BN_mod_exp_mont,

        RSA_eay_init,

        RSA_eay_finish,

        0,

        NULL,

        0,

        0

        };

由此可以看出，一般rsa->meth-> rsa_pub_enc对应于RSA_eay_public_encrypt，刚开始看openssl的时候最难得就是这个指向函数的指针，根本不知道 rsa->meth-> rsa_pub_enc对应于哪里。在openssl里面这种指针很多，到以后也能够看到。下面是设置meth的一些函数应该都很容易理解

void RSA_set_default_method(const RSA_METHOD *meth);

const RSA_METHOD *RSA_get_default_method(void);

int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);

const RSA_METHOD *RSA_get_method(const RSA *rsa);

int RSA_flags(const RSA *rsa);

RSA *RSA_new_method(ENGINE *engine);

6．加解密函数
int RSA_public_encrypt(int flen, unsigned char *from,

    unsigned char *to, RSA *rsa, int padding);

int RSA_private_decrypt(int flen, unsigned char *from,

    unsigned char *to, RSA *rsa, int padding);

int RSA_private_encrypt(int flen, unsigned char *from,

    unsigned char *to, RSA *rsa,int padding);

int RSA_public_decrypt(int flen, unsigned char *from,

unsigned char *to, RSA *rsa,int padding);

有了第4节的基础，那理解这些加解密函数就容易了，假如

RSA_set_method(rsa, RSA_PKCS1_SSLeay())的话，那RSA_public_encrypt对应于RSA_eay_public_encrypt，这样我们就可以调试公钥加密的过程了。Flen为要加密信息的长度，from为需要加密的信息，to为加密后的信息，一般to至少要申请 BN_num_bytes(rsa->n)大的空间。Padding是采取的加解密方案。PKCS#1中主要提供了两种加密方案，RSAEX- OAEP和PSAES-PKCS1-v1_5（反正就是两种加密过程了，有点复杂，它主要是先对先对需要加密的数据进行了编码，比如RSAES-OAEP 采用EME-OAEP编码，再进行加密或解密）。Openssl中已经编好了编码的函数：

case RSA_PKCS1_PADDING:

    i=RSA_padding_add_PKCS1_type_2(buf,num,from,flen);

#ifndef OPENSSL_NO_SHA

case RSA_PKCS1_OAEP_PADDING:        i=RSA_padding_add_PKCS1_OAEP(buf,num,from,flen,NULL,0);

#endif

case RSA_SSLV23_PADDING:

    i=RSA_padding_add_SSLv23(buf,num,from,flen);

case RSA_NO_PADDING:

    i=RSA_padding_add_none(buf,num,from,flen);

等上面编好码后，就调用BN_mod_exp_mont来进行模幂了。最后得出值，这也就是具体的加密和解密过程。在这里还可以发现，加密时输入的rsa 有两种方式，一是p,q,...为NULL,只有rsa->d,和rsa->n不为空，这样就直接用rsa->d和rsa->n 进行模幂计算，假如p,q.....都不为空的话，他会调用中国剩余定理来进行加密。

7．签名函数
int RSA_sign(int type, unsigned char *m, unsigned int m_len,

    unsigned char *sigret, unsigned int *siglen, RSA *rsa);

int RSA_verify(int type, unsigned char *m, unsigned int m_len,

    unsigned char *sigbuf, unsigned int siglen, RSA *rsa);

其实签名其实和用私钥加密差不多是一回事，所以签名函数最终调用的就是私钥加密的函数，在openssl中这个签名函数很少单独拿出来用的，都是为了给 EVP_SignFinal来调用的。所以假如是利用RSA进行签名的话，RSA_private_encrypt，BN_mod_exp_mont是最基本的，所有的都需要调用他，区别无非就在于在需要签名的信息上做了一下处理（一般将需要签名的信息求取摘要值得到m）

8．写入文件函数
int RSA_print(BIO *bp, RSA *x, int offset);

int RSA_print_fp(FILE *fp, RSA *x, int offset);offset是为了调整输出格式的，随意一个数都可以（例如2，12，16。。）

9．其他
int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);

void RSA_blinding_off(RSA *rsa);

为了防止时间攻击，openssl还在签名的时候产生一个随机因子，附加在私钥上。

int RSA_sign_ASN1_OCTET_STRING(int dummy, unsigned char *m,unsigned int m_len, unsigned char *sigret, unsigned int *siglen,RSA *rsa);

int RSA_verify_ASN1_OCTET_STRING(int dummy, unsigned char *m,unsigned int m_len, unsigned char *sigbuf, unsigned int siglen，RSA *rsa);

用私钥对八元组串进行签名，原理同RSA_sign
Openssl有关大数运算函数介绍- -

主要介绍Openssl中的有关大数运算函数，这个对于以后的RSA研究和实现比较有价值

1．初始化函数

BIGNUM *BN_new(void);    新生成一个BIGNUM结构

void BN_free(BIGNUM *a);   释放一个BIGNUM结构，释放完后a=NULL;

void BN_init(BIGNUM *);    初始化所有项均为0，一般为BN_ init(&c)

void BN_clear(BIGNUM *a); 将a中所有项均赋值为0，但是内存并没有释放

void BN_clear_free(BIGNUM *a); 相当与将BN_free和BN_clear综合，要不就赋值0，要不就释放空间。

2．上下文情景函数，存储计算中的中间过程
BN_CTX *BN_CTX_new(void);申请一个新的上下文结构

void BN_CTX_init(BN_CTX *c);将所有的项赋值为0，一般BN_CTX_init(&c)

void BN_CTX_free(BN_CTX *c);释放上下文结构，释放完后c=NULL;

3．复制以及交换函数
BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);将b复制给a,正确返回a，错误返回NULL

BIGNUM *BN_dup(const BIGNUM *a);新建一个BIGNUM结构，将a复制给新建结构返回，错误返回NULL

BIGNUM *BN_swap(BIGNUM *a, BIGNUM *b);交换a,b

4．取位函数

int BN_num_bytes(const BIGNUM *a);返回a的位数，大量使用

int BN_num_bits(const BIGNUM *a);

int BN_num_bits_word(BN_ULONG w);他返回有意义比特的位数，例如0x00000432 为11。

5．基本计算函数

int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);r=a+b

int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);r=a-b

int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);r=a*b

int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx);r=a*a,效率高于bn_mul(r,a,a)

int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d,

         BN_CTX *ctx);d=a/b,r=a%b

int BN_mod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);r=a%b

int BN_nnmod(BIGNUM *rem, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);r=abs(a%b)

int BN_mod_add(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,

         BN_CTX *ctx);r=abs((a+b)%m))

int BN_mod_sub(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,

         BN_CTX *ctx); r=abs((a-b)%m))

int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m,

         BN_CTX *ctx); r=abs((a*b)%m))

int BN_mod_sqr(BIGNUM *ret, BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); r=abs((a*a)%m))

int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx);r=pow(a,p)

int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p,

         const BIGNUM *m, BN_CTX *ctx); r=pow(a,p)%M

int BN_gcd(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);r=a,b最大公约数

int BN_add_word(BIGNUM *a, BN_ULONG w);

int BN_sub_word(BIGNUM *a, BN_ULONG w);

int BN_mul_word(BIGNUM *a, BN_ULONG w);

BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);

BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);

BIGNUM *BN_mod_inverse(BIGNUM *r, BIGNUM *a, const BIGNUM *n,

           BN_CTX *ctx);模逆，((a*r)%n==1).

6．比较函数
int BN_cmp(BIGNUM *a, BIGNUM *b);   -1 if a < b, 0 if a == b and 1 if a > b.

int BN_ucmp(BIGNUM *a, BIGNUM *b); 比较a,b觉得值，返回值和上同。

int BN_is_zero(BIGNUM *a);

int BN_is_one(BIGNUM *a);

int BN_is_word(BIGNUM *a, BN_ULONG w);

int BN_is_odd(BIGNUM *a);        上面四个返回1，假如条件成立，否则将返回0

7．设置函数
int BN_zero(BIGNUM *a); 设置a为0

int BN_one(BIGNUM *a);   设置a为1

const BIGNUM *BN_value_one(void); 返回一个为1的大数

int BN_set_word(BIGNUM *a, unsigned long w); 设置a为w

unsigned long BN_get_word(BIGNUM *a); 假如a能表示为long型，那么返回一个long型数

8．随机数函数
int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);产生一个加密用的强bits的伪随机数，若top=-1，最高位为0，top=0，最高位为1，top=1,最高位和次高位为1，bottom为真，随机数为偶数

int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);产生一个伪随机数，应用于某些目的。

int BN_rand_range(BIGNUM *rnd, BIGNUM *range);产生的0<rnd<range

int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);同上面道理

9．产生素数函数
BIGNUM *BN_generate_prime(BIGNUM *ret, int bits,int safe, BIGNUM *add,

         BIGNUM *rem, void (*callback)(int, int, void *), void *cb_arg);产生一个bits位的素数，后面几个参数都可以为NULL

int BN_is_prime(const BIGNUM *p, int nchecks,

         void (*callback)(int, int, void *), BN_CTX *ctx, void *cb_arg);

判断是否为素数，返回0表示成功，1表示错误概率小于0。25，-1表示错误

10．位数函数
int BN_set_bit(BIGNUM *a, int n);将a中的第n位设置为1，假如a小于n位将扩展

int BN_clear_bit(BIGNUM *a, int n);将a中的第n为设置为0，假如a小于n位将出错

int BN_is_bit_set(const BIGNUM *a, int n);测试是否已经设置，1表示已设置

int BN_mask_bits(BIGNUM *a, int n);将a截断至n位，假如a小于n位将出错

int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);a左移n位，结果存于r

int BN_lshift1(BIGNUM *r, BIGNUM *a); a左移1位，结果存于r

int BN_rshift(BIGNUM *r, BIGNUM *a, int n); a右移n位，结果存于r

int BN_rshift1(BIGNUM *r, BIGNUM *a); a左移1位，结果存于r

11．与字符串的转换函数
int BN_bn2bin(const BIGNUM *a, unsigned char *to);将abs（a）转化为字符串存入to，to的空间必须大于BN_num_bytes(a)

BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);将s中的len位的正整数转化为大数

char *BN_bn2hex(const BIGNUM *a);转化为16进制字符串

char *BN_bn2dec(const BIGNUM *a);转化为10进制字符串

int BN_hex2bn(BIGNUM **a, const char *str);同上理

int BN_dec2bn(BIGNUM **a, const char *str);同上理

int BN_print(BIO *fp, const BIGNUM *a);将大数16进制形式写入内存中

int BN_print_fp(FILE *fp, const BIGNUM *a); 将大数16进制形式写入文件

int BN_bn2mpi(const BIGNUM *a, unsigned char *to);

BIGNUM *BN_mpi2bn(unsigned char *s, int len, BIGNUM *ret);

12．其他函数
下面函数可以进行更有效率的模乘和模除，假如在重复在同一模下重复进行模乘和模除计算，计算r=(a*b)%m 利用了recp=1/m

BN_RECP_CTX *BN_RECP_CTX_new(void);

void BN_RECP_CTX_init(BN_RECP_CTX *recp);

void BN_RECP_CTX_free(BN_RECP_CTX *recp);

int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *m, BN_CTX *ctx);

int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *a, BIGNUM *b,

BN_RECP_CTX *recp, BN_CTX *ctx);

下面函数采用蒙哥马利算法进行模幂计算，可以提高效率，他也主要应用于在同一模下进行多次幂运算

BN_MONT_CTX *BN_MONT_CTX_new(void);

void BN_MONT_CTX_init(BN_MONT_CTX *ctx);

void BN_MONT_CTX_free(BN_MONT_CTX *mont);

int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *m, BN_CTX *ctx);

BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);

int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,

         BN_MONT_CTX *mont, BN_CTX *ctx);

int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,

         BN_CTX *ctx);

int BN_to_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont,

         BN_CTX *ctx);

基于OpenSSL的程序都要遵循以下几个步骤：

(1 ) OpenSSL初始化
在使用OpenSSL之前，必须进行相应的协议初始化工作，这可以通过下面的函数实现：
int SSL_library_int(void);
(2 ) 选择会话协议
在利用OpenSSL开始SSL会话之前，需要为客户端和服务器制定本次会话采用的协议，目前能够使用的协议包括TLSv1.0、SSLv2、 SSLv3、SSLv2/v3。
需要注意的是，客户端和服务器必须使用相互兼容的协议，否则SSL会话将无法正常进行。
(3 ) 创建会话环境
在OpenSSL中创建的SSL会话环境称为CTX，使用不同的协议会话，其环境也
不一样的。申请SSL会话环境的OpenSSL函数是：
SSL_CTX *SSL_CTX_new(SSL_METHOD * method);
当SSL会话环境申请成功后，还要根据实际的需要设置CTX的属性，通常的设置是指定SSL握手阶段证书的验证方式和加载自己的证书。制定证书验证方式的函数是：
int SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int(*verify_callback),int(X509_STORE_CTX *));
为SSL会话环境加载CA证书的函数是：
SSL_CTX_load_verify_location(SSL_CTX *ctx,const char *Cafile,const char *Capath);
为SSL会话加载用户证书的函数是：
SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file,int type);
为SSL会话加载用户私钥的函数是：
SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx,const char* file,int type);
在将证书和私钥加载到SSL会话环境之后，就可以调用下面的函数来验证私钥和证书是否相符：
int SSL_CTX_check_private_key(SSL_CTX *ctx);
(4) 建立SSL套接字
SSL套接字是建立在普通的TCP套接字基础之上，在建立SSL套接字时可以使用下面的一些函数：
SSL *SSl_new(SSL_CTX *ctx);
//申请一个SSL套接字
int SSL_set_fd(SSL *ssl,int fd);)
//绑定读写套接字
int SSL_set_rfd(SSL *ssl,int fd);
//绑定只读套接字
int SSL_set_wfd(SSL *ssl,int fd);
//绑定只写套接字
(5) 完成SSL握手
在成功创建SSL套接字后，客户端应使用函数SSL_connect( )替代传统的函数connect( )来完成握手过程:
int SSL_connect(SSL *ssl);
而对服务器来讲，则应使用函数SSL_ accept ( )替代传统的函数accept ( )来完成握手过程:
int SSL_accept(SSL *ssl);
握手过程完成之后，通常需要询问通信双方的证书信息，以便进行相应的验证，这可以借助于下面的函数来实现:
X509 *SSL_get_peer_certificate(SSL *ssl);
该函数可以从SSL套接字中提取对方的证书信息，这些信息已经被SSL验证过了。
X509_NAME *X509_get_subject_name(X509 *a);
该函数得到证书所用者的名字。
(6) 进行数据传输
当SSL握手完成之后，就可以进行安全的数据传输了，在数据传输阶段，需要使用SSL_read( )和SSL_write( )来替代传统的read( )和write( )函数，来完成对套接字的读写操作：
int SSL_read(SSL *ssl,void *buf,int num);
int SSL_write(SSL *ssl,const void *buf,int num);
(7 ) 结束SSL通信
当客户端和服务器之间的数据通信完成之后，调用下面的函数来释放已经申请的SSL资源：
int SSL_shutdown(SSL *ssl);
//关闭SSL套接字
void SSl_free(SSL *ssl);
//释放SSL套接字
void SSL_CTX_free(SSL_CTX *ctx);
//释放SSL会话环境