[ 加密 ] AES 加密 & BASE 64 编码

最新推荐文章于 2024-05-02 20:39:16 发布
最新推荐文章于 2024-05-02 20:39:16 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： 基础 文章标签： c语言 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012503786/article/details/106143588
版权

AES加密简介

       AES加密标准又称为高级加密标准Rijndael加密法，是美国国家标准技术研究所NIST旨在取代DES的21世纪的加密标准。AES的基本要求是，采用对称分组密码体制，密钥长度可以为128、192或256位，分组长度128位，算法应易在各种硬件和软件上实现。1998年NIST开始AES第一轮分析、测试和征集，共产生了15个候选算法。

      1999年3月完成了第二轮AES2的分析、测试。2000年10月2日美国政府正式宣布选中比利时密码学家Joan Daemen和Vincent Rijmen提出的一种密码算法Rijndael作为AES的加密算法。

       AES加密数据块和密钥长度可以是128b、192b、256b中的任意一个。

1、加密种类

       分组密码有五种工作体制：

              1.电码本模式（Electronic Codebook Book (ECB)）；

              2.密码分组链接模式（Cipher Block Chaining (CBC)）；

              3.计算器模式（Counter (CTR)）；

              4.密码反馈模式（Cipher FeedBack (CFB)）；

              5.输出反馈模式（Output FeedBack (OFB)）。

1.1、电码本模式（Electronic Codebook Book (ECB)

        这种模式是将整个明文分成若干段相同的小段，然后对每一小段进行加密。

                                        

1.2、密码分组链接模式（Cipher Block Chaining (CBC)）

         这种模式是先将明文切分成若干小段，然后每一小段与初始块或者上一段的密文段进行异或运算后，再与密钥进行加密。

                                                

1.3、计算器模式（Counter (CTR)）

        计算器模式不常见，在CTR模式中， 有一个自增的算子，这个算子用密钥加密之后的输出和明文异或的结果得到密文，相当于一次一密。这种加密方式简单快速，安全可靠，而且可以并行加密，但是在计算器不能维持很长的情况下，密钥只能使用一次。CTR的示意图如下所示：

                                    

1.4、密码反馈模式（Cipher FeedBack (CFB)）

        这种模式较复杂。

 

                                            

1.5、输出反馈模式（Output FeedBack (OFB)）

                                                 

 

2、padding

       AES对小段逐一进行加密，对于不足16个字节的小段，使用padding补充。

       主要padding种类：

              ZeroPadding：使用“0”作为填充数据

              Pkcs5Padding：PKCS7Padding的子集，只是块大小固定为8字节；

              Pkcs7Padding：假设数据长度需要填充n(n>0)个字节才对齐，那么填充n个字节，每个字节都是n;如果数据本身就已经对齐了，则填充一块长度为块大小的数据，每个字节都是块大小

       Pkcs7Padding的块长度可以是1-255之间，而Pkcs5Padding只能是8.

BASE64编码简介

         Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2049

所使用的的字符如下所示

                            

 

在线加解密测试工具

               https://www.ssleye.com/aes_cipher.html

实例

环境：ubuntu 16.04， openssl

demo.c

##########################################################################
#include <stdio.h>
#include <openssl/aes.h>
#include <string.h>
#include <stdlib.h>

#define OUR_AES_BLOCK_SIZE AES_BLOCK_SIZE /* 16 */
struct aes_key_st encrypt_key, decrypt_key;
typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
static int ncs_key_init(unsigned char *key)
{
	if (AES_set_encrypt_key(key, 128, &encrypt_key) < 0) {
		printf("Unable to set encryption key in AES");
		return -1;
	}
	if (AES_set_decrypt_key(key, 128, &decrypt_key) < 0) {
		printf("Unable to set encryption key in AES");
		return -1;
	}
	printf("ENCRYPT key init OK!\n");
	return 0;
}
static uint8_t decode_getbyte(char c) 
{
	char *dict = "+/=";
	char *dict2 = "-_.";
	
    //if (c == '+') {
    if (c == dict[0] || c == dict2[0]) {
        return 62;
    //} else if (c == '/') {
    } else if (c == dict[1] || c == dict2[1]) {
        return 63;
    } else if (c <= '9') {
        return (uint8_t)(c - '0' + 52);
    //} else if (c == '=') {
    } else if(c == dict[2] || c == dict2[2]) {
        return 64;
    } else if (c <= 'Z') {
        return (uint8_t)(c - 'A');
    } else if (c <= 'z') {
        return (uint8_t)(c - 'a' + 26);
    } 
    return 64;
}

