c语言实现aes-128 cbc

最新推荐文章于 2024-07-18 18:44:07 发布
最新推荐文章于 2024-07-18 18:44:07 发布
阅读量5k 收藏 18
点赞数 1
分类专栏： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35522513/article/details/83743538
版权

 加密头文件：


#ifndef __TAESCLASS_H
#define __TAESCLASS_H	 

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define AESKEY	"71412E2299B0EEA5"
#define AESIV	"71412E2299B0EEA5"

typedef unsigned long DWORD;
typedef unsigned char UCHAR,*PUCHAR;
typedef void *PVOID,*LPVOID;
typedef unsigned char byte;
typedef DWORD *PDWORD,*LPDWORD;

#ifndef VOID
#define VOID void
#endif

//#pragma once

//enum KeySize { Bits128, Bits192, Bits256 };  // key size, in bits, for construtor
#define Bits128	16
#define Bits192	24
#define Bits256	32


    void Aes_init(int keySize, unsigned char* keyBytes);
    
    void Cipher(unsigned char* input, unsigned char* output);  // encipher 16-bit input
    void InvCipher(unsigned char* input, unsigned char* output);  // decipher 16-bit input


    void SetNbNkNr(int keySize);
    void AddRoundKey(int round);      //轮密钥加
    void SubBytes(void);                  //S盒字节代换
    void InvSubBytes(void);               //逆S盒字节代换
    void ShiftRows(void);                 //行移位
    void InvShiftRows(void);
    void MixColumns(void);                //列混淆
    void InvMixColumns(void);
    unsigned char gfmultby01(unsigned char b);
    unsigned char gfmultby02(unsigned char b);
    unsigned char gfmultby03(unsigned char b);
    unsigned char gfmultby09(unsigned char b);
    unsigned char gfmultby0b(unsigned char b);
    unsigned char gfmultby0d(unsigned char b);
    unsigned char gfmultby0e(unsigned char b);
    void KeyExpansion(void);              //密钥扩展
     unsigned char* SubWord(unsigned char* word);         //密钥S盒字代换
     unsigned char* RotWord(unsigned char* word);         //密钥移位


    void TAesClass(void);
    void InitializePrivateKey(DWORD KeySize,UCHAR *KeyBytes);                       //AES 密钥初始化
    DWORD OnAesEncrypt(LPVOID InBuffer,DWORD InLength,LPVOID OutBuffer);			//AES 加密数据
    DWORD OnAesUncrypt(LPVOID InBuffer,DWORD InLength,LPVOID OutBuffer);			//AES 解密数据

#endif

加密 c文件

#include "TAesClass.h"
#include "main.h"


    int Nb;         // block size in 32-bit words.  Always 4 for AES.  (128 bits).
    int Nk;         // key size in 32-bit words.  4, 6, 8.  (128, 192, 256 bits).
    int Nr;         // number of rounds. 10, 12, 14.

    unsigned char key[32];
    unsigned char w[16*15];
		unsigned char State[4][4];
		static unsigned char AesSbox[16*16]=
{// populate the Sbox matrix
 /* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
 /*0*/  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
 /*1*/  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
 /*2*/  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
 /*3*/  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
 /*4*/  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
 /*5*/  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
 /*6*/  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
 /*7*/  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
 /*8*/  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
 /*9*/  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
 /*a*/  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
 /*b*/  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
 /*c*/  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
 /*d*/  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
 /*e*/  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
 /*f*/  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};

static unsigned char AesiSbox[16*16]=
{
    // populate the iSbox matrix
    /* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
    /*0*/  0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
    /*1*/  0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
    /*2*/  0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
    /*3*/  0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
    /*4*/  0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
    /*5*/  0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
    /*6*/  0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
    /*7*/  0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
    /*8*/  0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
    /*9*/  0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
    /*a*/  0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
    /*b*/  0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
    /*c*/  0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
    /*d*/  0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
    /*e*/  0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
    /*f*/  0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};
