PKCS7填充标准代码实现（C）

最新推荐文章于 2024-03-11 15:44:38 发布
最新推荐文章于 2024-03-11 15:44:38 发布
阅读量9.1k 收藏 11
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IOT2017/article/details/84141461
版权

在AES加密算法中，若加密数据不是16bytes的整倍数，则需要按照一定标准对数据进行填充，使其满足 DataSize % 16 = 0。本文是根据PKCS7标准进行数据填充。

PKCS7 填充标准摘要

PKCS5Padding和PKCS7Padding都是密钥的一种填充方式,即当密钥长度不足时的一种密钥填充方式。PKCS5Padding的填充方式为当密钥长度不足时,缺几位补几个0,eg.针对AES128,如果密钥为“1234567890”一共10位,缺6位,采用PKCS5Padding方式填充之后的密钥为“1234567890000000”,补了6个0.PKCS7Padding的填充方式为当密钥长度不足时,缺几位补几个几,eg.对于AES128,如果密钥为”1234567890”一共10位,缺6位,采用PKCS7Padding方式填充之后的密钥为“1234567890666666”。

源码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>     //使用memset函数要包含此库

#define MAXLEN  1024	// 定义一次性处理数据的最大size

/**
 * 加密明文如果不是16byte整倍数，则根据PKCS7标准填充至16byte整倍数
 * 参数 p:明文的字符串数组。
 * 参数 plen:明文长度
 * 返回padding后的明文长度
 */
 int PKCS7Padding(char *p, int plen)
 {
	int plen_after_Padding, remain, padding_num;
	char padding_value;

	if(plen % 16 == 0)
	{
        plen_after_Padding = plen;
        exit(0);
    }

	if(plen == 0)
	{
		printf("加密数据为空！\n");
        exit(0);
	}

	if( plen % 16 != 0)
	{
		remain = plen % 16;
		switch (remain)
		{
		    case 1:
				padding_num = 15;
				padding_value = 0x0F;
				break;

			case 2:
				padding_num = 14;
				padding_value = 0x0E;
				break;

			case 3:
				padding_num = 13;
				padding_value = 0x0D;
				break;

			case 4:
				padding_num = 12;
				padding_value = 0x0C;
				break;

			case 5:
				padding_num = 11;
				padding_value = 0x0B;
				break;

			case 6:
				padding_num = 10;
				padding_value = 0x0A;
				break;

			case 7:
				padding_num = 9;
				padding_value = 0x09;
				break;

			case 8:
				padding_num = 8;
				padding_value = 0x08;
				break;

			case 9:
				padding_num = 7;
				padding_value = 0x07;
				break;

			case 10:
				padding_num = 6;
				padding_value = 0x06;
				break;

			case 11:
				padding_num = 5;
				padding_value = 0x5;
				break;

			case 12:
				padding_num = 4;
				padding_value = 0x04;
				break;

			case 13:
				padding_num = 3;
				padding_value = 0x03;
				break;

			case 14:
				padding_num = 2;
				padding_value = 0x02;
				break;

			case 15:
				padding_num = 1;
				padding_value = 0x01;
				break;

            default:
                break;
		}
	}
    plen_after_Padding = plen + padding_num;

	for(int i = plen; i < plen_after_Padding; i++)
	{
		p[i] = padding_value;
	}

	p[plen_after_Padding] = '\0';	//明文原来就是以'\0'结尾，但是被填充冲掉了，所以填充完成后需要在数据最后加上'\0'

	return plen_after_Padding;
 }

 /**
  * 从命令行获取数据并将结尾换行符替换为'\0'
  */

 void getString(char *str, int len)
 {

    int slen = read(0, str, len);
    for(int i = 0; i < slen; i++)
    {
        if(str[i] == '\n')
        {
            str[i] = '\0';
            break;
        }
    }
}


int main()
{
    int plen, after_padding_plen;
    char *p;

    p = (char*)malloc(MAXLEN*(sizeof(char*)));		//申请一块内存用来存放明文数据
    memset(p,0,MAXLEN);

    printf("请输入一串字符：\n");

    getString(p,MAXLEN);

    for(plen = 0; p[plen] != '\0'; plen++ );    //获取输入明文数据字符串长度(不包含换行符)

    printf("输入明文长度为：%d 个字节\n", plen);
    
    after_padding_plen = PKCS7Padding(p,plen);

    printf("按照PKCS7标准填充后的明文长度为：%d 个字节\n", after_padding_plen);

    for(int i =0; p[i]!='\0';i++)
    {
        printf("p[%d] = 0x%x\n",i,p[i]);
    }

	free(p);		//释放内存

}

