openssl与mbedtls互相aes加密解密

原创已于 2025-02-28 11:01:31 修改 · 1.2k 阅读

3 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

linux应用编程学习

于 2021-07-06 01:08:21 首次发布

本文档详细介绍了如何使用openssl和mbedtls库进行AES加密解密操作，涉及1k字节文件、256bit和128bit的CBC模式。在不同位数下，通过mbedtls加密后，使用openssl进行解密验证，展示了加密解密的互操作性。

上班访问外网限制，只能访问csdn，个人练习工程代码

文件读取 1k字节解密加密 256bit cbc模式 mbedtls加密 openssl解密

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <openssl/aes.h>
#include <mbedtls/aes.h>
#include <mbedtls/rsa.h>
// gcc -o test_mbedtls_256 mbedtls_aes256.c -lssl -lcrypto -lmbedtls -lmbedcrypto
#define BLOCK_SIZE 1024
#define TEST_AES_BLOCK_SIZE 32
#define VI_SET '0'
#define ENCRYP_FILE "lala_encryp.c"
#define DECRYP_FILE "lala_decryp.c"
#define AES_KEY "0123456789abcdeffedcba9876543210"

char srcBuff[BLOCK_SIZE] = {0};
char desBuff[BLOCK_SIZE] = {0};

int MbedtlsEncrypFile(const char *path)
{
	int ret;
	int temp;
	int fileLen;
	int readLen;
	mbedtls_aes_context ctx;
	unsigned char ivec[16] = {0};
	unsigned char key[TEST_AES_BLOCK_SIZE];

	memset(ivec, VI_SET, sizeof(ivec));
	memcpy(key, AES_KEY, sizeof(key));
	FILE *sfp = fopen(path, "r");
	if (sfp == NULL) {
		printf("open [%s] error \n", path);
		return -1;
	}

	FILE *dfp = fopen(ENCRYP_FILE, "a+");
	if (dfp == NULL) {
		printf("open [%s] error \n", ENCRYP_FILE);
		return -1;
	}

	fseek(sfp , 0, SEEK_END);
	fileLen = ftell(sfp);
	fseek(sfp , 0, SEEK_SET);
	printf("[%s] fileLen is %d\n", path, fileLen);
	temp = fileLen;
	mbedtls_aes_init(&ctx);
 	ret = mbedtls_aes_setkey_enc(&ctx, key, 256);
	while (fileLen > 0) {
		if (fileLen > BLOCK_SIZE) {
			readLen = BLOCK_SIZE;
		} else if ((fileLen % TEST_AES_BLOCK_SIZE) == 0) {
			readLen = fileLen;
		} else {
			readLen = ((fileLen / TEST_AES_BLOCK_SIZE) + 1) * TEST_AES_BLOCK_SIZE;
		}
		fileLen -= readLen;
		memset(srcBuff, 0, sizeof(srcBuff));
		memset(desBuff, 0, sizeof(desBuff));
		fread(srcBuff, 1, readLen, sfp);
		mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_ENCRYPT, readLen, ivec, (unsigned char *)srcBuff, (unsigned char *)desBuff);
		// 此处不能截断文件，每个字节都是加密的数据，解密需要使用，使用temp返回源文件大小
		//if (fileLen < 0) {
		//	readLen += fileLen;
		//}
		fwrite(desBuff, 1, readLen, dfp);
	}
	fclose(sfp);
	fclose(dfp);
	return temp;
}

int OpensslDncrypFile(int len)
{
	int ret;
	int fileLen;
	int readLen;
	unsigned char ivec[16] = {0};
	unsigned char key[TEST_AES_BLOCK_SIZE];
	AES_KEY aes;

	memset(ivec, VI_SET, sizeof(ivec));
	memcpy(key, AES_KEY, sizeof(key));

	FILE *sfp = fopen(ENCRYP_FILE, "r");
	if (sfp == NULL) {
		printf("open [%s] error \n", ENCRYP_FILE);
		exit(-1);
	}

	FILE *dfp = fopen(DECRYP_FILE, "a+");
	if (dfp == NULL) {
		printf("open [%s] error \n", DECRYP_FILE);
		exit(-1);
	}

	fseek(sfp , 0, SEEK_END);
	fileLen = ftell(sfp);
	fseek(sfp , 0, SEEK_SET);
	printf("[%s] fileLen is %d\n", ENCRYP_FILE, fileLen);
	fileLen = len;
	printf("iput fileLen is %d\n", fileLen);

	if(AES_set_decrypt_key(key, 256, &aes) < 0) {
		fprintf(stderr, "Unable to set encryption key in AES...\n");
		exit(-1);
	}
	while (fileLen > 0) {
		if (fileLen > BLOCK_SIZE) {
			readLen = BLOCK_SIZE;
		} else if ((fileLen % TEST_AES_BLOCK_SIZE) == 0) {
			readLen = fileLen;
		} else {
			readLen = ((fileLen / TEST_AES_BLOCK_SIZE) + 1) * TEST_AES_BLOCK_SIZE;
		}
		fileLen -= readLen;
		memset(srcBuff, 0, sizeof(srcBuff));
		memset(desBuff, 0, sizeof(desBuff));
		fread(srcBuff, 1, readLen, sfp);
		AES_cbc_encrypt((unsigned char *)srcBuff, (unsigned char *)desBuff, 
						readLen, &aes, ivec, AES_DECRYPT);
		// 截断文件，只写入原始文件长度，其他位都是无意义数据
		if (fileLen < 0) {
			readLen += fileLen;
		}
		fwrite(desBuff, 1, readLen, dfp);
	}
	fclose(sfp);
	fclose(dfp);
}