static unsigned char AesRcon[11*4]=
{
    0x00, 0x00, 0x00, 0x00,
    0x01, 0x00, 0x00, 0x00,
    0x02, 0x00, 0x00, 0x00,
    0x04, 0x00, 0x00, 0x00,
    0x08, 0x00, 0x00, 0x00,
    0x10, 0x00, 0x00, 0x00,
    0x20, 0x00, 0x00, 0x00,
    0x40, 0x00, 0x00, 0x00,
    0x80, 0x00, 0x00, 0x00,
    0x1b, 0x00, 0x00, 0x00,
    0x36, 0x00, 0x00, 0x00
};
void Aes_init(int keysize,unsigned char* keyBytes)
{
		SetNbNkNr(keysize);                         //设置密钥块数，轮数 
	memcpy(key,keyBytes,keysize);				//字符串拷贝函数，把keyBytes的keysize个字符复制到key中
	KeyExpansion();								//密钥扩展，必须提前做的初始化
	
}


void SetNbNkNr(int keySize)
{
	Nb=4;
	if(keySize==Bits128)
	{
		Nk=4;    //4*4字节，128位密钥，10轮加密
		Nr=10;
	}
	else if(keySize==Bits192)
	{
		Nk=6;    //6*4字节，192位密钥，12轮加密
		Nr=12;
	}
	else if(keySize==Bits256)
	{
		Nk=8;    //8*4字节，256位密钥，14轮加密
		Nr=14;
	}
}

void KeyExpansion()
{
  int row,i,j,k;
   byte temp[4];	
   byte *ret;
	memset(w,0,16*15);
	for( row=0;row<Nk;row++)       //拷贝seed 密钥
	{
		w[4*row+0] =  key[4*row];
		w[4*row+1] =  key[4*row+1];
		w[4*row+2] =  key[4*row+2];
		w[4*row+3] =  key[4*row+3];
	}
	
	for( row=Nk;row<4*(Nr+1);row++)
	{
		temp[0]=w[4*row-4];     //当前列的前一列  
		temp[1]=w[4*row-3];
		temp[2]=w[4*row-2];
		temp[3]=w[4*row-1];
		if(row%Nk==0)           //逢nk时，对当前列的前一列作特殊处理
		{
			ret=SubWord(RotWord(temp));   //先移位，再代换，最后和轮常量异或
			temp[0] =ret[0];
			temp[1] =ret[1];
			temp[2] =ret[2];
			temp[3] =ret[3];
			temp[0] = (byte)( (int)temp[0] ^ (int) AesRcon[4*(row/Nk)+0] );   
			temp[1] = (byte)( (int)temp[1] ^ (int) AesRcon[4*(row/Nk)+1] );
			temp[2] = (byte)( (int)temp[2] ^ (int) AesRcon[4*(row/Nk)+2] );
			temp[3] = (byte)( (int)temp[3] ^ (int) AesRcon[4*(row/Nk)+3] );
			/*ret[0]=(byte)( (int)ret[0] ^ (int) AesRcon[4*(row/Nk)+0] ); 
      ret[1] = (byte)( (int)ret[1] ^ (int) AesRcon[4*(row/Nk)+1] );
			ret[2] = (byte)( (int)ret[2] ^ (int) AesRcon[4*(row/Nk)+2] );
			ret[3] = (byte)( (int)ret[3] ^ (int) AesRcon[4*(row/Nk)+3] );		*/		
		}
		else if ( Nk > 6 && (row % Nk == 4) )  
		{
			ret = SubWord(temp);
			temp[0] =ret[0];
			temp[1] =ret[1];
			temp[2] =ret[2];
			temp[3] =ret[3];
		}

		// w[row] = w[row-Nk] xor temp
		w[4*row+0] = (byte) ( (int) w[4*(row-Nk)+0] ^ (int)temp[0] );
		w[4*row+1] = (byte) ( (int) w[4*(row-Nk)+1] ^ (int)temp[1] );
		w[4*row+2] = (byte) ( (int) w[4*(row-Nk)+2] ^ (int)temp[2] );
		w[4*row+3] = (byte) ( (int) w[4*(row-Nk)+3] ^ (int)temp[3] );
		/*w[4*row+0] = (byte) ( (int) w[4*(row-Nk)+0] ^ (int)ret[0] );
		w[4*row+1] = (byte) ( (int) w[4*(row-Nk)+1] ^ (int)ret[1] );
		w[4*row+2] = (byte) ( (int) w[4*(row-Nk)+2] ^ (int)ret[2] );
		w[4*row+3] = (byte) ( (int) w[4*(row-Nk)+3] ^ (int)ret[3] );*/
	}  // for loop
 /* for(i=0;i<240;i+=4)
	{
	  UART4_Send_Data(&w[i],4);
		for(j=0;j<840;j++)
		 for(k=0;k<1240;k++)
		 {
			 __nop();
			 __nop();
			 __nop();
			 __nop();
		 }
	}*/
		
}