uint32_t base64_encode(const char *src, uint32_t srclen, char *dest, int url_safe) 
{
    uint8_t input[3];
    uint8_t output[4];
    uint32_t i;
    uint32_t index_src = 0;
    uint32_t index_dest = 0;
	
	char *dict = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
	if(url_safe)
	{
		dict = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/.";
	}

    for (i = 0;i < srclen;i += 3) {
        input[0] = src[index_src++];
        output[0] = (uint8_t)((input[0] >> 2)&0x3f);
        dest[index_dest++] = dict[output[0]];

        if (index_src < srclen) {
            input[1] = src[index_src++];
            output[1] = (uint8_t)(((input[0] & 0x03) << 4) + ((input[1] >> 4)&0x0f));
            dest[index_dest++] = dict[output[1]];
        } else {
            output[1] = (uint8_t)((input[0] & 0x03) << 4);
            dest[index_dest++] = dict[output[1]];
            //dest[index_dest++] = '=';
            //dest[index_dest++] = '=';
            dest[index_dest++] = dict[64];
            dest[index_dest++] = dict[64];
            break;
        }

        if (index_src < srclen) {
            input[2] = src[index_src++];
            output[2] = (uint8_t)(((input[1] & 0x0f) << 2) + ((input[2] >> 6)&0x03));
            dest[index_dest++] = dict[output[2]];
        } else {
            output[2] = (uint8_t)((input[1] & 0x0f) << 2);
            dest[index_dest++] = dict[output[2]];
            //dest[index_dest++] = '=';
            dest[index_dest++] = dict[64];
            break;
        }

        output[3] = (uint8_t)(input[2] & 0x3f);
        dest[index_dest++] = dict[output[3]];
    }

    dest[index_dest] = 0;

    return index_dest;
}
uint32_t base64_decode(const char *src, uint32_t srclen, char *dest) 
{
    uint8_t data[4];
    uint32_t i;
    uint32_t index = 0;
	char paddingchar = '=';
	char paddingchar2 = '.';

    for (i=0; i<srclen; i+=4) {
        data[0] = decode_getbyte(src[i]);
        data[1] = decode_getbyte(src[i + 1]);
        dest[index++] = (data[0] << 2) + (data[1] >> 4);

        //if (src[i+2] != '=') {
        if (src[i+2] != paddingchar && src[i+2] != paddingchar2) {
            data[2] = decode_getbyte(src[i+2]);
            if(64 > data[2])
			{
            	dest[index++] = ((data[1] & 0x0f) << 4) + (data[2] >> 2);
            }
        }

        //if (src[i+3] != '=') {
        if (src[i+3] != paddingchar && src[i+3] != paddingchar2) {
            data[3] = decode_getbyte(src[i + 3]);
			if(64 > data[3])
			{
            	dest[index++] = ((data[2] & 0x03) << 6) + (data[3]&0x3f);
			}
        }
    }

    dest[index] = '\0';

    return index;
}