int main(int argc, char **argv)
{
	if (argc < 2) {
		printf("argc = %d error\n", argc);		
	}
	remove(ENCRYP_FILE);
	remove(DECRYP_FILE);
	OpensslDncrypFile(MbedtlsEncrypFile(argv[1]));
	printf("openssl success\n");

	exit(0);
}

256bit 加密 cbc模式 mbedtls加密 openssl解密

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <openssl/aes.h>
#include <mbedtls/aes.h>
#include <mbedtls/rsa.h>
// gcc -o test_mbedtls_256 mbedtls_aes256.c -lssl -lcrypto -lmbedtls -lmbedcrypto
#define TEST_AES_BLOCK_SIZE 32
#define VI_SET '1'
int main(int argc, char **argv)
{
	char Source[1024];
	char *InputData=NULL;
	char *EncryptData=NULL;
	char *DecryptData=NULL;
	unsigned char Key[TEST_AES_BLOCK_SIZE+1];	//建议用unsigned char
	unsigned char ivec[32] = {0};		//建议用unsigned char
	int DataLen=0,SetDataLen=0, i;
	int ret;
	AES_KEY AesKey;
	mbedtls_aes_context ctx;

	mbedtls_aes_init( &ctx);
	memset(Source, 0x00, sizeof(Source));
	strncpy(Source, argv[1], 1023);	//要加密的数据
	DataLen = strlen(Source);
 	printf("data len = %d \n", DataLen);
	memset(Key, 0x00, sizeof(Key));
	memcpy(Key, "0123456789abcdeffedcba9876543210", TEST_AES_BLOCK_SIZE);
 
    SetDataLen = 0;
	if ((DataLen%TEST_AES_BLOCK_SIZE) == 0) {
        SetDataLen = DataLen;
    } else {
        SetDataLen = ((DataLen/TEST_AES_BLOCK_SIZE)+1) * TEST_AES_BLOCK_SIZE;
    }
    printf("SetDataLen:%d...\n", SetDataLen);	//取16的倍数
	
	InputData = (char *)calloc(SetDataLen+1, sizeof(char));
    if(InputData == NULL){
        fprintf(stderr, "Unable to allocate memory for InputData\n");
        exit(-1);
    }
    memcpy(InputData, Source, DataLen);
	
	EncryptData = (char *)calloc(SetDataLen+1, sizeof(char));
    if(EncryptData == NULL)	{
        fprintf(stderr, "Unable to allocate memory for EncryptData\n");
        exit(-1);
    }
    
    DecryptData = (char *)calloc(SetDataLen+1, sizeof(char));
    if(DecryptData == NULL)	{
        fprintf(stderr, "Unable to allocate memory for DecryptData\n");
        exit(-1);
    }
 
 	ret = mbedtls_aes_setkey_enc( &ctx, Key, 256);
	memset(ivec, VI_SET, sizeof(ivec));
	ret = mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_ENCRYPT, SetDataLen, ivec, (unsigned char *)InputData, (unsigned char *)EncryptData);

	memset(&AesKey, 0x00, sizeof(AES_KEY));
	if(AES_set_decrypt_key(Key, 256, &AesKey) < 0) {//设置解密密钥
		fprintf(stderr, "Unable to set encryption key in AES...\n");
		exit(-1);
	}
	memset(ivec, VI_SET, sizeof(ivec));
	//解密
	AES_cbc_encrypt((unsigned char *)EncryptData, (unsigned char *)DecryptData, 
		SetDataLen, &AesKey, ivec, AES_DECRYPT); 
 
	printf("openssl DecryptData:%s...\n", (char *)DecryptData);
	if(InputData != NULL) {
		free(InputData);
		InputData = NULL;
	}
	
	if(EncryptData != NULL)	{
		free(EncryptData);
		EncryptData = NULL;
	}
	
	if(DecryptData != NULL) {
		free(DecryptData);
		DecryptData = NULL;
	}
	mbedtls_rsa_self_test(1);
	exit(0);
}