//密钥移位函数
 unsigned char*  RotWord(unsigned char word[])
{
	static byte temp[4];
	temp[0] = word[1];
	temp[1] = word[2];
	temp[2] = word[3];
	temp[3] = word[0];
	return temp;
}

//密钥字代换函数
 unsigned char*  SubWord(unsigned char word[])
{
	int j;
	static byte temp[4];
	
	for( j=0;j<4;j++)
	{
		temp[j] = AesSbox[16*(word[j] >> 4)+(word[j] & 0x0f)];  //实际上也可以写成AesSbox[[j]];因为两者相等
	}
	return temp;

}

//Aes加密函数
void  Cipher(unsigned char* input, unsigned char* output)
{
	int i;
	int round ;
	memset(&State[0][0],0,16);
	for(i=0;i<4*Nb;i++)                        //这里是先写列后写行的，即输入是一列一列的进来的
	{
		State[i%4][i/4]=input[i];					//换成先写行后写列也是可以的，只要在输出时也是这样就可以了
	}
	AddRoundKey(0);									//轮密钥加

	for (round = 1; round <= (Nr - 1); round++)  // main round loop
	{
		SubBytes();									//字节代换
		ShiftRows();								//行移位
		MixColumns();								//列混淆
		AddRoundKey(round);							//轮密钥加
	}  // main round loop

	SubBytes();										//字节代换
	ShiftRows();									//行移位
	AddRoundKey(Nr);								//轮密钥加

	// output = state
	for ( i = 0; i < (4 * Nb); i++)
	{
		output[i] =  State[i % 4][ i / 4];
	}

}

//Aes解密函数
void  InvCipher(unsigned char* input,unsigned char* output)
{
	int round;
	int i;
	memset(&State[0][0],0,16);
	for ( i = 0; i < (4 * Nb); i++)
	{
		State[i % 4][ i / 4] = input[i];
	}

	AddRoundKey(Nr);

	for (round = Nr-1; round >= 1; round--)  // main round loop
	{
		InvShiftRows();
		InvSubBytes();
		AddRoundKey(round);
		InvMixColumns();
	}  // end main round loop for InvCipher

	InvShiftRows();
	InvSubBytes();
	AddRoundKey(0);

	// output = state
	for ( i = 0; i < (4 * Nb); i++)
	{
		output[i] =  State[i % 4][ i / 4];
	}
}

//轮密钥加
void  AddRoundKey(int round)
{
	int i,j;  //i行 j列           //因为密钥w是一列一列排列的，即 k0 k4 k8 k12
	for(j=0;j<4;j++)			  //							  k1 k5 k9 k13
	{							  //							  k2 k6 k10k14
		for(i=0;i<4;i++)		  //							  k3 k7 k11k15
		{						  // 所以i行j列的下标是4*((round*4)+j)+i即16*round+4*j+i
			State[i][j]=(unsigned char)((int)State[i][j]^(int)w[4*((round*4)+j)+i]);  
		}
	}
}

//字节代换函数
void  SubBytes()                              //Page 103
{
	int i,j;
	for(j=0;j<4;j++)
	{
		for(i=0;i<4;i++)
		{
			State[i][j]=AesSbox[State[i][j]];
			//因为 16*(State[i][j]>>4)+State[i][j]&0x0f=State[i][j]


		}
	}
}

void  InvSubBytes(void)
{
	int i,j;
	for(j=0;j<4;j++)
	{
		for(i=0;i<4;i++)
		{
			State[i][j]=AesiSbox[State[i][j]]; //因为 16*(State[i][j]>>4)+State[i][j]&0x0f=State[i][j]
		}
	}

}

