OpenSSL 中 RSA 加密解密实现源代码分析

1、RSA 公钥和私钥的组成。以及加密和解密的公式：

2、模指数运算：

先做指数运算，再做模运算。如 5^3 mod 7 = 125 mod 7 = 6

3、RSA加密算法流程：

1. 选择一对不同的、而且足够大的素数 p 和 q
2. 计算 n = p * q
3. 计算欧拉函数 f(n) = (p-1) * (q-1)，p 和 q 须要保密
4. 寻找与 f(n) 互质的数 e。而且 1 < e < f(n)
5. 计算 d，使得 d * e ≡ 1 mod f(n)
6. 公钥 KU = (e , n)   私钥 KR = (d , n)
7. 加密时，将明文变换成 0 ~ n-1 的一个整数 M。明文较长能够切割。设密文为 C，则加密过程是：C ≡ M^e mod n
8. 解密时，M ≡ C^d mod n

当中 ≡ 表示同余，就是符号两边模运算结果同样。

由于符号右边结果恒为 1

所以要找到符合条件的 d 使得 d * e mod f(n) = 1

4、OpenSSL中RSA加密解密实现

（1）BN_MONT_CTX

/* Used for montgomery multiplication */
struct bn_mont_ctx_st
     {
     int ri;              /* number of bits in R */
     BIGNUM RR;           /* used to convert to montgomery form */
     BIGNUM N;            /* The modulus */
     BIGNUM Ni;           /* R*(1/R mod N) - N*Ni = 1
                           * (Ni is only stored for bignum algorithm) */
     BN_ULONG n0[2];      /* least significant word(s) of Ni;
                                      (type changed with 0.9.9, was "BN_ULONG n0;" before) */
     int flags;
     };

（2）BIGNUM

struct bignum_st

     {

     BN_ULONG *d;     /* Pointer to an array of 'BN_BITS2' bit chunks. */

     int top;                 /* Index of last used d +1. */

                                  /* The next are internal book keeping for bn_expand. */

     int dmax;             /* Size of the d array. */

     int neg;                /* one if the number is negative */

     int flags;

     };

d：BN_ULONG (应系统而异，win32 下为4 个字节) 数组指针首地址，大数就存放在这里面，只是是倒放的。

比方。用户要存放的大数为 12345678000（通过BN_bin2bn 放入）。则d 的内容例如以下： 0x30
0x30 0x30 0x38 0x37 0x36 0x35 0x34 0x33 0x32 0x31 ；（注意这里是以ASCII码存放的。他是字符转 bignum ）

top：用来指明大数占多少个 BN_ULONG 空间，上例中top 为 3。

dmax：d 数组的大小。

neg：是否为负数。假设为1，则是负数，为 0。则为正数。

flags：用于存放一些标记，比方 flags 含有BN_FLG_STATIC_DATA 时。表明d 的内存

是静态分配的。含有 BN_FLG_MALLOCED 时。d 的内存是动态分配的。

（3）RSA

struct rsa_st

     {

     /* The first parameter is used to pickup errors where

     * this is passed instead of aEVP_PKEY, it is set to 0 */

    

     int pad;

     long version;



/*此处的 method 方法指针比較重要，通过指向不同的函数，能够调用自定义的处理函数，也就是这个指针指向各种运算函数的地址*/

     const RSA_METHOD *meth;

     /* functional reference if 'meth' is ENGINE-provided */

     ENGINE *engine;

     BIGNUM *n;

     BIGNUM *e;

     BIGNUM *d;

     BIGNUM *p;

     BIGNUM *q;

     BIGNUM *dmp1;

     BIGNUM *dmq1;

     BIGNUM *iqmp;

     /* be careful using this if the RSA structure is shared */

     CRYPTO_EX_DATA ex_data;

     int references;

     int flags;



     /* Used to cache montgomery values */

     BN_MONT_CTX *_method_mod_n;

     BN_MONT_CTX *_method_mod_p;

     BN_MONT_CTX *_method_mod_q;



     /* all BIGNUM values are actually in the following data, if it is not NULL */

     char *bignum_data;

     BN_BLINDING *blinding;

     BN_BLINDING *mt_blinding;

     };

（4）RSA_METHOD

struct rsa_meth_st

     {

     const char *name;

/*与（6）中RSA_eay_public_encrypt函数相应*/

     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,

                                       BN_CTX *ctx);           /* Can be null */

/*与（6）中BN_mod_exp_mont 函数相应*/

     int (*bn_mod_exp)(BIGNUM *r,

                                    const BIGNUM *a, const BIGNUM *p,

                                    const BIGNUM *m, BN_CTX *ctx,

                                    BN_MONT_CTX *m_ctx);      /* Can be null */



     int (*init)(RSA *rsa);          /* called at new */

     int (*finish)(RSA *rsa);      /* called at free */

     int flags;                             /* RSA_METHOD_FLAG_* things */

     char *app_data;                 /* may be needed! */