128bit 加密 cbc模式 openssl加密解密

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <openssl/aes.h>
#include <mbedtls/aes.h>
//g++ -g -o -Wall -m64 AesTest AesTest.cpp -lssl -lcrypto
//g++ -g -o -Wall AesTest AesTest.cpp -lssl -lcrypto
 
int main(int argc, char **argv)
{//由于与直接对接用的char，那么加解密要强制转换
	char Source[1024];
	char *InputData=NULL;
	char *EncryptData=NULL;
	char *DecryptData=NULL;
	unsigned char Key[AES_BLOCK_SIZE+1];	//建议用unsigned char
	unsigned char ivec[AES_BLOCK_SIZE];		//建议用unsigned char
	int DataLen=0,SetDataLen=0, i;
	int ret;
	AES_KEY AesKey;
	mbedtls_aes_context ctx;
	//mbedtls_aes_self_test(1);
	mbedtls_aes_init( &ctx );
	memset(Source, 0x00, sizeof(Source));
	strncpy(Source, argv[1], 1023);	//要加密的数据
	DataLen = strlen(Source);
 	printf("data len = %d \n", DataLen);
	memset(Key, 0x00, sizeof(Key));
	memcpy(Key, "0123456789abcdef", AES_BLOCK_SIZE);
 
 // set the encryption length
    SetDataLen = 0;
	if ((DataLen%AES_BLOCK_SIZE) == 0) {
        SetDataLen = DataLen;
    } else {
        SetDataLen = ((DataLen/AES_BLOCK_SIZE)+1) * AES_BLOCK_SIZE;
    }
    printf("SetDataLen:%d...\n", SetDataLen);	//取16的倍数
	
	InputData = (char *)calloc(SetDataLen+1, sizeof(char));
    if(InputData == NULL){
        fprintf(stderr, "Unable to allocate memory for InputData\n");
        exit(-1);
    }
    memcpy(InputData, Source, DataLen);
	
	EncryptData = (char *)calloc(SetDataLen+1, sizeof(char));
    if(EncryptData == NULL)	{
        fprintf(stderr, "Unable to allocate memory for EncryptData\n");
        exit(-1);
    }
    
    DecryptData = (char *)calloc(SetDataLen+1, sizeof(char));
    if(DecryptData == NULL)	{
        fprintf(stderr, "Unable to allocate memory for DecryptData\n");
        exit(-1);
    }
 
	memset(&AesKey, 0x00, sizeof(AES_KEY));
	if(AES_set_encrypt_key(Key, 128, &AesKey) < 0) {//设置加密密钥
		fprintf(stderr, "Unable to set encryption key in AES...\n");
		exit(-1);
	}
 
	for(i=0; i<AES_BLOCK_SIZE; i++)	{//必须要有
		ivec[i] = 0;
	}
	//加密
	AES_cbc_encrypt((unsigned char *)InputData, (unsigned char *)EncryptData, 
		SetDataLen, &AesKey, ivec, AES_ENCRYPT);   
 
	memset(&AesKey, 0x00, sizeof(AES_KEY));
	if(AES_set_decrypt_key(Key, 128, &AesKey) < 0) {//设置解密密钥
		fprintf(stderr, "Unable to set encryption key in AES...\n");
		exit(-1);
	}
 
	for(i=0; i<AES_BLOCK_SIZE; i++)	{//必须要有
		ivec[i] = 0;
	}
	//解密
	AES_cbc_encrypt((unsigned char *)EncryptData, (unsigned char *)DecryptData, 
		SetDataLen, &AesKey, ivec, AES_DECRYPT); 
 
	printf("openssl DecryptData:%s...\n", (char *)DecryptData);
	for(i=0; i<AES_BLOCK_SIZE; i++)	{//必须要有
		ivec[i] = 0;
	}
	memset(DecryptData, 0, SetDataLen);
	ret = mbedtls_aes_setkey_dec( &ctx, Key, 128);
	ret = mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_DECRYPT, SetDataLen, ivec, (unsigned char *)EncryptData, (unsigned char *)DecryptData );
	printf("mbedtls DecryptData:%s...\n", (char *)DecryptData);
	if(InputData != NULL) {
		free(InputData);
		InputData = NULL;
	}
	
	if(EncryptData != NULL)	{
		free(EncryptData);
		EncryptData = NULL;
	}
	
	if(DecryptData != NULL) {
		free(DecryptData);
		DecryptData = NULL;
	}
 
	exit(0);
}

标签

#算法