C语言实现AES128加密

已于 2023-09-26 21:12:32 修改
阅读量628 收藏 5
点赞数 9
文章标签： c语言 密码学 抽象代数
于 2023-09-26 21:08:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63016521/article/details/133321825
版权

文章目录

  • 前言
  • 一、前提知识
  • 二、具体函数实现
    • 1.xtime函数
    • 2.如何利用xtime实现有限域中的乘法
    • 3.密钥扩展
    • 4.轮密钥加
    • 5.字节代换
    • 6.行移位
    • 7.列混淆
    • 8.整体代码
  • 总结

前言

用C语言实现AES128加密。这里仅仅针对输入的明文和密钥都为16字节的情况。

一、前提知识

1:需要掌握xtime,在有限域中的乘法
2:默认熟悉AES的加密流程
ps:这里简述一下:在有限域中加法就是无符号数的异或操作
乘法操作具体可以参照这篇文章:有限域GF(2^8)内乘法代码实现以及原理-CSDN博客

二、具体函数实现

1.xtime函数

unsigned char XTIME(unsigned char num)
{
    if(num&0x80){
        return (num<<1)^0x1b;

    }else{
        return num<<1;
    }
}

首先判断最高位是否为1，如果不是1就直接左移1位。如果是1，则先左移1位在和0x1b做异或运算。函数的结果即为在有限域中得到了一个数的2倍。xtime的多项式原理即为在有限域中拿x与一个数做乘法。多项式前面的系数即为无符号数对应位置的值，所以x用一个字节表示就是00000010，故函数的结果可以得到一个数在有限域中的2倍。

2.如何利用xtime实现有限域中的乘法 

unsigned char multiply(unsigned char a,unsigned char b)
{
    unsigned char temp[8]={a};
    int i;
    for(i=1;i<8;i++){
        temp[i]=XTIME(temp[i-1]);
    }
    unsigned char res=0x00;
    for(i=0;i<8;i++){
        res=res^(((b<<i)&0x01)*temp[i]);
    }
    return res;
}

通过上面推荐的文章我们可以了解到任何一个在有限域中的数(这里以8位来举例说明)都可以通过0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80相异或得到。而一个数(用函数的a表示)与0x01,0x02,0x04......0x80都可以通过迭代xtime得到。第一个for循环功能即为此。第二个for循环的功能即为将b拆解，看它使用0x01,0x02......0x80中的哪些数异或而来，即将b拆解成0x01,0x02,0x04......0x80异或的形式。而a与这些数的乘积我们在第一个for循环已经得到。因此可以得到有限域中两个数的乘积。

3.密钥扩展

这里是AES128所以密钥扩展需要扩展10次(这里扩展1次等于得到新的4列)
ps:一些变量已在代码中给出,inkey即为初始输入的密钥序列，outkey即为扩展10次后的序列，Nk=4，Nr=10,这两个我基本没用

//密钥扩展
void ScheduleKey(unsigned char *inkey,
    unsigned char *outkey, int Nk, int Nr)
{
    int i,index=4,j,k,t;//index用于指示密钥扩展到哪一列了
    unsigned char temp_4[4];//i-4的那四个字节
    unsigned char temp_1[4];//i-1的那四个字节
    unsigned char temp;
    unsigned char temp_or[4]={0x00};
    unsigned char array[10]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36};
    for(i=0;i<16;i++){
        outkey[i]=inkey[i];
    }
    for(i=0;i<10;i++){//一共10轮
        for(t=0;t<4;t++){//每一轮扩展出来四个字
            if(index%4==0){//
                for(j=0;j<4;j++){
                    temp_4[j]=outkey[(index-4)*4+j];
                    temp_1[j]=outkey[(index-1)*4+j];
                }
                temp=temp_1[0];
                //字循环
                for(k=0;k<4;k++){
                    if(k==3){
                        temp_1[k]=temp;
                    }else{
                        temp_1[k]=temp_1[k+1];
                    }
                }
                //字节代换
                for(k=0;k<4;k++){
                   temp_1[k]=sbox[temp_1[k]];
                }
                //轮常量异或
                temp_or[0]=array[i];
                //最终三个一维矩阵异或
                for(k=0;k<4;k++){
                    outkey[index*4+k]=temp_4[k]^temp_1[k]^temp_or[k];
                }
            }else{
                for(k=0;k<4;k++){
                    outkey[index*4+k]=outkey[(index-4)*4+k]^outkey[(index-1)*4+k];
                }
            }
            index++;
        }
    }
}