/* New sign and verify functions: some libraries don't allow arbitrary data

*   to be signed/verified: this allows them to be used. Note: for this to work

*   the RSA_public_decrypt() and RSA_private_encrypt() should *NOT* be used

*   RSA_sign(), RSA_verify() should be used instead. Note: for backwards

*   compatibility this functionality is only enabled if the RSA_FLAG_SIGN_VER

*   option is set in 'flags'.

*/

     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,

                                const unsigned char *sigbuf,

                                unsigned int siglen,

                                const RSA *rsa);



/* If this callback is NULL, the builtin software RSA key-gen will be used. This

*   is for behavioural compatibility whilst the code gets rewired, but one day

*   it would be nice to assume there are no such things as "builtin software"

*   implementations. */

     int (*rsa_keygen)(RSA *rsa,

                                   int bits,

                                   BIGNUM *e,

                                   BN_GENCB *cb);

     };

用户可实现自己的 RSA_METHOD 来替换openssl 提供的默认方法。

（5）rsa_crpt.c 详细实现了下面几个函数

int     RSA_public_encrypt(int flen,

                                           const unsigned char *from,

                                           unsigned char *to,

                                           RSA *rsa,

                                           int padding);



int     RSA_private_encrypt(int flen,

                                      const unsigned char *from,

                                      unsigned char *to,

                                      RSA *rsa,

                                      int padding);



int     RSA_public_decrypt(int flen,

                                    const unsigned char *from,

                                    unsigned char *to,

                                    RSA *rsa,

                                    int padding);



int     RSA_private_decrypt(int flen,

                                      const unsigned char *from,

                                      unsigned char *to,

                                      RSA *rsa,

                                      int padding);



RSA_public_encrypt 函数体内部，真正调用的是例如以下函数：



return(rsa->meth->rsa_pub_enc(flen, from, to, rsa, padding));



也就是 RSA_public_encrypt 调用的是（4）中 rsa_pub_enc 这个函数。





在 rsa.h中有例如以下说明：

/* these are the actual SSLeay RSA functions */

const RSA_METHOD *RSA_PKCS1_SSLeay(void);



const RSA_METHOD *RSA_null_method(void);

（6）rsa_esy.c 中有例如以下定义：

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,         /* signature verification */

     RSA_eay_private_encrypt,       /* signing */

     RSA_eay_private_decrypt,

     RSA_eay_mod_exp,

     BN_mod_exp_mont,              /* XXX probably we should not use Montgomery if  e == 3 */

     RSA_eay_init,

     RSA_eay_finish,

     0, /* flags */

     NULL,

     0,                                               /* rsa_sign */

     0,                                               /* rsa_verify */

     NULL                                         /* rsa_keygen */

     };

 这个结构体完毕了函数地址映射的功能。如：

 RSA_public_encrypt 终于调用的是 RSA_eay_public_encrypt 这个函数

 bn_mod_exp 终于调用的是 BN_mod_exp_mont这个函数

（7）RSA_eay_public_encrypt 在 rsa_esy.c 中实现

static int RSA_eay_public_encrypt(int flen,

                                                         const unsigned char *from,

                                                         unsigned char *to,

                                                         RSA *rsa,

                                                         int padding)

     {

 ..............

/*核心调用在此。事实上调用的是（6）中 BN_mod_exp_mont 函数*/

     if (!rsa->meth->bn_mod_exp(ret,f,rsa->e,rsa->n,ctx,

          rsa->_method_mod_n)) goto err;



 ..............

     }

（8）BN_mod_exp_mont 在 bn_exp.c 中实现

int BN_mod_exp_mont(BIGNUM *rr,

                                       const BIGNUM *a,

                                       const BIGNUM *p,

                                       const BIGNUM *m,

                                       BN_CTX *ctx,

                                       BN_MONT_CTX *in_mont)

     {

    ..........

     if (!BN_to_montgomery(val[0],aa,mont,ctx)) goto err; /* 1 */



     window = BN_window_bits_for_exponent_size(bits);

     if (window > 1)

          {

          if (!BN_mod_mul_montgomery(d,val[0],val[0],mont,ctx)) goto err; /* 2 */

          j=1<<(window-1);

          for (i=1; i<j; i++)

               {

               if(((val[i] = BN_CTX_get(ctx)) == NULL) ||

                         !BN_mod_mul_montgomery(val[i],val[i-1],

                              d,mont,ctx))

                    goto err;

               }

          }



     ..........

     }

BN_mod_exp_mont 调用 BN_mod_mul_montgomery 函数实现了核心功能