static int ncs_encrypt(unsigned char *in, unsigned char *out)
{
	char *input, *output, *tmpin, *tmpout = NULL;
	int inputlen, inlen = 0;
	int padding = 0;
	int i;
	/* get aes in string */
	printf("in %s\n", in);
	inlen = strlen(in);
	inputlen = (((inlen + OUR_AES_BLOCK_SIZE)/OUR_AES_BLOCK_SIZE)*OUR_AES_BLOCK_SIZE);
	input = (char*)malloc(inputlen + 1);
	if (input == NULL) {
		return -1;
	}
	memset((void *)input, 0, inputlen + 1);
	output = (char*)malloc(inputlen + 1);
	if (output == NULL) {
		return -1;
	}
	memset((void *)output, 0, inputlen + 1);
	
	strcpy(input, in);

	padding = inputlen - inlen;
	for (i = 0; i < padding; i++) { /* pkcs7padding */
		input[inlen + i] = padding;
	}

	/* aes ecb */
	i = 0;
	tmpin = input;
	tmpout = output;
	while (i < inputlen) {
		//AES_ecb_encrypt(tmpin, tmpout, &encrypt_key, AES_ENCRYPT);
		AES_encrypt(tmpin, tmpout, &encrypt_key);
		tmpin += OUR_AES_BLOCK_SIZE;
		tmpout += OUR_AES_BLOCK_SIZE;
		i += OUR_AES_BLOCK_SIZE;
	}

	base64_encode(output, inputlen, out, 0);
	printf("encode %s; len %d;\n", out, strlen(out));
	return 0;
}
static int ncs_decrypt(unsigned char *in, unsigned char *out)
{
	const char *data_en;
	char data[4096] = {0};
	char *input, *output, *tmpin, *tmpout = NULL;
	int inputlen, inlen = 0;
	int i, j;
	int padding = 0;

	int padding_len, de_len;
	data_en = in;

	for (i = 0, j =0; i < strlen(data_en); i++) {
		if (data_en[i] != '"') {
			data[j++] = data_en[i];
		}
	}
	printf("decode %s; len %d;\n", data, strlen(data));
	inlen = strlen(data);
	input = (char*)malloc(inlen + OUR_AES_BLOCK_SIZE);
	if (input == NULL) {
		return -1;
	}
	memset((void *)input, 0, inlen + OUR_AES_BLOCK_SIZE);
	output = (char*)malloc(inlen + OUR_AES_BLOCK_SIZE);
	if (output == NULL) {
		return -1;
	}
	memset((void *)output, 0, inlen + OUR_AES_BLOCK_SIZE);
	de_len = base64_decode(data, inlen, input);
	padding_len = (((de_len+OUR_AES_BLOCK_SIZE-1)/OUR_AES_BLOCK_SIZE)*OUR_AES_BLOCK_SIZE);
	i = 0;
	tmpin = input;
	tmpout = output;
	while (i < inlen) {
		AES_decrypt(tmpin, tmpout, &decrypt_key);
		tmpin += OUR_AES_BLOCK_SIZE;
		tmpout += OUR_AES_BLOCK_SIZE;
		i += OUR_AES_BLOCK_SIZE;
	}
	padding = output[padding_len -1];
	for (i = 0; i < padding; i++) {
		output[padding_len-i-1] = 0;
	}
	printf("out %s\n", output);

	return 0;
}

int ncs_encrypt_decrypt_test(void)
{
	unsigned char data[16] = "1234567890";
	unsigned char endata[256] = {0};
	unsigned char dedata[256] = {0};
	int i = 0;
	ncs_key_init("5c44crn9ap98api7");
	ncs_encrypt(data, endata);
	ncs_decrypt(endata, dedata);
	return 0;
}

void main()
{
	ncs_encrypt_decrypt_test();
}

然后使用gcc 编译即可

gcc demo.c -o demo -I/usr/local/ssl/include/ -lssl -lcrypto  -ldl -L/usr/local/ssl/lib

运行可执行文件

./demo

结果如下

ENCRYPT key init OK!
in 1234567890
encode cnBnIUTu+yEhshQbXoduHg==; len 24;
decode cnBnIUTu+yEhshQbXoduHg==; len 24;
out 1234567890

 