void  ShiftRows(void)
{
	unsigned char temp[4*4];                                        //Page105
	int i,j;
	for(j=0;j<4;j++)
	{
		for(i=0;i<4;i++)
		{
			temp[4*i+j]=State[i][j];
		}
	}
	for(i=1;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			if(i==1)State[i][j]=temp[4*i+(j+1)%4];					//第一行左移1位
			else if(i==2)State[i][j]=temp[4*i+(j+2)%4];				//第二行左移2位
			else if(i==3)State[i][j]=temp[4*i+(j+3)%4];				//第三行左移3位
		}
	}

}
void  InvShiftRows(void)
{
	unsigned char temp[4*4];
	int i,j;
	for(j=0;j<4;j++)
	{
		for(i=0;i<4;i++)
		{
			temp[4*i+j]=State[i][j];
		}
	}
	for(i=1;i<4;i++)
	{
		for(j=0;j<4;j++)
		{
			//if(i==1)State[i][j]=temp[4*i+(j-1)%4];    在此犯了一个错误 -1%4=-1 而不是3，所以采用了下面再加一个4的做法
			if(i==1)State[i][j]=temp[4*i+(j+3)%4];			//第一行右移1位 j-1+4=j+3
			else if(i==2)State[i][j]=temp[4*i+(j+2)%4];		//第二行右移2位 j-2+4=j+2
			else if(i==3)State[i][j]=temp[4*i+(j+1)%4];		//第三行右移3位 j-3+4=j+2
		}
	}

}

void  MixColumns(void)
{
	unsigned char temp[4*4];
	int i,j;
	for(j=0;j<4;j++)                                    //2 3 1 1  列混淆矩阵  Page107
	{													//1 2 3 1
		for(i=0;i<4;i++)								//1 1 2 3
		{												//3 1 1 2
			temp[4*i+j]=State[i][j];
		}
	}
	for(j=0;j<4;j++)
	{
		State[0][j] = (unsigned char) ( (int)gfmultby02(temp[0+j]) ^ (int)gfmultby03(temp[4*1+j]) ^
			(int)gfmultby01(temp[4*2+j]) ^ (int)gfmultby01(temp[4*3+j]) );
		State[1][j] = (unsigned char) ( (int)gfmultby01(temp[0+j]) ^ (int)gfmultby02(temp[4*1+j]) ^
			(int)gfmultby03(temp[4*2+j]) ^ (int)gfmultby01(temp[4*3+j]) );
		State[2][j] = (unsigned char) ( (int)gfmultby01(temp[0+j]) ^ (int)gfmultby01(temp[4*1+j]) ^
			(int)gfmultby02(temp[4*2+j]) ^ (int)gfmultby03(temp[4*3+j]) );
		State[3][j] = (unsigned char) ( (int)gfmultby03(temp[0+j]) ^ (int)gfmultby01(temp[4*1+j]) ^
			(int)gfmultby01(temp[4*2+j]) ^ (int)gfmultby02(temp[4*3+j]) );
	}

}
void  InvMixColumns(void)
{
	unsigned char temp[4*4];
	int i,j;
	for (i = 0; i < 4; i++)  // copy State into temp[]
	{
		for (j = 0; j < 4; j++)                         //0e 0b 0d 09   逆变换矩阵 Page108
		{												//09 0e 0b 0d
			temp[4*i+j] =  State[i][j];					//0d 09 0e 0b
		}												//0b 0d 09 0e
	}

	for (j = 0; j < 4; j++)
	{
		State[0][j] = (unsigned char) ( (int)gfmultby0e(temp[j]) ^ (int)gfmultby0b(temp[4+j]) ^
			(int)gfmultby0d(temp[4*2+j]) ^ (int)gfmultby09(temp[4*3+j]) );
		State[1][j] = (unsigned char) ( (int)gfmultby09(temp[j]) ^ (int)gfmultby0e(temp[4+j]) ^
			(int)gfmultby0b(temp[4*2+j]) ^ (int)gfmultby0d(temp[4*3+j]) );
		State[2][j] = (unsigned char) ( (int)gfmultby0d(temp[j]) ^ (int)gfmultby09(temp[4+j]) ^
			(int)gfmultby0e(temp[4*2+j]) ^ (int)gfmultby0b(temp[4*3+j]) );
		State[3][j] = (unsigned char) ( (int)gfmultby0b(temp[j]) ^ (int)gfmultby0d(temp[4+j]) ^
			(int)gfmultby09(temp[4*2+j]) ^ (int)gfmultby0e(temp[4*3+j]) );
	}
}

unsigned char  gfmultby01(unsigned char b)
{
	return b;
}
unsigned char  gfmultby02(unsigned char b)
{
	if (b < 0x80)
		return (unsigned char)(int)(b <<1);
	else
		return (unsigned char)( (int)(b << 1) ^ (int)(0x1b) );
}