（9）BN_mod_mul_montgomery 在 bn_mont.c 中实现

int BN_mod_mul_montgomery(BIGNUM *r,

                                                   const BIGNUM *a,

                                                   const BIGNUM *b,

                                                   BN_MONT_CTX *mont,

                                                   BN_CTX *ctx)

     {

..........



     if (num>1 && a->top==num && b->top==num)

          {

          if (bn_wexpand(r,num) == NULL) return(0);

          if (bn_mul_mont(r->d,a->d,b->d,mont->N.d,mont->n0,num))

               {

               r->neg = a->neg^b->neg;

               r->top = num;

               bn_correct_top(r);

               return(1);

               }

          }

..........

     }

BN_mod_mul_montgomery 调用 bn_mul_mont 函数实现了核心功能

（10）bn_mul_mont 在 bn_asm.c 中实现，即实现蒙哥马利模乘

例如以下是 bn_mul_mont 函数的详细实现：



int bn_mul_mont(BN_ULONG *rp,

                             const BN_ULONG *ap,

                             const BN_ULONG *bp,

                             const BN_ULONG *np,

                             const BN_ULONG *n0p,

                             int num)

     {

     BN_ULONG c0,c1,*tp,n0=*n0p;

     volatile BN_ULONG *vp;

     int i=0,j;



     vp = tp = alloca((num+2)*sizeof(BN_ULONG));



     for(i=0;i<=num;i++)     tp[i]=0;



     for(i=0;i<num;i++)

          {

/* t = a * b */

          c0         = bn_mul_add_words(tp,ap,num,bp[i]);

          c1         = (tp[num] + c0)&BN_MASK2;

          tp[num]    = c1;

          tp[num+1]  = (c1<c0?1:0);



/* u = (t + (t*n0 mod r) * n) / r */

          c0         = bn_mul_add_words(tp,np,num,tp[0]*n0);

          c1         = (tp[num] + c0)&BN_MASK2;

          tp[num]    = c1;

          tp[num+1] += (c1<c0?

1:0);



          for(j=0;j<=num;j++)     tp[j]=tp[j+1];

          }



/* return u>=n ? u-n : u */

     if (tp[num]!=0 || tp[num-1]>=np[num-1])

          {

          c0 = bn_sub_words(rp,tp,np,num);

          if (tp[num]!=0 || c0==0)

               {

               for(i=0;i<num+2;i++)     vp[i] = 0;

               return 1;

               }

          }



     for(i=0;i<num;i++)     rp[i] = tp[i],     vp[i] = 0;

     vp[num]   = 0;

     vp[num+1] = 0;

     return 1;

     }

bn_mul_add_words 在 bn_asm.c 中定义实现。能够通过例如以下部分代码知道详细的实现方法：

num  -->  表示大数占用的 BN_ULONG 的个数，也就是 BIGNUM 中的 top 成员

rp     -->  表示输出结果的指针

ap    -->  表示输入大数的指针

w     -->  表示输入word

c1    -->  表示输出进位



BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w)

     {

......

while (num)

          {

          mul_add(rp[0],ap[0],w,c1);

          ap++; rp++; num--;

          }

......

     }



bn_mul_add_words 函数实现了将一个大数 ap 与字 w 乘累加，而且得到结果保存到大数 rp ,进位保存到 c1 中。

实现了例如以下表达式：



(c1, rp) = ap * w + rp + c1



乘法的实现方式例如以下：

bn_sub_words 在 bn_asm.c 中定义实现。能够通过例如以下部分代码知道详细的实现方法：

n      -->  表示大数占用的 BN_ULONG 的个数，也就是 BIGNUM 中的 top 成员

a      -->  表示输入被减数

b      -->  表示输入减数

c      -->  表示输出借位

BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)

        {

......

while (n)

          {

          t1=a[0]; t2=b[0];

          r[0]=(t1-t2-c)&BN_MASK2;

          if (t1 != t2) c=(t1 < t2);

          a++; b++; r++; n--;

          }

......

       }

实现了两个大数 a 和 b 的减法运算，当中 c 是借位。实现例如以下表达式：

(r, c) = a - b

bn_lcl.h 中定义了例如以下几个宏：实现乘累加运算

#define Lw(t)     (((BN_ULONG)(t))&BN_MASK2)

#define Hw(t)    (((BN_ULONG)((t)>>BN_BITS2))&BN_MASK2)



#define mul_add(r,a,w,c) { \

     BN_ULLONG t; \

     t=(BN_ULLONG)w * (a) + (r) + (c); \

     (r)= Lw(t); \

     (c)= Hw(t); \

     }



mul_add 函数实现了乘累加的功能。实现例如以下的表达式：



(c, r) = a * w + r + c