首先将inkey直接赋值到outkey当中去，然后开始扩展。若index%4!=0，则直接拿index-4的列和index-1的列相互异或就得到新扩展得到的列。若index%4==0则对于index-1的列需要分三步进行。1:字循环,即将这一列(逆时针旋转90度后)左移一位即可。2：字节代换,即将这一列的值作为地址映射到sbox表中。这里我的sbox是一维的，若你的是二维的需要分别取出高四位和低四位来映射到sbox中。3：轮常量异或,这个矩阵根据轮次来得到。第一轮位[0x10,0x00,0x00,0x00],后三个字节都是0x00，变的只是第一个字节。

4:轮密钥加

/*AddRoundKey 轮密钥加 col初始为明文 key:经过10次扩展的密钥*/
static void AddRoundKey(unsigned char *col,
    unsigned char *key, int round)
{
    int i;
    for(i=0;i<16;i++){
        col[i]=col[i]^key[16*round+i];
    }

}

即为将col(抽象看来是一个4X4矩阵)与对应的轮次的密钥(也是一个4X4矩阵)对应位置做异或操作即可。

5：字节代换

/*SubBytes 字节替换*/
static void SubBytes(unsigned char *col)
{
    int i;
    for(i=0;i<16;i++){
        col[i]=sbox[col[i]];
    }
}

将col这个矩阵对应位置的值映射到sbox即可。

6：行移位

void shift(unsigned char *rol)
{
    unsigned char temp;
    int k;
    temp=rol[0];
    //字循环
    for(k=0;k<4;k++){
        if(k==3){
            rol[k]=temp;
        }else{
            rol[k]=rol[k+1];
        }
    }
}
/*ShiftRows:Shifts the entire block 行移位*/
static void ShiftRows(unsigned char *col)
{
    int i,j,k;
    unsigned char mov[4]={0x00};
    for(i=1;i<=3;i++){//有三行需要移动
        for(k=0;k<4;k++){//选择出来要移动的那一行
            mov[k]=col[i+4*k];
        }
        for(j=0;j<i;j++){//移动的行需要移动几次
            shift(mov);
        }
        for(k=0;k<4;k++){//将移动过后的行重新赋值
            col[i+4*k]=mov[k];
        }
    }
}

col这个矩阵第0行不做操作，第1行向左移动1次，第二行移动2次，第三行移动三次。
shift函数即为向左移动一次。
 

7:列混淆

这里特别注意一下是左乘那个固定的矩阵
 

/*MixColumns: Process the entire block 列混淆*/
static void MixColumns(unsigned char *col)
{
    int i,j,k;
    unsigned char constant[4][4]={{0x02,0x03,0x01,0x01},
                           {0x01,0x02,0x03,0x01},
                           {0x01,0x01,0x02,0x03},
                           {0x03,0x01,0x01,0x02}};
    unsigned char temp[4][4];
    unsigned char res[4][4];
    k=0;
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            temp[j][i]=col[k];
            k++;
        }
    }
    for (i = 0; i < 4; i++) {
            for (j = 0; j < 4; j++) {
                res[i][j]=0x00;
                for (k = 0; k < 4; k++) {
                    res[i][j] =res[i][j]^(multiply(constant[i][k],temp[k][j]));
                }
       }
    }
    k=0;
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            col[k]=res[j][i];
            k++;
        }
    }
}

这里的乘法就要用到步骤二了。
这里我是将col这个一维转化位二维矩阵来和那个固定矩阵来做乘法了，感觉比较方便实现。

8：整体代码

#include <stdio.h>

/*The AES Substitution Table*/
static const unsigned char sbox[256] = {
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
    0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
    0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
    0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
    0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
    0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
    0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
    0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
    0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
    0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
    0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
    0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
    0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
    0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
    0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
    0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
};
//用于计算乘积
unsigned char XTIME(unsigned char x)
{
    if(x&0x80){
        return (x<<1)^0x1b;
    }else{
        return x<<1;
    }
}
unsigned char multiply(unsigned char a,unsigned char b)
{
    unsigned char array[10]={a};
    int i;
    for(i=1;i<8;i++){
        array[i]=XTIME(array[i-1]);
    }
    unsigned char res=0x00;
    for(i=0;i<8;i++){
        res=res^((b>>i)&0x01)*array[i];
    }
    return res;
}
/*SubBytes 字节替换*/
static void SubBytes(unsigned char *col)
{
    int i;
    for(i=0;i<16;i++){
        col[i]=sbox[col[i]];
    }
}
void shift(unsigned char *rol)
{
    unsigned char temp;
    int k;
    temp=rol[0];
    //字循环
    for(k=0;k<4;k++){
        if(k==3){
            rol[k]=temp;
        }else{
            rol[k]=rol[k+1];
        }
    }
}
/*ShiftRows:Shifts the entire block 行移位*/
static void ShiftRows(unsigned char *col)
{
    int i,j,k;
    unsigned char mov[4]={0x00};
    for(i=1;i<=3;i++){//有三行需要移动
        for(k=0;k<4;k++){//选择出来要移动的那一行
            mov[k]=col[i+4*k];
        }
        for(j=0;j<i;j++){//移动的行需要移动几次
            shift(mov);
        }
        for(k=0;k<4;k++){//将移动过后的行重新赋值
            col[i+4*k]=mov[k];
        }
    }
}