hanfs390
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微信小程序 AES ECB base64 加密解密
09-25
3. 设置密钥：AES加密需要一个密钥，通常是一个16、24或32字节的字符串，你可以自定义或随机生成。 ```javascript const key = 'your_16_byte_key'; ``` 4. 加密过程：使用AES的ECB模式和Base64编码进行加密。 ...
AES加密base64编码
04-19
在iOS平台上，我们可以使用`CommonCrypto`库或者Swift的`CryptoKit`框架来实现AES加密，然后使用内置的`Data`类的`base64Encoded`方法进行Base64编码。 **应用场景** 这种组合方式常用于敏感信息的存储和传输，...
AES（高级加密标准）
u011296842的专栏
08-03 1423
请注意，此处使用ECB模式是为了简单起见，但在实际应用中，应该优先使用带有初始化向量（IV）的CBC模式，以提供更好的安全性。请注意，在实际应用中，应该使用更安全的方法生成和管理密钥，并避免在源代码中硬编码密钥。灵活性：AES支持不同长度的密钥，可根据实际需求选择128位、192位或256位的密钥长度。AES的解密过程与加密过程类似，但是加密轮的顺序相反，即从最终轮开始逆向操作直到初始轮。初始化密钥扩展：根据密钥的长度，将其扩展为不同的轮密钥，以用于后续的加密轮数。对象，这是执行AES加密所需的对象。
OpenSSL中AES加密的用法
游蓝海 的专栏
03-27 1万+
使用API的时候，需要特别小心数据长度，我在初次使用的时候简直被弄的晕头转向，遂作此文留个备忘。一般没有指定长度的参数，默认都是16（AES_BLOCK_SIZE）个字节。输出数据的长度一般都是16字节的倍数，否则会出现数组越界访问。
小程序使用Base64加密key（秘钥）和iv（偏移量）在进行aes加密，AES加密技术简介与应用
最新发布
2401_84411557的博客
05-02 2535
四轮技术面+一轮hr面结束，学习到了不少，面试也是一个学习检测自己的过程，面试前大概复习了 一周的时间，把以前的代码看了一下，字节跳动比较注重算法，面试前刷了下leetcode和剑指offer， 也刷了些在牛客网上的面经。大概就说这些了，写代码去了~祝大家都能收获大厂offer~开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】篇幅有限，仅展示部分内容。
C++ OpenSSL 3.0.8 AES加解密
琅嬛福地
08-17 3201
如果使用OpenSSL 1.1.1 sdk编译则没有上述错误，使用3.0以上的openssl sdk就会报错，那是因为3.0的不兼容1.0的sdk。如果你想继续使用已弃用的函数，并且不想更改代码，可以考虑禁用特定的编译警告。在 Visual Studio 中，你可以使用。来禁用这个特定的警告。请注意，这并不是一个推荐的解决方案，因为它可能会掩盖潜在的问题。最佳的解决方案通常是更新你的代码，以使用新的API。这样可以确保你的代码与最新的库版本兼容，并且可以从新版本中获得的安全和性能改进中受益。
AES加密与Base64编码（加解密、签名系列）
zp17764507932的博客
06-22 1万+
0：前情回顾 通过wx.getUserInfo()的success回调得到的加密数据( encryptedData ) 对加密数据( encryptedData )解密后可得到openId和unionId。 如何解密，官方文档是这样解释的！ 首次看到如上解密说明时，我只知道encryptedData和session_key获得方式。 session_key在上篇有介绍，如下：
AES加密解密的基本原理与Python爬取AES加密接口
热门推荐
小小明-代码实体的专栏
06-30 3万+
大家好，我是小小明，今天我要带大家学习AES加密的基本原理，并爬取一个经过AES加密的接口。一起来学习吧！ AES编码解码基础 AES简介 AES(Advanced Encryption Standard)是取代其前任标准(DES)而成为新标准的一种对称加密算法。 DES因为应用时间较早，密文已经可以在短时间内被破译，所以现在已经基本不再使用。 被选定为AES的Rijndael算法 全世界的企业和密码学家提交了多个对称密码算法作为AES的候选，最终在2000年从这些候选算法中选出了一种名为 Rijndael
linux c openssl aes 加解密
whatday的专栏
07-25 9401
1.OpenSSL提供了AES加解密算法的API const char *AES_options(void); AES算法状态，是所有支持或者是部分支持。 返回值：“aes(full)” 或者"aes(partial)" int AES_set_encrypt_key(const unsigned char *userKey, const int bits,AES_KEY *key)...
AES-128-CBC加密Base64编码Demo
07-09
在这个Demo中，我们主要探讨的是如何使用AES-128-CBC进行数据加密，并通过Base64编码来将加密后的结果转化为可读字符串。 AES-128-CBC的特点在于它使用128位的密钥，这提供了非常高的安全性。在CBC模式下，每个明文...
微信小程序base64加密，AES加密
07-24
在这个特定的场景下，我们讨论的是在微信小程序中进行数据加密，包括base64编码和AES加密。这两种技术在数据安全领域扮演着重要角色。 首先，让我们了解一下Base64编码。Base64是一种将二进制数据转换为可打印ASCII...
base64加密_Base64加密_
10-04
3. **加密过程**：调用插件提供的API进行Base64编码。在Java中，可以使用`Base64.getEncoder().encodeToString(byte[])`方法，其中参数是需要编码的字节数组。在Python中，可以使用`base64.b64encode()`函数。 4. *...
AES加解密,Base64编解码
qq_36470898的博客
08-28 925
AES是什么？ 美国国家标准技术研究所在2001年发布了高级加密标准（AES）。 AES是基于数据块的加密方式， 即，每次处理的数据是一块（16字节），当数据不是16字节的倍数时填充， 这就是所谓的分组密码（区别于基于比特位的流密码），16字节是分组长度。 AES是一个对称分组密码算法。由于每一步操作都是可逆的，按照相反的顺序进行解密即可恢复明文，解密过程分别为对应的逆操作。 Base64_Dec...
c语言通过openssl aes对称加解密和base64编解码将密码存储成密文
FlayHigherGT的博客
11-29 2457
今天遇到这样一个问题，将客户端中的一个密码存储到文件中以供下次使用，但是存储的密码不能直接存储明文，需要进行加密处理，再三考虑之后，这个加密的过程需要双向的可逆的过程，MD5等方式是不适用的，因为记住密码意味着下次我还需要还原这个密码进行使用，所以最后选择了openssl的aes算法，然而aes可行然而用遇到另外一个问题，aes编码字符串之后是乱码，只能用16进制数来显示，这样我使用的glib的k...
使用openssl的aes256加解密算法（带例程 兼容openssl命令）
tjlcd1的博客
11-04 1万+
目的 发布版本时，使用openssl加密版本，放到服务器上 产品升级版本时，下载版本包后，先使用openssl进行解密，然后升级 使用openssl源码 真正需要用到的只有一个结构体和三个函数，注释如下： unsigned char key[32];//密钥字符串，最长32位 unsigned char iv[16];//向量字符串，最长16位 AES_KEY aesKey;//
gcc中的参数-I -L -l三者的区别
Nothing replaces hard work！
06-03 3347
我们用gcc编译程序时，可能会用到“-I”（大写i），“-L”（大写l），“-l”（小写l）等参数，下面做个记录： 例： gcc -o hello hello.c -I /home/hello/include -L /home/hello/lib -lworld 上面这句表示在编译hello.c时： -I /home/hello/incl
【前端知识】前端加密算法(base64、md5、sha1、escape/unescape、AES/DES)
Outman's blog
09-07 1952
它们的作用是将字符串中的特殊字符转换为编码表示，以便在不同的上下文中进行安全传输或存储，并且可以再次解码以恢复原始字符串。是最早广泛使用的对称加密算法之一。不可逆性：escape 和 unescape 是一种简单的编码解码方式，它们是一对一的关系，无法进行数据压缩或加密，也无法恢复被修改的编码结果。容易碰撞：由于MD5摘要的长度固定，而原始数据的长度可以是任意的，因此可能会出现不同的数据生成相同的摘要，即碰撞情况。更高的安全性：AES采用更长的密钥长度（128位、192位或256位），提供更高的安全性。
AES+BASE64双重加密，解密 私钥，向量解析
linjingyg的博客
12-14 1786
　　使用AES加密，再使用base64编码加密。 　　具体细节请看注释。 　　/** 　　* 加密 　　* 　　* @param sSrc 加密的明文 　　* @param sKey 秘钥 　　* @param iv 向量 16 bytes 　　* @return 　　* @throws Exception 　　*/ 　　public static String Encrypt(String sSrc, String sKey,String iv) throws Exception..
前端base64加密
11-06
前端base64加密是将二进制数据转换为可打印的ASCII字符的一种编码方式。在前端开发中，base64加密常用于将图片、文件、字符串等数据转换为一串可传输的文本数据。 Base64加密过程如下： 1. 将需要加密的数据转换为二进制格式。 2. 将二进制数据按照6位一组进行分组。 3. 对每组6位二进制数据进行转换，转换为对应的Base64字符。 4. 如果分组中不足6位，则在末尾补0，转换为Base64字符时用"="进行填充。 5. 将转换后的Base64字符连接在一起，即得到加密后的字符串。 Base64加密的优点是可以将二进制数据转换为文本数据，方便传输和存储，同时由于使用了固定的字符集，可以在不同的系统、编程语言之间进行数据的交互，增加了数据的兼容性。 在前端开发中，可以使用JavaScript中的btoa()和atob()函数进行Base64加密和解密操作。btoa()函数将字符串转换为Base64编码，atob()函数将Base64编码解密为原始字符串。 需要注意的是，Base64加密并不能提供真正的加密功能，因为Base64加密的结果是可逆的。如果需要加密敏感信息，建议使用更为安全的加密方式，如AES或RSA加密算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值