C语言实现AES128解密-法2

最新推荐文章于 2024-08-02 11:02:50 发布
最新推荐文章于 2024-08-02 11:02:50 发布
阅读量1.8k 收藏 9
点赞数 1
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63016521/article/details/133345677
版权

目录

前言

用C语言实现AES128加密可以翻看往期文章AES128加密解密的流程图见下图​

一、方法2与方法1的等价思想

在加密方法中轮结构为：字节代换------->行移位-------->列混淆----->轮密钥加在解密方法1中轮结构为:逆向行移位->逆向字节代换->轮密钥加->逆向列混淆在解密方法2中轮结构为:逆向字节代换->逆向行移位->逆向列混淆->轮密钥加(轮密钥加之前要先做子密钥列混淆)我们不难发现在解密方法2中轮结构与加密方法的轮结构大致一致了。法2与法1等价的原因:1:（逆向行移位->逆向字节代换）与（逆向字节代换->逆向行移位）效果等价说人话就是:你先移动在替换和你先替换在移动效果是一样的呀。2:（轮密钥加->逆向列混淆）与（先:逆向列混淆 在:子密钥列混淆）->轮密钥加等价不妨设子密钥为a，常量矩阵为c，col矩阵为b则（轮密钥加->逆向列混淆）=c*(a⊕b)=(c*a)⊕(c*b)(先:逆向列混淆 在:子密钥列混淆）->轮密钥加 =(c*b)⊕(c*a)这就是方法2的由来​编辑

​编辑

二、具体函数

1.解密算法总体流程

2.轮密钥列混淆

其实就是拿子密钥矩阵左乘常量矩阵。

3.其他

除了轮密钥列混淆函数外，法2所用的其他函数与法1均相同这里就不再赘述，具体见法1或者整体代码,特别注意一下轮次的值。

4.整体代码

5.测试结果

输入：zhang123456789ab zhang123456789ab输出：Plaintext is: zhang123456789ab

输入：python123456789a ba987654321zhang输出：Plaintext is: python123456789a

6.总结

文章可能存在错误，欢迎指出。希望这篇文章能够对你有所帮助

前言

用C语言实现AES128加密可以翻看往期文章
AES128加密解密的流程图见下图

一、方法2与方法1的等价思想

在加密方法中轮结构为：字节代换------->行移位-------->列混淆----->轮密钥加
在解密方法1中轮结构为:逆向行移位->逆向字节代换->轮密钥加->逆向列混淆
在解密方法2中轮结构为:逆向字节代换->逆向行移位->逆向列混淆->轮密钥加(轮密钥加之前要先做子密钥列混淆)
我们不难发现在解密方法2中轮结构与加密方法的轮结构大致一致了。
法2与法1等价的原因:
1:（逆向行移位->逆向字节代换）与（逆向字节代换->逆向行移位）效果等价
说人话就是:你先移动在替换和你先替换在移动效果是一样的呀。
2:（轮密钥加->逆向列混淆）与（先:逆向列混淆 在:子密钥列混淆）->轮密钥加等价
不妨设子密钥为a，常量矩阵为c，col矩阵为b
则（轮密钥加->逆向列混淆）=c*(a⊕b)=(c*a)⊕(c*b)
(先:逆向列混淆 在:子密钥列混淆）->轮密钥加 =(c*b)⊕(c*a)
这就是方法2的由来



 

二、具体函数

1.解密算法总体流程

void AesDecrypt2(unsigned char *blk, unsigned char *key, int Nr)
{
    int x;
    AddRoundKey(blk, key, Nr);//Nr=10
    for (x = Nr - 1; x >= 1; x--){
        InvSubBytes(blk);//逆向字节代换
        InvShiftRows(blk);//逆向行移位
        InvMixColumns(blk);//逆向列混淆
        InvMixColumnsKey(key, x * 16);
        //轮密钥列混淆
        AddRoundKey(blk, key, x);//轮密钥加
    }
    InvSubBytes(blk);
    InvShiftRows(blk);
    AddRoundKey(blk, key, 0);
}

2.轮密钥列混淆

/*轮密钥列混淆 这里的col是key->密钥扩展 r=16*x*/
static void InvMixColumnsKey(unsigned char *col, int r)
{
    int i,j,k;
    unsigned char constant[4][4]={
        {0x0e,0x0b,0x0d,0x09},
        {0x09,0x0e,0x0b,0x0d},
        {0x0d,0x09,0x0e,0x0b},
        {0x0b,0x0d,0x09,0x0e}
    };
    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[r+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[r+k]=res[j][i];
            k++;
        }
    }
}

其实就是拿子密钥矩阵左乘常量矩阵。

3.其他

除了轮密钥列混淆函数外，法2所用的其他函数与法1均相同这里就不再赘述，具体见法1或者整体代码,特别注意一下轮次的值。

4.整体代码

#include <stdio.h>
# include <stdlib.h>
# include <string.h>
/*aes_small.c*/
/*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,
};

/*解密S盒*/
static const unsigned char invsbox[256] = {
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};
//用于计算乘积
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]];
    }
}
/*解密 逆字节替换*/
static void InvSubBytes(unsigned char *col)
{
    int i;
    for(i=0;i<16;i++){
        col[i]=invsbox[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*/
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];
        }
    }
}
void shift_r(unsigned char *col)
{
    unsigned char temp=col[3];
    int i;
    for(i=3;i>=0;i--){
        if(i==0){
            col[i]=temp;
        }else{
            col[i]=col[i-1];
        }
    }
}
/*解密 逆行位移*/
static void InvShiftRows(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[4*k+i];
        }
        for(j=0;j<i;j++){
            shift_r(mov);
        }
        for(k=0;k<4;k++){
            col[4*k+i]=mov[k];
        }
    }
}