/*MixColumns: Process the entire block 列混淆*/
static void MixColumns(unsigned char *col)
{
    int i,j,k;
    unsigned char constant[4][4]={{0x02,0x03,0x01,0x01},
                           {0x01,0x02,0x03,0x01},
                           {0x01,0x01,0x02,0x03},
                           {0x03,0x01,0x01,0x02}};
    unsigned char temp[4][4];
    unsigned char res[4][4];
    k=0;
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            temp[j][i]=col[k];
            k++;
        }
    }
    for (i = 0; i < 4; i++) {
            for (j = 0; j < 4; j++) {
                res[i][j]=0x00;
                for (k = 0; k < 4; k++) {
                    res[i][j] =res[i][j]^(multiply(constant[i][k],temp[k][j]));
                }
       }
    }
    k=0;
    for(i=0;i<4;i++){
        for(j=0;j<4;j++){
            col[k]=res[j][i];
            k++;
        }
    }
}

/*AddRoundKey 轮密钥加 col初始为明文 key:已经扩展的密钥*/
static void AddRoundKey(unsigned char *col,
    unsigned char *key, int round)
{
    int i;
    for(i=0;i<16;i++){
        col[i]=col[i]^key[16*round+i];
    }

}
/*Encrypt a single block with Nr Rounds(10,12,14)*/
void AesEncrypt(unsigned char *blk, unsigned char *key, int Nr)
{
    int x;
    AddRoundKey(blk, key, 0);
    for (x = 1; x <= (Nr - 1); x++){
        SubBytes(blk);
        ShiftRows(blk);
        MixColumns(blk);
        AddRoundKey(blk, key, x);
    }
    SubBytes(blk);
    ShiftRows(blk);
    AddRoundKey(blk, key, Nr);
}

//密钥扩展
void ScheduleKey(unsigned char *inkey,
    unsigned char *outkey, int Nk, int Nr)
{
    int i,index=4,j,k,t;//index用于指示密钥扩展到哪一列了
    unsigned char temp_4[4];//i-4的那四个字节
    unsigned char temp_1[4];//i-1的那四个字节
    unsigned char temp;
    unsigned char temp_or[4]={0x00};
    unsigned char array[10]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36};
    for(i=0;i<16;i++){
        outkey[i]=inkey[i];
    }
    for(i=0;i<10;i++){//一共10轮
        for(t=0;t<4;t++){//每一轮扩展出来四个字
            if(index%4==0){//
                for(j=0;j<4;j++){
                    temp_4[j]=outkey[(index-4)*4+j];
                    temp_1[j]=outkey[(index-1)*4+j];
                }
                temp=temp_1[0];
                //字循环
                for(k=0;k<4;k++){
                    if(k==3){
                        temp_1[k]=temp;
                    }else{
                        temp_1[k]=temp_1[k+1];
                    }
                }
                //字节代换
                for(k=0;k<4;k++){
                   temp_1[k]=sbox[temp_1[k]];
                }
                //轮常量异或
                temp_or[0]=array[i];
                //最终三个一维矩阵异或
                for(k=0;k<4;k++){
                    outkey[index*4+k]=temp_4[k]^temp_1[k]^temp_or[k];
                }
            }else{
                for(k=0;k<4;k++){
                    outkey[index*4+k]=outkey[(index-4)*4+k]^outkey[(index-1)*4+k];
                }
            }
            index++;
        }
    }
}

void main(void){
    unsigned char pt[17],key[17];
    unsigned char skey[15 * 16];
    int i;
    scanf("%s", pt);
    scanf("%s", key);
    ScheduleKey(key, skey, 4, 10);
    AesEncrypt(pt, skey, 10);
    for (i = 0; i < 16; i++) {
        printf("%02x ", pt[i]);
    }

}

9:测试结果

输入：zhang123456789ab zhang123456789ab
输出：af 2b db 30 57 88 7d 0c 38 10 6b 43 75 45 7b 80