unsigned char  gfmultby03(unsigned char b)
{
	return (unsigned char) ( (int)gfmultby02(b) ^ (int)b );
}

unsigned char  gfmultby09(unsigned char b)
{
	return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^ (int)b );
}

unsigned char  gfmultby0b(unsigned char b)
{
	return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^
		(int)gfmultby02(b) ^ (int)b );
}

unsigned char  gfmultby0d(unsigned char b)
{
	return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^
		(int)gfmultby02(gfmultby02(b)) ^ (int)(b) );
}

unsigned char  gfmultby0e(unsigned char b)
{
	return (unsigned char)( (int)gfmultby02(gfmultby02(gfmultby02(b))) ^
		(int)gfmultby02(gfmultby02(b)) ^(int)gfmultby02(b) );
}

void TAesClass(void)
{
	//m_lpAes=NULL;
    InitializePrivateKey(16,(unsigned char*)"71412E2299B0EEA5");//\x79\x76\x68\x6B\x77\x66\x6E\x68\x72\x65\x73\x63\x6C\x6B\x70\x6E");//yvhkwfnhresclkpn
}


//------------------------------------------------------------------------------------------------------------
// 编写人员：
//
// 函数名称：InitializeAes
//
// 函数描述：初始化AES 密钥，密钥用于加密解密
//
// 调用参数：
//
// 返回数值：无
//
// 最近修改：
//------------------------------------------------------------------------------------------------------------


VOID InitializePrivateKey(DWORD KeySize,UCHAR *KeyBytes)
{
	/*if (m_lpAes)
	{
		delete m_lpAes;
		m_lpAes=NULL;
	}
	m_lpAes=new Aes(KeySize,KeyBytes);*/
	Aes_init(KeySize,KeyBytes);

}

//------------------------------------------------------------------------------------------------------------
// 编写人员：
//
// 函数名称：OnAesEncrypt
//
// 函数描述：用AES加密算法加密数据
//
// 调用参数：
//
// 返回数值：加密后的数据大小 ，错误返回值  0
//
// 最近修改：
//------------------------------------------------------------------------------------------------------------

DWORD OnAesEncrypt(LPVOID InBuffer,DWORD InLength,LPVOID OutBuffer)
{
    //qDebug("InLength = %d",InLength);
    DWORD OutLength=0;
	    long j;
    long i;
   /* if (m_lpAes==NULL||OutBuffer==NULL)
    {
        return 0;
    }*/

    UCHAR *lpCurInBuff=(UCHAR *)InBuffer;
    UCHAR *lpCurOutBuff=(UCHAR *)OutBuffer;
    long blocknum=InLength/16;
    long leftnum=InLength%16;
    //qDebug("blocknum = %d",blocknum);
    //qDebug("leftnum = %d",leftnum);

    UCHAR iv[20] = AESIV;


    for( i=0;i<blocknum;i++)
    {
        for(j = 0; j < 16; j++ )
        {
            lpCurOutBuff[j] = (unsigned char)( lpCurInBuff[j] ^ iv[j] );
        }

        Cipher(lpCurOutBuff,lpCurOutBuff);

        memcpy( iv, lpCurOutBuff, 16 );

        lpCurInBuff+=16;
        lpCurOutBuff+=16;
        OutLength+=16;
    }
    //qDebug("1--OutLength = %d",OutLength);
    if(leftnum)                   //多余出leftnum 字节  则加密时 多出16-leftnum 个字节
    {
        UCHAR inbuff[16];
        memset(inbuff,16-leftnum,16);
        memcpy(inbuff,lpCurInBuff,leftnum);

        for(j = 0; j < 16; j++ )
        {
            lpCurOutBuff[j] = (unsigned char)( inbuff[j] ^ iv[j] );

        }

        Cipher(lpCurOutBuff,lpCurOutBuff);

        memcpy( iv, lpCurOutBuff, 16 );

        lpCurOutBuff+=16;
        OutLength+=16;
    }
    else
    {
        //新增16个字节，用以确定增加的字节数
        UCHAR extrabuff[16];
        memset(extrabuff,16,16);
        //*((LPDWORD)extrabuff)=16+(16-leftnum)%16;      //多出16+(16-leftnum)%16个字节

        for(j = 0; j < 16; j++ )
        {
            lpCurOutBuff[j] = (unsigned char)( extrabuff[j] ^ iv[j] );

        }

        Cipher(lpCurOutBuff,lpCurOutBuff);

        memcpy( iv, lpCurOutBuff, 16 );

        OutLength+=16;
    }
    return OutLength;
}