/*加密 列混淆 MixColumns*/
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++;
        }
    }
}
/*解密 逆列混淆*/
static void InvMixColumns(unsigned char *col)
{
    int i,j,k;
    unsigned char constant[4][4]={
        {0x0e,0x0b,0x0d,0x09},
        {0x09,0x0e,0x0b,0x0d},
        {0x0d,0x09,0x0e,0x0b},
        {0x0b,0x0d,0x09,0x0e}
    };
    unsigned char temp[4][4];
    unsigned char res[4][4];
    k=0;
    for(i=0;i<4;i++){//将col转化为二维矩阵
        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*/
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是key->密钥扩展 r=16*x*/
static void InvMixColumnsKey(unsigned char *col, int r)
{
    int i,j,k;
    unsigned char constant[4][4]={
        {0x0e,0x0b,0x0d,0x09},
        {0x09,0x0e,0x0b,0x0d},
        {0x0d,0x09,0x0e,0x0b},
        {0x0b,0x0d,0x09,0x0e}
    };
    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[r+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[r+k]=res[j][i];
            k++;
        }
    }
}
/*Encrypt*/
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 AesDecrypt2(unsigned char *blk, unsigned char *key, int Nr)
{
    int x;
    AddRoundKey(blk, key, Nr);//Nr=10
    for (x = Nr - 1; x >= 1; x--){
        InvSubBytes(blk);//逆向字节代换
        InvShiftRows(blk);//逆向行移位
        InvMixColumns(blk);//逆向列混淆
        InvMixColumnsKey(key, x * 16);
        //轮密钥列混淆
        AddRoundKey(blk, key, x);//轮密钥加
    }
    InvSubBytes(blk);
    InvShiftRows(blk);
    AddRoundKey(blk, key, 0);
}

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

5.测试结果

输入：zhang123456789ab zhang123456789ab
输出：Plaintext is: zhang123456789ab

输入：python123456789a ba987654321zhang
输出：Plaintext is: python123456789a

6.总结

文章可能存在错误，欢迎指出。
希望这篇文章能够对你有所帮助。

打不过你菜菜
关注
AES128加密，解密，源码
12-08
AES128加密解密算法，及应用例程，支持CBC,ECB加密方式。 int main(void) { test_encrypt_cbc(); test_decrypt_cbc(); test_decrypt_ecb(); test_encrypt_ecb(); mytest_test_cbc(); getchar(); return 0; }
AES128加密解密
好好学习
11-17 3305
aes128加密解密算法
基于AES 128算法的Seed&key DLL的生成
最新发布
CANoe_Vector的博客
08-02 189
Seed & Key DLL封装了用于进行安全解锁的特定算法，在UDS中定义了0x27服务用于更改安全级别，以解锁具有访问限制的诊断服务。通常ECU发送种子作为诊断测试仪的安全访问请求响应。然后，诊断测试仪为种子计算相应的密钥，并使用该密钥解锁服务器。CANoe示例工程“UDSSystem”中提供了生成该DLL的C++工程。本文档在该示例工程的基础上集成OpenSSL库，将AES128算法应用到计算key值上来。
基于C语言的AES 128 CBC加密解密代码（MSP430F149验证通过）
10-31
这是一个基于C语言编写的AES 128位的加密及解密算法实现，已经通过MSP430F149单片机验证，很容易移植到其它单片机或者上位机。
AES128算法c语言实现
loglingyy的博客
03-14 2399
/ nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。// nDataLen -- 数据长度，以字节为单位，必须为AES_KEY_LENGTH/8的整倍数。// 输入参数： pPlainText -- 明文，即需加密的数据，其长度为nDataLen字节。
C语言实现AES128解密-法1
qq_63016521的博客
09-27 1502
C语言实现AES解密-法1
C语言实现AES128加解密算法
07-22
**AES128 加解密算法在C语言中的实现** AES（Advanced Encryption Standard），即高级加密标准，是一种广泛应用于现代密码学的块密码算法。它以其高效性、安全性以及标准化的特点，成为数据加密的重要工具。AES128...
AES128 ECB、CBC模式加密解密函数（C语言实现 -单片机/嵌入式）
04-24
在单片机和嵌入式系统中实现AES128的加密解密，需要考虑硬件资源限制和性能优化。C语言是一种常见且高效的编程语言，适用于这些平台。实现过程中可能涉及以下步骤： 1. 密钥扩展：AES128使用固定长度的128位密钥，但...
AES128-GCM:AES 128 位 C 语言的基本实现和 Galois Counter Mode 的操作模式
06-17
在压缩包中的"AES128-GCM-master"文件中，可能包含了实现这些步骤的C语言源代码，包括AES128的实现、GCM模式的具体操作、密钥扩展函数、加密解密函数以及MAC的计算。这些代码可能使用了如OpenSSL等库提供的AES接口，...
C语言实现AES加密解密
06-26
在C语言中实现AES加密解密是一项基础且重要的技能，特别是在嵌入式系统和低级别编程中。 AES的核心是一个名为Rijndael的密码，由比利时密码学家Joan Daemen和Vincent Rijmen设计。它的工作原理基于一系列的替换和...
AES-128加密算法，C语言实现
04-25
该文件是AES加密算法C语言的实现，在STM32平台验证通过，ECB加密方式，方便移植。
AES128 C语言实现源码及应用例程
07-25
AES128 C语言实现源码及应用例程，可用于通信等场合数据加密
AES128 加密 解密 C#
01-04
AES128 加密 解密 C#实现 可以实现文件等的加密解密。
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的字符串水 int Bit64ToChar8 (ElemType bitL64, ElemType ch18) int cnt memset(ch, 0, 8) for(ent-0: cnt<8: cnt++i BitToByte(bit+(cnt<<3), ch+cnt) return 0 /*生成子密钥 int DES Make Subkeys(ElemType key _64, ElemType subkeys [16][48]) ElemType temp 56 int cnt DES PCI Transform(key,temp):/*PCI置换* for(cnt=0;cnt<16;cnt+-){*16轮跌代,产生16个子密钥米 DES ROL(tenp, MOVE TIMES[cnt]);循坏左移* DES PC2 Transform(temp, subkeys cnt]);/PC2置换,产生子密钥体 return o /*密钥置換1*/ int DES PCI Transform(ElemType key [64, ElemType tempts[56])t int cnt for(cnt=0: cnt( 56 cnt++) )empts[cnt]= key[ Ilant] r巳turn /*密钥置換2* int DES PC2 Transform(Elem Type key [56], ElemType tempts[48])i t cnt for(ent =0: cnt< 48: cnt+)I )pbts [cnt]= key [PC 2[cnt]] return /*循环左移*/ int DES ROL (Elem Type data[56], int time)t Elem l'ype temp _56 /*保存将要循环栘动到右边的位* memcpy(temp, data, time) memcpy(temg-time, data+28, time) /*前28位移动 (data-28-time, temp, time) /*后28位移动* memcpy(data 28, data+28+time, 28-time memcpy (data-56-time, temp+time, time) return o /*P置换*/ int DES IP) Iransform(Elemlype data[64)[ ElemType temp _64]: for(cnt templet- datalIP Tablelcnt」」 memcpy(data, temp, 64) return o 第3页 AIS加密算法c语言实现代码 /*IP逆置換* int DES IP 1 Transform(ElemType data[64)( int cnt ElemType temp _64 for(cnt =0: cnt 64: cnt+-)i templet」- dataLIP1 Tablelcrt]」 memcpy(data, temp, 64) return o /*扩展置换*/ int DES E Transform(ElemType data[48])( Int cn ElemType temp48」 for(ent-0: cnt 48: cnt-) temp lent= datale Tablelent memcpy( data, temp, 48 return o P置换 int DES P Transform(ElemType data[32])( t ElemType temp_32] for(ent =0; cnt 32; cnt+-) temp ent-datalP Tablel 11 me.mcpy(data, temp, 32) return 0 /水异或* int DES XOR(Elem Type R[48, Elem Type L[48], int count)I int cnt for(cnt-0: cnt< count: cnt++)i RIant]= lent] return 0 /*S盒置换*/ int DES SBOX (Elem Type data[48]) int cnt int line, row, output int curl, cur for(ent=0; cnt( 8: cnt++i curl cnt:6 cur2= cnt<<2 /*计算在S盒中的行与列来 line=(data cur1<<1)+ data[ cur1+5 row=(data[cur1+1]<<3)+(data[cur1+2]<<2) +(data「cur1-31<<1)+data「cur1+41 output s[cnt][line]trow] /*化为2进制*/ data[cur2]=(output&0X08)>>3 data[cur2+1]=(output&0X04)>>2 data (output&0X02)>1 datalcur 2+3= output&0x01 return o 交换 int DES Swap(ElemType left[32], ElemType right [32]) memcpy(temp, left, 32 memcpy(left, right, 32 memcpy (right, temp, 32 return o 第4页 AIS加密算法c语言实现代码 /*加密单个分组 int DES EncryptBlockElem Type plainBlock[8, ElemType subKeys[l6][48, ElemType cipherBlock[8])I ElemT'ype plainTs [54] ElemType copyRight[48] int cnt Char8ToBit64(plainBlock, plairBits) /米初始置换(IP置换)* DES IP Transform(plainBits /*16轮迭代* for(cnt=0: cnt< 16: cnt+-) memcpy(copyRight, plainBits- 32, 32 /*将右半部分进行扩展置换,从32位扩展到48位*/ DES E Trans form(copyRight) /*将右半部分与子密钥进行异或操作 DES XOR (copy Righ 48) /*异或结果进入S盒,输出32位结果*/ DES SBOX (copyRight) /P置换 DES P Transform(copyRight) /*将明文左半部分与右半部分进行异或* DES XOR (plainBits, copyRight, 32) 最终完成左右部的交换* DES Swap(plainBits, plainBits-32) /逆初始置换(IPI置换)* DES IP 1 Transform (plainBits) Bit64ToChar8(plainBits, cipherBlock) turn o /*解密单个分组 int DES DecryptBlock(ElemType cipherBlock[8, ElemType subKeys[16] 18], ElemType plainBlock [81) ElemType cipherBits[ 641 Elem Type copy Right [48] int cnt Char8ToBit64(cipherBlock, cipherBits) /初始置换(IP置换)* DES IP Transform(cipherBits /*16轮迭代*/ for(cnt-15: cnt >-0: cnt--)i memcpy(copyRight, cipherBits+32, 32 /*将右半部分进行扩展置换,从32位扩展到48位 DES T Trans form(copyright) /*将右半部分与子密钥进行异或操作 DES XOR(copy Right, subKeys [ent], 48) /*异或结果进入S盒,输出32位结果* DES SBOX(copyRight) /米P置换* DES P Transform(copyright) /*将明文h半部分与右半部分进行异或* DES XOR (cipherBits, copy Right, 32) f(cnt /米最终完成左右部的交换* DES Swap(cipherBits, cipherBits+32) /*逆初始置换(IP1置换)* DES IP 1 Transform(cipherBits) Bit64ToChar8(cipherBits, plainBlock) return 0: *加密文件 int DES Encrypt (char xplainFile, char *keyStr, char *cipherFile)t FILE xplain, i*cipher; int count ElcmType plainBlock[81, ciphcrBlock [8, keyBlock 8 第5页 AIS加密算法c语言实现代码 Elem Type bEy 64] ElemType subKeys[16][18] if((plain- fopen(plainFilc, " rb"))--NULL) return Plain FILe OPEN ERROR return CIPHER FILE OPEN ERROR: ))== NULL)( if ((cipher fopen(cipherFile, wb /设置密钥 memcpy (keyBlock, key Str, 8) 将密钥转换为二进制流* Char8ToBit64(keyBlock, bKcy /牛成子密钥* DES Make SubKeys(bEy, subKeys while(!feof plain))( /*每次读8个字节,并返回成功读取的字节数* if((count- fread(plainBlock, sizeof(char),8, plain)) 8){ DES EncryptBlock (plainBlock, subKeys, cipherBlock f(count)[ /*填充*/ memset(plainBlock ount, \0, 7- count) /*最后一个字符休存包括最后一个字符在内的所填充的字符数量水 plainblockl7-8-count DES EncryptBlock (plainBlock, subkeys, cipherBlock fwrite(cipherBlock, sizeof (char), 8, cipher) fclose (plain) f'c. lose(cipher return oK /*解密文件* int DES Decrypt(char *cipherFile, char *key Str, char xplainFile)i FILE* plain,米 cipher int count, times 0 long fileLen Eleml'ype plainBlock [8], cipherBlock[8], keyBlock[8 ElemType bEy _6 ElemType subKeys[16][48] if ((cipher fopen(cipherFile, rb ))= NULL)[ return CIPHEr FILe OPEN ERROR if((plain= fopen(plainFile, wb" ))= NULL) rcturn plain FIle OPEN ERROR /*设置密钥* memcpy(key Block, keyStr, 8) /将密钥转换为二进制流* Char8ToBit64 (keyBlock, bKey) /水生成子密钥* ES Make SubKeys(bKey subKeys) /取文什长度*/ fseek( cipher,0, SEEK END);/将文件指针置尾 fi lelen= ftel l( cipher);/*取文件指针当前位置*/ rewind( CIpher);/*将文件指针重指向文件头* while(1)i 密文的字节数一定是8的整数倍* fread(cipherBlock, sizeof(char), 8, cipher DES DecryptBlock(cipherBlock, subKeys, plainBlock) times +-8 if(times< fileLen fwrite(plainBlock, sizeof(char), 8, plain) /*判断末尾是否被填充米 if(plainBlock 71< 8)i 第6页 AIS加密算法c语言实现代码 for(count=8- plainBlock[7]; count< 7; count++)( if(plainBlock[ count!='\0i break if( count==7){/*有填充* fwrite(plairBlock, sizeof (char), 8- plainBlockL7, plain) else{/*无填充 fwrite(plainBlock, sizeof(char), 8, plain) t'close ( plain) fclose(cipher) return OK int main() clock t a, b a= clockO DES Encrypt( 1. txt, key. txt, 2. txt b=clock o printf("加密消耗%毫秒Ⅶn",b-a); system("pause") a= clock( DES Decrypt( 2. txt, key. txt", 3. txt") printf("解密消耗%毫秒、n",o-a) getcharo return 第7页
C语言实现AES-128 CMAC算法
热门推荐
easychang的博客
08-29 4万+
美国国家标准与技术研究院NIST推荐了一种CMAC计算方式，可以避免CBC-MAC带来的缺点，编号为800-3B，文档可以从其官网上下载。该算法通过MAC密钥生成k1和k2两个子密钥，并规定了数据位填充的规则，可以通过AES-128、AES-192、AES-256三种模式进行MAC计算，支持所有整数字节的数据以及长度为0的输入。下图为MAC算法处理不需要位填充和需要位填充的两种情况。本文介绍AES-128生成的CMAC实现。
AES128加密解密方法
RicheyLee的博客
06-30 9399
AES128加密解密方法AES介绍AES(高级加密标准Advanced Encryption Standard) 2000年10月，NIST（美国国家标准和技术协会）宣布通过从15种侯选算法中选出的一项新的密匙加密标准。新的标准将会代替密匙长度变的太短的旧的DES算法。Rijndael被选中成为将来的AES。Rijndael这个名字是从它的两个发明者Rijmen和Daemen的名字得来的。 这个加
C语言AES加密解密（ECB，256，包含测试代码）
06-26
C语言实现AES加密解密，加密结果与Java中AES的ECB模式，NoPadding补码方式结果一致；支持中文加密，但是限定密钥32位，加密内容16位；若需要变化可作为参考
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值