输入：python123456789a ba987654321zhang
输出：10 db af 84 8e b8 23 ff 4a 55 e4 bd 3a b4 8a 1a

总结

博客排版熟悉中。
可能存在错误，欢迎指出。若有更优解，请@我。
希望这篇文章可以帮助到你，随缘更新。

打不过你菜菜
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AES128 C语言实现源码及应用例程
03-18
AES128 C语言实现源码及应用例程，可用于通信等场合数据加密 AES128 C语言实现源码及应用例程，可用于通信等场合数据加密
AES128/192/256 C语言实现AES加密/解密,实测可用
08-04
aes.c aes.h test.c 本人实测可以使用，基于C的AES算法代码，希望能帮到有需要的。以下是相关模式调用的函数。 void AES_init_ctx(struct AES_ctx* ctx, const uint8_t* key); void AES_init_ctx_iv(struct AES_ctx* ctx, const uint8_t* key, const uint8_t* iv); void AES_ctx_set_iv(struct AES_ctx* ctx, const uint8_t* iv); void AES_ECB_encrypt(const struct AES_ctx* ctx, uint8_t* buf); void AES_ECB_decrypt(const struct AES_ctx* ctx, uint8_t* buf); void AES_CBC_encrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length); void AES_CBC_decrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length); void AES_CTR_xcrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, uint32_t length);
AES128算法c语言实现
loglingyy的博客
03-14 1960
/ nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。// 输入参数： pPlainText -- 明文，即需加密的数据，其长度为nDataLen字节。
【图像加密】基于对称密钥加密技术AES-128实现图像加密和解密附matlab代码
m0_57702748的博客
02-23 905
本文介绍了一种基于对称密钥加密技术AES-128的图像加密和解密方法。该方法利用AES-128算法的强大加密能力，对图像像素数据进行加密处理，实现图像数据的安全存储和传输。AES-128是一种对称密钥加密算法，由美国国家标准与技术研究院（NIST）于2001年发布。它是一种分组密码，使用128位密钥对128位数据块进行加密和解密。AES-128算法具有高安全性、高效率和易于实现等优点，广泛应用于各种加密场景中。
c 语言常用的加密算法——AES加密算法
A185822153的专栏
12-06 1427
在这个示例中，我们使用了AES的CBC模式进行加密。加密密钥和初始向量都是16字节长度的字符串。待加密的数据是一个字符串，我们将其长度传递给。在C语言中，可以使用openssl库来实现AES加密算法。下面是一个简单的示例代码，演示如何使用openssl库进行AES加密和解密。以上这些算法在C语言中实现时，通常会使用到openssl这样的第三方库，因为这些库已经实现了这些算法的高效实现，直接使用。数组中，其长度为原始数据的长度加上一个块的大小（16字节）。加密后，我们输出加密数据的16进制格式。
AES128加密算法完整实现
热门推荐
u013605322的博客
02-26 6万+
概述 原本想把自己AES加密算法的整个实现过程给详细复述下来，分享给想学习的同学，也方便自己复习，但后来发现该工作量太大，加上作业太多没有过多的时间去写。所以就想把自己在学习的过程中多遇到的好的文章进行汇总，避免重复性的工作，因为我感觉有的文章的介绍和配图写的非常好，再次重复也没有意义。本文里我会将文章的链接附上，如有侵权，敬请告知！ 因为最近要完成课程作业，实现AES128加解密...
C语言 AES128 加密
04-13
C语言 MCU用的AES128加密
密码学_AES加密算法
qq_40442137的博客
12-29 4000
主要学习AES的加密过程
AES128加密解密
好好学习
11-17 2366
aes128加密解密算法
AES算法描述
m0_74043383的博客
02-06 1711
AES-128使用128bits加密128bits的明文分组，数据和密钥均用一个4×4的字节矩阵表示。AES是一个密钥迭代型密码算法，这意味着轮变换将会反复应用于状态，AES计算采用了10轮迭代，每一轮迭代使用一个轮密钥，轮密钥由密钥扩展算法产生。解密过程的工作原理与加密过程的工作原理类似，但是，解密过程必须以与加密过程相反的顺序应用各轮密钥，且使用轮变换的逆变换。
AES（128bit十六进制的加密）
qq_45031509的博客
06-11 6962
AES加密算法的实现过程
AES-128.rar_AES-128实现_AES128 C语言_AES用C++_C语言；单片机_aes128
07-13
用c语言实现得AES128加密，亲测可用，欢迎各位前来下载
AES-128加密解密源码及算法详解。
09-24
一份非常不错的AES加密解密原理及算法学习的资料。所附源码经本人实测，完全无误。并且可移植性强，可移植到任意平台运行，从而为系统添加AES加密解密的功能。
128位AES加密算法C语言实现
11-26
用C语言实现的128位AES加密算法，可以运行在JAVA的JNI 中AIS加密算法c语言实现代码 nt cnt for(ent =0: cnt< 8: cnt++) BvtcToBit(*(ch+cnt), bit+(ent<<3)) return /将二进制位串转为长度为8的字符串水 ...
AES-128加密算法，C语言实现
04-25
该文件是AES加密算法C语言的实现，在STM32平台验证通过，ECB加密方式，方便移植。
基于C语言实现的aes256加密算法示例
12-31
本文实例讲述了基于C语言实现的aes256加密算法。分享给大家供大家参考，具体如下： aes256.h： #ifndef uint8_t #define uint8_t unsigned char #endif #ifdef __cplusplus extern C { #endif typedef struct { ...
STM32单片机C语言模块化编程实战：按键控制LED灯详解与示例
最新发布
jmlinux的博客
04-22 882
​ 之前介绍了很多关于点灯的方法，比如轮询、定时器中断、PWM、按键点灯等方式，这些文章使用的编程方法都不是模块化分层的编写方式，往往会导致代码可读性差、重用性差、扩展性差以及测试和维护困难等问题。为了避免这些问题，我们实际工作中通常会采用模块化分层的编写方法，这样可以确保代码结构清晰、功能明确，提高代码的可读性和可维护性，同时降低功能之间的耦合度，增强代码的重用性（无论是STM32F103还是STM32F407或是STM32H系列等，直接将文件复制使用）和扩展性。模块化分层的编写方式还有助于实现代码的并行
第十四届蓝桥杯省赛C/C++大学B组真题-飞机降落
小蒋的博客
04-20 1748
思路：根据数据范围N
c语言实现 aes-128 cbc 加密
06-07
好的，下面是示例代码，使用 OpenSSL 库进行 AES-CBC 加密和解密： 加密： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <openssl/aes.h> void aes_encrypt_cbc(const unsigned char *plaintext, int plaintext_len, const unsigned char *key, const unsigned char *iv, unsigned char *ciphertext) { AES_KEY aes_key; AES_set_encrypt_key(key, 128, &aes_key); AES_cbc_encrypt(plaintext, ciphertext, plaintext_len, &aes_key, iv, AES_ENCRYPT); } int main() { const unsigned char *plaintext = (const unsigned char *)"待加密的明文"; const unsigned char *key = (const unsigned char *)"密钥"; const unsigned char *iv = (const unsigned char *)"初始化向量"; unsigned char ciphertext[AES_BLOCK_SIZE * ((strlen((const char *)plaintext) + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE)]; memset(ciphertext, 0, sizeof(ciphertext)); aes_encrypt_cbc(plaintext, strlen((const char *)plaintext), key, iv, ciphertext); printf("加密结果："); for (int i = 0; i < sizeof(ciphertext); i++) { printf("%02x", ciphertext[i]); } printf("\n"); return 0; } ``` 解密： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <openssl/aes.h> void aes_decrypt_cbc(const unsigned char *ciphertext, int ciphertext_len, const unsigned char *key, const unsigned char *iv, unsigned char *plaintext) { AES_KEY aes_key; AES_set_decrypt_key(key, 128, &aes_key); AES_cbc_encrypt(ciphertext, plaintext, ciphertext_len, &aes_key, iv, AES_DECRYPT); } int main() { const unsigned char *ciphertext = (const unsigned char *)"待解密的密文"; const unsigned char *key = (const unsigned char *)"密钥"; const unsigned char *iv = (const unsigned char *)"初始化向量"; unsigned char plaintext[AES_BLOCK_SIZE * ((strlen((const char *)ciphertext) + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE)]; memset(plaintext, 0, sizeof(plaintext)); aes_decrypt_cbc(ciphertext, strlen((const char *)ciphertext), key, iv, plaintext); printf("解密结果：%s\n", plaintext); return 0; } ``` 需要注意的是，以上代码使用的是 CBC 模式和 PKCS7 填充方式。同时，需要在编译时链接 OpenSSL 库，可以使用以下命令进行编译： ``` gcc aes_cbc_encrypt.c -o aes_cbc_encrypt -lcrypto gcc aes_cbc_decrypt.c -o aes_cbc_decrypt -lcrypto ``` 其中，`-lcrypto` 参数表示链接 OpenSSL 库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值