//------------------------------------------------------------------------------------------------------------
// 编写人员：
//
// 函数名称：OnAesUncrypt
//
// 函数描述：用AES加密算法解密数据
//
// 调用参数：
//
// 返回数值：解密后的数据大小 ，错误返回值  0
//
// 最近修改：
//------------------------------------------------------------------------------------------------------------
DWORD OnAesUncrypt(LPVOID InBuffer,DWORD InLength,LPVOID OutBuffer)
{
    //qDebug("OnAesUncrypt InLength = %d",InLength);
    DWORD OutLength=0;
	  long blocknum=InLength/16;
    long leftnum=InLength%16;
    long j;
		long i;
    unsigned char temp[16];
	  UCHAR iv[20] = AESIV;
    /*if (m_lpAes==NULL||OutBuffer==NULL)
    {
        return 0;
    }*/
    UCHAR *lpCurInBuff=(UCHAR *)InBuffer;
    UCHAR *lpCurOutBuff=(UCHAR *)OutBuffer;
    
    if(leftnum)
    {
        return 0;
    }

   

  

    for(i=0;i<blocknum;i++)
    {
        InvCipher(lpCurInBuff,lpCurOutBuff);

        for(j = 0; j < 16; j++ )
        {
            lpCurOutBuff[j] = (unsigned char)( lpCurOutBuff[j] ^ iv[j] );
        }
        memcpy( iv, lpCurInBuff, 16 );

        if(i == (blocknum-1))
        {
            memset(temp,0,16);
            if(lpCurOutBuff[15] != 0x10)
            {
                if(lpCurOutBuff[15] < 0x10)
                {
                    OutLength = InLength - lpCurOutBuff[15];
                    memcpy( temp, lpCurOutBuff, 16-lpCurOutBuff[15] );
                    memcpy( lpCurOutBuff, temp, 16 );
                }
                else
                    break;
            }
            else
            {
                OutLength = InLength - 16;
                memcpy( lpCurOutBuff, temp, 16 );
            }
        }
        lpCurInBuff+=16;
        lpCurOutBuff+=16;
    }

    return OutLength;

}

主函数： 

#include "main.h"
#include "TAesClass.h"
void main(void)
{
	
	 DWORD outlen;
	 unsigned char in[]={"asdfgh"};
	  unsigned char out_data[32];
	  unsigned char in_data[32];
	//SCB->VTOR = FLASH_BASE | 0x10000; /* Vector Table Relocation in Internal FLASH. */
	TAesClass();
   UART4_Send_Data("1111",4);
	 outlen=OnAesEncrypt(in,6,out_data);//DWORD OnAesEncrypt(LPVOID InBuffer,DWORD InLength,LPVOID OutBuffer)
   UART4_Send_Data(out_data,16);

	 outlen=OnAesUncrypt(out_data,16,in_data);//DWORD OnAesUncrypt(LPVOID InBuffer,DWORD InLength,LPVOID OutBuffer)
	 //UART4_Send_Data(in_data,6);
	}

测试工具连接：

https://download.csdn.net/download/qq_35522513/11087971

如果没积分可以添加群qq 678758509