解密数据cutting填充数据

/**
 * 将解密后的明文填充数据去掉，还原数据
 * int PKCS7Cutting(char *p, int plen)
 * 参数 p:解密后明文的字符串数组。
 * 参数 plen:解密后明文长度
 * 返回cutting后的明文长度
 */
 int  PKCS7Cutting(char *p, int plen)
 {
    int plen_after_cutting;

    if(p[plen-1] == 0x01)
    {
        plen_after_cutting = plen -1;
    }
    else if(p[plen-1] == 0x02)
    {
        if(p[plen-2] == 0x02)
            plen_after_cutting = plen -2;
    }
    else if(p[plen-1] == 0x03)
    {
        if((p[plen-2] == 0x03) && (p[plen-3] == 0x03))
            plen_after_cutting = plen -3;
    }
    else if(p[plen-1] == 0x04)
    {
        if((p[plen-2] == 0x04) && (p[plen-3] == 0x04) && (p[plen-4] == 0x04))
            plen_after_cutting = plen -4;
    }
    else if(p[plen-1] == 0x05)
    {
        if((p[plen-2] == 0x05) && (p[plen-3] == 0x05) && (p[plen-4] == 0x05) && (p[plen-5] == 0x05))
            plen_after_cutting = plen -5;
    }
    else if(p[plen-1] == 0x06)
    {
        if((p[plen-2] == 0x06) && (p[plen-3] == 0x06) && (p[plen-4] == 0x06) && (p[plen-5] == 0x06) && (p[plen-6] == 0x06))
            plen_after_cutting = plen -6;
    }
    else if(p[plen-1] == 0x07)
    {
        if((p[plen-2] == 0x07) && (p[plen-3] == 0x07) && (p[plen-4] == 0x07) && (p[plen-5] == 0x07) && (p[plen-6] == 0x07) && (p[plen-7] == 0x07))
            plen_after_cutting = plen -7;
    }
    else if(p[plen-1] == 0x08)
    {
        if((p[plen-2] == 0x08) && (p[plen-3] == 0x08) && (p[plen-4] == 0x08) && (p[plen-5] == 0x08) && (p[plen-6] == 0x08) && (p[plen-7] == 0x08) && (p[plen-8] == 0x08))
            plen_after_cutting = plen -8;
    }
    else if(p[plen-1] == 0x09)
    {
        if((p[plen-2] == 0x09) && (p[plen-3] == 0x09) && (p[plen-4] == 0x09) && (p[plen-5] == 0x09) && (p[plen-6] == 0x09) && (p[plen-7] == 0x09) && (p[plen-8] == 0x09) && (p[plen-9] == 0x09))
            plen_after_cutting = plen -9;
    }
    else if(p[plen-1] == 0x0A)
    {
        if((p[plen-2] == 0x0A) && (p[plen-3] == 0x0A) && (p[plen-4] == 0x0A) && (p[plen-5] == 0x0A) && (p[plen-6] == 0x0A) && (p[plen-7] == 0x0A) && (p[plen-8] == 0x0A) && (p[plen-9] == 0x0A) && (p[plen-10] == 0x0A))
            plen_after_cutting = plen -10;
    }
    else if(p[plen-1] == 0x0B)
    {
        if((p[plen-2] == 0x0B) && (p[plen-3] == 0x0B) && (p[plen-4] == 0x0B) && (p[plen-5] == 0x0B) && (p[plen-6] == 0x0B) && (p[plen-7] == 0x0B) && (p[plen-8] == 0x0B) && (p[plen-9] == 0x0B) && (p[plen-10] == 0x0B) && (p[plen-11] == 0x0B))
            plen_after_cutting = plen -11;
    }
    else if(p[plen-1] == 0x0C)
    {
        if((p[plen-2] == 0x0C) && (p[plen-3] == 0x0C) && (p[plen-4] == 0x0C) && (p[plen-5] == 0x0C) && (p[plen-6] == 0x0C) && (p[plen-7] == 0x0C) && (p[plen-8] == 0x0C) && (p[plen-9] == 0x0C) && (p[plen-10] == 0x0C) && (p[plen-11] == 0x0C) && (p[plen-12] == 0x0C))
            plen_after_cutting = plen -12;
    }
    else if(p[plen-1] == 0x0D)
    {
        if((p[plen-2] == 0x0D) && (p[plen-3] == 0x0D) && (p[plen-4] == 0x0D) && (p[plen-5] == 0x0D) && (p[plen-6] == 0x0D) && (p[plen-7] == 0x0D) && (p[plen-8] == 0x0D) && (p[plen-9] == 0x0D) && (p[plen-10] == 0x0D) && (p[plen-11] == 0x0D) && (p[plen-12] == 0x0D) && (p[plen-13] == 0x0D))
            plen_after_cutting = plen -13;
    }
    else if(p[plen-1] == 0x0E)
    {
        if((p[plen-2] == 0x0E) && (p[plen-3] == 0x0E) && (p[plen-4] == 0x0E) && (p[plen-5] == 0x0E) && (p[plen-6] == 0x0E) && (p[plen-7] == 0x0E) && (p[plen-8] == 0x0E) && (p[plen-9] == 0x0E) && (p[plen-10] == 0x0E) && (p[plen-11] == 0x0E) && (p[plen-12] == 0x0E) && (p[plen-13] == 0x0E) && (p[plen-14] == 0x0E))
            plen_after_cutting = plen -14;
    }
    else if(p[plen-1] == 0x0F)
    {
        if((p[plen-2] == 0x0F) && (p[plen-3] == 0x0F) && (p[plen-4] == 0x0F) && (p[plen-5] == 0x0F) && (p[plen-6] == 0x0F) && (p[plen-7] == 0x0F) && (p[plen-8] == 0x0F) && (p[plen-9] == 0x0F) && (p[plen-10] == 0x0F) && (p[plen-11] == 0x0F) && (p[plen-12] == 0x0F) && (p[plen-13] == 0x0F) && (p[plen-14] == 0x0F) && (p[plen-15] == 0x0F))
            plen_after_cutting = plen -15;
    }
    else
    {
        plen_after_cutting = plen;
    }

    return plen_after_cutting;

 }
