请教一个openssl中aes cbc函数的问题

beyond2004

下面是我从openssl-fips-1.1.1中找到的crypto/aes/aes_cbc.c ，aes 中cbc加密过程是要加如一个初始化向量(参数中的ivec)，同时解密的过程也用到了这个ivec,问题是为什么他的加密过程会有一个

“memcpy(ivec,iv,AES_BLOCK_SIZE);”
这样不仅没有作用，而且把ivec中的内容也破坏了，使他在解密过程中不能用了，如果我理解的不正确，谁能告诉我这个函数加密和解密是怎么使用的？

1. 
   
2. 
   
3. void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
   
4.                      const unsigned long length, const AES_KEY *key,
   
5.                      unsigned char *ivec, const int enc) {
   
6. 
   
7.         unsigned long n;
   
8.         unsigned long len = length;
   
9.         unsigned char tmp[AES_BLOCK_SIZE];
   
10.         const unsigned char *iv = ivec;
    
11. 
    
12.         assert(in && out && key && ivec);
    
13.         assert((AES_ENCRYPT == enc)||(AES_DECRYPT == enc));
    
14. 
    
15.         if (AES_ENCRYPT == enc) {
    
16.                 while (len >= AES_BLOCK_SIZE) {
    
17.                         for(n=0; n < AES_BLOCK_SIZE; ++n)
    
18.                                 out[n] = in[n] ^ iv[n];
    
19.                         AES_encrypt(out, out, key);
    
20.                         iv = out;
    
21.                         len -= AES_BLOCK_SIZE;
    
22.                         in += AES_BLOCK_SIZE;
    
23.                         out += AES_BLOCK_SIZE;
    
24.                 }
    
25.                 if (len) {
    
26.                         for(n=0; n < len; ++n)
    
27.                                 out[n] = in[n] ^ iv[n];
    
28.                         for(n=len; n < AES_BLOCK_SIZE; ++n)
    
29.                                 out[n] = iv[n];
    
30.                         AES_encrypt(out, out, key);
    
31.                         iv = out;
    
32.                 }
    
33.                 memcpy(ivec,iv,AES_BLOCK_SIZE);
    
34.         } else if (in != out) {
    
35.                 while (len >= AES_BLOCK_SIZE) {
    
36.                         AES_decrypt(in, out, key);
    
37.                         for(n=0; n < AES_BLOCK_SIZE; ++n)
    
38.                                 out[n] ^= iv[n];
    
39.                         iv = in;
    
40.                         len -= AES_BLOCK_SIZE;
    
41.                         in  += AES_BLOCK_SIZE;
    
42.                         out += AES_BLOCK_SIZE;
    
43.                 }
    
44.                 if (len) {
    
45.                         AES_decrypt(in,tmp,key);
    
46.                         for(n=0; n < len; ++n)
    
47.                                 out[n] = tmp[n] ^ iv[n];
    
48.                         iv = in;
    
49.                 }
    
50.                 memcpy(ivec,iv,AES_BLOCK_SIZE);
    
51.         } else {
    
52.                 while (len >= AES_BLOCK_SIZE) {
    
53.                         memcpy(tmp, in, AES_BLOCK_SIZE);
    
54.                         AES_decrypt(in, out, key);
    
55.                         for(n=0; n < AES_BLOCK_SIZE; ++n)
    
56.                                 out[n] ^= ivec[n];
    
57.                         memcpy(ivec, tmp, AES_BLOCK_SIZE);
    
58.                         len -= AES_BLOCK_SIZE;
    
59.                         in += AES_BLOCK_SIZE;
    
60.                         out += AES_BLOCK_SIZE;
    
61.                 }
    
62.                 if (len) {
    
63.                         memcpy(tmp, in, AES_BLOCK_SIZE);
    
64.                         AES_decrypt(tmp, out, key);
    
65.                         for(n=0; n < len; ++n)
    
66.                                 out[n] ^= ivec[n];
    
67.                         for(n=len; n < AES_BLOCK_SIZE; ++n)
    
68.                                 out[n] = tmp[n];
    
69.                         memcpy(ivec, tmp, AES_BLOCK_SIZE);
    
70.                 }
    
71.         }
    
72. }
    
73. 
    
74. 
    

复制代码

beyond2004

顶起

langue

ivec[] 必须可写。每一次迭代都会修改 ivec[] 的数据，为下一次迭代做准备，这是 CBC 的特点。
解密前应当重新设置 ivec[]，而不是直接利用原来的值——那是为下一次迭代做准备的 ivec[]

beyond2004

thx,我也看到了他的调用方法，不过这个函数一次可以处理n个16字节的数据,所以我当时迷惑了，呵呵

dennydothuang

3楼正解。你可以查一下WIKI，有关于AES算法的具体解释。
所以，在解密前必须要重新设置该ivec.
每次处理16字节，是因为AES算法本身是block cipher，按照块方式处理的。