夜晚_航空站_世界
关注
专栏目录
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实现。
java学习-AES加解密之AES-128-CBC算法
weixin_30852367的博客
08-29 995
AES算法简介 AES是一种对称加密算法，或称分组对称加密算法。 是Advanced Encryption Standard高级加密标准，简称AES AES的基本要求是，采用对称分组密码体制。分组密码算法通常由密钥扩展算法和加密（解密）算法两部分组成 AES加密数据块分组长度必须为128比特（bit位），密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足...
基于C语言的AES 128 CBC加密解密代码（MSP430F149验证通过）
10-31
这是一个基于C语言编写的AES 128位的加密及解密算法实现，已经通过MSP430F149单片机验证，很容易移植到其它单片机或者上位机。
AES-128加密算法，C语言实现
04-25
该文件是AES加密算法C语言的实现，在STM32平台验证通过，ECB加密方式，方便移植。
基于Mbedtls实现AES128-CBC-PKCS7#padding和Hmac-SHA256数据加解密处理和基于micro_uECC实现ECDH密钥协商算法
最新发布
weixin_46097907的博客
07-18 768
对称算法是一种通信双方使用相同的秘钥进行加密和解密的密码算法。其中这份相同的秘钥称为对称秘钥或者共享秘钥，只有通信双方持有，如果传输的密文被拦截，没有秘钥也无法解密出原文。3.1.1. AES功能相关宏mbedtls中提供的这些对称加密算法，每个都是一个独立的模块，由对应的宏控制是否开启，要使用AES相关功能，需要开启以下宏：宏定义说明开启AES算法开启CBC模式开启CRT模式开启预定义S盒开启PKCS7填充方案。
AES-CBC-128 C语言加解密
02-10
AES-CBC-128 C语言加解密 使用C语言实现AES-CBC-128加解密，KEY可自己定义
AES-128-CBC算法C语言源码（解密）（已经修改，可直接在WIN-TC下运行）
07-29
用于计算AES CBC算法的(解密)程序，key长度128bit 看到很多朋友说我之前的算法只有加密的，那是因为之前我这边只需要做加密就OK，解密交给三位机来做的。 现在我把解密的算法也提交上来了. 省的大家操心了，让天下的罪都归老衲吧，阿弥陀佛。。。
AES-128-CBC算法C语言源码（已经修改，可直接在WIN-TC下运行）
06-29
这是一个用于计算AES CBC算法的程序，key长度128bit 满足fips－197规格，这个是最近在做一个OMS（Open Metering Sytem）项目用到的，自己在网上找了半天都找不到C语言的源代码。找到的不是工具就是别的没用的东西，要不就是找到的代码只是AES算法，不是CBC的，和spec上的数据对不上，结果经过多番实验（try啊try啊），终于成功了，哇哈哈，要不然项目要被赔款的。。。
AES-128-CBC C语言代码
weixin_30435261的博客
09-26 1709
/** * Copyright (c) 2007, Cameron Rich * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that th...
AES128 ECB、CBC模式加密解密函数（C语言实现 -单片机/嵌入式）
04-24
AES128是一种广泛使用的对称加密算法，全称为Advanced Encryption Standard，128表示其块大小为128位。...提供的压缩包文件“AES128”可能包含了实现这些功能的C语言源代码，可以进一步学习和研究。
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页
AES128 C语言实现源码及应用例程
07-25
AES128 C语言实现源码及应用例程，可用于通信等场合数据加密
C语言实现AES128加解密算法
07-22
项目有README详细讲解AES项目的总体结构、使用环境、编译方法和功能，还有辅助资料和项目流程图。
C语言 实现AES-CBC-128-ZeroPadding 加解密算法 完整可编译工程
12-13
C语言 实现AES_CBC_128_ZeroPadding 加解密算法 完整可编译工程
C语言实现AES加密、解密算法
04-29
源文件为AES高级加密算法的C语言实现，由于AES加密算法的加密解密过程高度对称，程序可读性很强。改变宏定义中的加密轮数可以实现128位，192位以及256位的密钥加密，一次加密过程明文长度最多为128位，即16个字节，8个汉字。
aes128 cmac java,C语言实现AES-128 CMAC算法
weixin_42514407的博客
03-18 2224
MessageAuthentication Code(MAC)是一种保障信息完整性和认证的密码学方法，其中CMAC的全称是Cypher-BasedMessage Authentication Code，基于AES等对称加密方式实现消息认证。通信双方需要共享一个对称密钥，由发送方生成一个MAC值，附在消息后面，接收方计算收到消息的MAC，如果和收到的MAC一致，则说明没有被篡改，并且能确认发送方一定...
AES-128 CMAC
04-26
**AES-128 CMAC** 是一种基于高级加密标准（AES）的密码消息认证码（CMAC）算法，主要用于数据的完整性和来源的验证。它遵循美国国家标准与技术研究所（NIST）发布的《SP 800-38B：密码模式操作：用于认证的CMAC模式...
c语言实现 aes-128 cbc 加密
06-07
好的，下面是示例代码，使用 OpenSSL 库进行 AES-CBC 加密和解密： 加密： ```c #include #include #include #include <openssl/aes.h> void aes_encrypt_cbc(const unsigned char *plaintext, int plaintext_...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值