汽车电子开发攻城狮
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
AES128 ECB、CBC模式加密解密函数（C语言实现 -单片机/嵌入式）
04-24
基于c语言实现AES128_ECB、AES128_CBC两种模式加密，数据使用PKCS7Padding算法对齐，程序已验证
封装DES_CBC加解密算法实现PKCS7填充
Lee notes
02-19 652
#include <iostream> #include <openssl/des.h> using namespace std; //交易数据 struct Slip { char from[16] = { 0 }; //A=>B 10000 char to[16] = { 0 }; //篡改为 B=>A 10000 long long amount = 0; }; static const_DES_cblock key = "1234
数据填充规则之PKCS7
CHYabc123456hh的博客
12-20 925
程序输入的数据全部使用Hex 十六进制的格式 IV 00000000000000000000000000000000 Source(加密数据) char input_date[] = {'a','a','a','a',.......} Ascll编码 需要转16进制 input_data303030303030303030303030303030CC CC表示此位无数据 注意事项：考虑到程序采用 PKCS#7填充，填充方式为当数据长度不足数据块长度时，缺少几个元素，就使用几个几的十...
OpenSSL之AES加密算法-ECB模式
最新发布
逆光倾城的博客
03-11 277
OpenSSL库中AES-ECB算法的使用
C++调用openssl实现DES加密解密cbc模式 zeropadding填充方式 pkcs5padding填充方式 pkcs7padding填充方式...
weixin_30388677的博客
12-26 1590
============================================== 　　　　des cbc 加密　zeropadding填充方式 ============================================== //加密 cbc zeropadding 自己实现 std::string des_cbc_zero_encrypt(const s...
C语言实现DES+EBC+PKSC5/PKSC7加解密算法详解
小康师兄
03-18 3917
C语言实现DES+EBC+PKSC5/PKSC7加解密算法详解
C++使用openssl对AES-256-ECB PKCS7 加解密
铍镁钙锶钡镭
10-16 1289
【代码】C++使用openssl对AES-256-ECB PKCS7 加解密。
SpringBoot AES加密 PKCS7Padding 模式
代码小疯子
02-13 1332
AES的区块长度固定为128位，密钥长度则可以是128 bit，192 bit 或256位 bit
加密填充方式（pkcs5/pkcs7/ISO10126填充/ANSIX923填充/Zeros填充）外部填充
07-17 1445
c++ 填充结构代码
PKCS7
qq_42873640的博客
06-02 4562
Enveloped-data 内容类型 enveloped-data内容类型由任意类型的加密内容和加密的一个/多个接收者的内容加密密钥组成。加了密的内容和加了密的内容加密密钥一起构成了接收者的“数字信封”。 Enveloped-data的组建过程分以下几步： 随机产生一个对应于特定加密算法的内容加密密钥。 内容加密密钥用每个接收者的公钥加密。 对于每一个接收者，把加了密的内容加密密钥和接收者的其他信息放入RecipientInfo值中。 用内容加密密钥加密内容。(内容加密可能会需要填充一些块；见Secti
aes加密/解密，cbc模式PKCS#5 padding填充方式
csdndys的博客
11-24 4959
AES(高级加密标准)是一种广泛使用的对称密钥加密算法。
AES 示例(CBC算法模式 PKCS5填充模式)
08-17
AES 示例(CBC算法模式 PKCS5填充模式) delphi 和java 源码，delphi可能支持delphi 7 。后续需要自己看代码
AES-128-ECB-PKCS5Padding.zip
04-07
此次AES文件只实现AES128-ECB加密方式，实现以PKCS5Padding填充方式，也可通用PKCS7Padding填充方式，也可自行修改实现NOPadding填充。以C语言方式实现加密方法，国际标准方式实现，可自行网上搜索在线验证方式验证...
AES128_ECB_PKCS5Padding-master.zip
04-27
C/C++代码 AES128/ECB/PKCS5Padding 的实现 附各类加解密网站：http://tool.chacuo.net/cryptaes
AES_CBC_PKCS5加解密 MD5加密
07-05
AES加解密，采用CBC模式 PKCS5填充模式 可提取C源码 用QT可直接编译使用
C++使用AES+Base64算法对文本进行加密
热门推荐
蓝色天空
02-18 1万+
使用AES算法和Base64实现具体的文本加密功能。 采用AES算法的CBC模式，16位秘钥，PKCS7Padding填充方案对文本进行加解密。此方案可防止一些比较关键的文本暴露， 也可以用于服务器通信间的加密，防止通信协议和信息的泄露。 Main.cpp #include #include "AES.h" #include "Base64.h" using namespace
PKCS7填充（C语言实现）
XingXingYeGuDu的博客
07-01 3372
1.用途：aes128 EBC 数据填充 头文件 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> 源码： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> /*************
可以相互解密的C#版及C++版DES算法代码(包括ECB、CBC模式，Zeros、PKCS7填充，以及Base64编解码)
~~
09-10 6260
稍后补代码。
pkcs7填充和zeros填充
萧海的博客
07-03 226
不足十六位长度的，剩余字节以剩余的长度作为填充内容，如。不足十六位长度的，剩余字节以0x00作为填充内容，如。hello world 填充为。hello world 填充为。
上述代码的PKCS#7 填充具体是怎么做的
07-17
PKCS#7填充是一种常用的块密码填充方案，用于将数据填充到块长度的倍数。具体实现PKCS#7填充的步骤如下： 1. 确定需要填充的字节数：计算数据长度与块长度的余数，得到需要填充的字节数。 2. 创建填充字节：创建一个字节，其值等于需要填充的字节数。 3. 将填充字节复制到数据末尾：将填充字节复制到数据的末尾，以达到块长度的倍数。 以下是一个示例函数，展示如何实现PKCS#7填充： ```c void pkcs7_padding(unsigned char *data, size_t data_len, size_t block_size) { size_t padding_len = block_size - (data_len % block_size); unsigned char padding = (unsigned char)padding_len; for (size_t i = 0; i < padding_len; i++) { data[data_len + i] = padding; } } ``` 在上述示例代码中，`pkcs7_padding`函数接受要填充的数据、数据长度和块长度作为参数。它计算需要填充的字节数，并创建填充字节。然后，将填充字节复制到数据的末尾。 请注意，上述代码只展示了PKCS#7填充的基本实现。在实际使用时，还应考虑错误处理、边界情况和其他安全性考虑。确保在使用PKCS#7填充时，参考相关的标准和实践，并在必要时进行适当的修改和调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

汽车电子开发攻城狮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值