在线aes加密_aes加密用法

AES128_CBC_NoPading加密、sha256withRSA签名

unsigned char xdata tempbuf[16];

AES加密中重要的两个参数KEY、IV且都是16位数字，我这里将IV默认为16个0

在线aes加密_aes加密用法

加密的数据data长度必须是16的倍数，否则会加密失败，加密前需要检查是否补0处理

主要用到的函数 CCCrypt：

解密先需要将字符串通过base64解码转为NSData后进行 AES128解密

sha256wi}// Keysize larger than 24 bytes, ie. larger that 192 bits?thRSA签名

RSA签名需要Mac端生成公钥和私钥，由于我们项目是后台申请的给了公钥私钥字符串，所以是通过字符串转成SecKeyRef格式。

一般客户端只用来对数据加签，后台验签。

frameworkDemo地址

最近项目用到了，看了很多文章才搞出来，有不对的请指正，谢谢！

对于加密的总结（AES,RSA）

主要用到的函数SecKeyRawSign

跟第三方联调的时候会碰到各种加密算法，所以总结一下。

AES不是将拿到的明文一次性加密，而是分组加密，就是先将明文切分成长度相等的块，每块大小128bit，再对每一小块进行加密。那么问题就来了，并不是所有的原始明文串能被等分成128bit，例如原串大小200bit，那么第二个块只有72bit，所以就需要对第二个块进行填充处理，让第二个块的大小达到128bit。常见的填充模式有

不进行填充，要求原始加密串大小必须是128bit的整数倍；

假设块大小8字节，如果这个块跟8字节还n个字节，那么就在原始块填充n，直到满8字节。例：块{1,2,3}，跟8字节了5个字节，那么补全后的结果{1,2,3,5,5,5,5,5}后面是五个5，块{1,2,3,..7}跟8字节了1个字节，那么补全后就是{1,2,3,...,7,1},就是补了一个1。

如果恰好8字节又选择了PKCS5Padding填充方式呢？块{1,2,3...8}填充后变成{1,2,3...8,8...8}，原串后面被补了8个8，这样做的原因是方便解密，只需要看一位就能算出原块的大小是多少。

跟PKCS5Padding的填充方式一样，不同的是，PKCS5Padding只是对8字节的进行填充，PKCS7Padding可以对1~256字节大小的block进行填充。openssl里aes的默认填充方式就是PKCS7Padding

AES有多种加密模式，包括：ECB,CBC,CTR,OCF,CFB,最常见的还是ECB和CBC模式。

最简单的一种加密模式，每个块进行加密，块与块之间加密互不影响，这样就能并行，效率高。

虽然这样加密很简单，但是不安全，如果两个块的明文一模一样，那么加密出来的东西也一模一样。

openssl的相关函数：

CBC模式中引入了一个新的概念，初始向量iv。iv的作用就是为了防止同样的明文块被加密成同样的内容。原理是个明文块跟初始向量做异或后加密，第二个块跟个密文块做异或再加密，依次类推，避免了同样的块被加密成同样的内容。

openssl相关函数：

敲黑板！！ 所以跟第三方对接的时候，如果对面说他们用aes加密，务必对他们发起灵魂三问：

签名的作用是让接受方验证你传过去的数据没有被篡改；加密的作用是保证数据不被窃取。

原理：你有一个需要被验签的原串A。

步骤一：选择hash算法将A进行hash得到hash_a；

步骤二：将hash_a进行加密，得到加密值encrypt_a；

步骤三：将原串A和加密的encrypt_a发给第三方，第三方进行验签。第三方先解密encrypt_a，得到一个hash值hash_a1，然后对原串A使用同样的hash算法进行hash，得到的即为加密前的hash_a,如果hash_a = hash_a1, 那么验签成功。

rInvShiftRows( block );sa使用私钥对信息加密来做签名，使用公钥解密去验签。

openssl相关函数：

注意：两个函数中的m，是原串hash后的值，type表示生成m的算法，例如NID_sha256表示使用sha256对原串进行的hash，返回1为签名成功或者验签成功，-1位为失败。

再次敲黑板！！ 所以如果第三方说使用rsa验签，要让对方告知他们的hash算法。

首先明确，私钥加密不等于签名。加密的时候，使用使用公钥加密，第三方使用你的私钥进行解密。

openssl里公钥加密函数为RSA_public_encrypt，私钥解密函数为RSA_private_decrypt，具体的可以自己去查看下文档。

rsa也涉及到了填充方式，所以对接的时候也要问清楚

在使用公钥进行加密时，会发现每次加密出的结果都不一样，但使用私钥加密时，每次的结果都一样，网上查了一圈，说是因为填充方式的原因。

文档说明：

那么为什么一定要使用私钥做签名，公钥做加密，而不是公钥做签名，私钥做加密呢？

举个栗子：

AES和ECC的混合加密

Rcon = (Rcon << 1) ^ (Rcon & 0x80 ? BPOLY : 0);

在上面对AES加密的初步认知中，我们知道AES加密需要一个key，加减密双方都需要知道，那这个key怎么设定好？看一下下面的一种场景：

#define ROUNDS 10 //!< Number of rounds.

在社交的APP中，一般对聊天内容都会是加密的，A和B聊天，A和C聊天。如果这个Key都是固定的，那么是不是意味着:如果B通过蛮力等方法某段聊天信息，拿到了和A之间的AES_Key，再抓包劫持了A和C的传输内容，就可以轻易的A和C之间的内容，显然这种做法是不安全的。

所以安全的模式是A和B，A和C，B和C， 他们聊天内容加密的key都是不同的(再安全点加密方式也可以有区别)。那样即使A和B的加密被了，A和C，B和C等其他的聊天记录都不会被轻易。

那怎么传送这个key，肯定不是明文传送，那用哪一种加密方式更好点，一般都是非对称加密，如RSA、ECC等。

非对称加密:加减密的密钥不同,分私钥和公钥。

主流的非对称加密方式如：RSA和ECC

这边为什么选用ECC，客观因素有很多：

安全性高

有研究表示160位的椭圆密钥与1024位的RSA密钥安全性相同，256位相当于3072位。

加密效率比较

1)计算负荷:在私钥的加密解密速度上,速度更快。

2)密钥大小:存储空间占用小。

3)带宽:带宽要求低.

AES的Key经过接收方公钥加密和AES加密的内容 一起发送

给接收方，接收方通过自己私钥先将加密后的AES_KEY解密，再通过解密得到的原始AES_KEY，并用该key解密发送方发送的内容，得到明文。

如下图所示:

上面这种加密方式性能上是杠杠的，虽然自己没有用具体的数据测试过，但也找过很多资料看了，加密算法速度高于

扩展：AES和ECC的混合加密还有一种特殊的场景，先来看一下ECC 数学函数 Q=dG; (Q是公钥 d是私钥 G是他们之间的关系)；Q1 = d1G1; Q2=d2G2;那么能推出 key＝Q1d2G2 = Q2d1G1;

有没有亮点 1的公钥和2的私钥 2的公钥和1的私钥 他们能得到一个相同的值 key。那么我们能不能把这个相同的key 作为他们之间AES加减密的key呢？

那我们是不是可以在这个发送过程少传一个AES密钥key‘的参数，那在传输的过程透露的信息是不是有可以少，安全性是不是会高一点呢？

32位的ECC加密 和32位AES解密，经实践可以使用上述方法。

路由器加密算法tkip和aes有什么区别

// Inverse in GF(2^8).

tkip和aes都是算法，后者比前者新一点，这个项目设置选择自动，用以增加安全性，而不用指定选择；如果满意，请给分！

tkip和aes都是算法，aes也叫CCMP，是恰好我有。能运行的，C语言的。增强型算法，其加密等级要比TKIP高。

文件加密软件哪个用

0x02, 0x03, 0x01, 0x01

透明加密技术是近年来针对企业文件保密需求应运而生的一种文件加密技术。所谓透明，是指对使用者来说是未知的。当使用者在打开或编辑指定文件时，系统将自动对未加密的文件进行加密，对已加密的文件自动解密。文件在硬盘上是密文，在内存中是明文。一旦离开使用环境，由于应用程序无法得到自动解密的服务而无法打开，从而起来保护文件内容的效果。

透明加密有以下特点：

自动强制加密：安装系统后，所有指定类型文件都是强制加密的；

使用方便习惯：不影响原有作习惯，不需要限止端口；

原有习惯保持：内部交流时不需要作任何处理便能交流；

对外严禁泄露：一旦文件离开使用环境，文件将自动失效，从而保护知识产权。

1、为什么需要透明文件加密

每个单位都有很重要的数据文件；比如对企业来说财务报表、用户名单、进货渠道、设计图纸、投标文件等等；那么这些资料你允许别人随意拿走吗？

如果你不想被拿走，你可能部署了比如网络等方式，但远远不够的，因为人是活的，既然你不想别人拿走，人家要拿的时候就千方百计的方式了；防不胜防；比如，压缩后发个邮件出去，修改名字后你也看不懂这个是什么再QQ传输出去；

那么你就result = temp ^ 0x63; // Start with adding a vector in GF(2).应加密，比如采用压缩加密方式，或把文件夹加密，可是你会很快发现不现实也无什么用；比如压缩加密好了，你总是要打开的，要是你天天都要用的，你就烦了每天都加密解密；再比如假如你这个是设计的图纸，你的员工设计的，他手里还有一份呢，他抄走呢？再比如，一个大型的设计可能很多人需要参加，那你加密别人就无法参与了，可你解密后别人立即抄走了；也就是说你打开他们就抄走了，你不打开别人就无法工作了；这个时候，你就需要透明文件加密了；

2、什么叫透明文件加密

透明文件加密区别于常见的文件密码加密方式；对你想加密的机密文件进行保护时，系统在不改变用户原有工作流程和文件使用习惯的前提下，对需要保护的进程生成的所有文件(无论该文件原来是明文还是密文)进行强制加密保护。简单说：就是对你需要加密的文件自动加密又不改变原来的作习惯，而能看的人又无法抄走（即使非法出去都是乱码的无法看的加密格式的文件）；这样，你的员工可以像往常一样工作和参与，但却无法抄走（无论是网络方式、U盘方式、或改名转存方式等等）；除非获得授权；

3、透明加密的基本功能

自动备份加密文档，防止恶意删除； 全程记录文件作行为；

有效控制传输途径：设备限制（USB存储设备、光驱/软件只读或禁用，打印机禁用）；禁止截屏、拖拽；禁止内容； 三重密钥管理，安全可靠； 灵活离线策略，在方便员工短期外出、在家办公或长期出的同时，仍防泄密；在线解密申请，授权高管解密后方可文件外发；

4、透明文件加密软件的部署

一般安装都很简单，在管理端安装一个引擎驱动，用于管理以及建立密钥等；被加密电脑安装工作站，然后就开始根据你管理端设置的规则自动加密了；剩余的只是对管理过程

公司终端、电脑文件资料透明加密，防泄密软件利用驱动层透明加密技术实现电子文件安全加密的防护产品，是一套从源头上保障数据安全和使用安全的加密系统。该系统遵循基于文件生命周期安全防护的思想，集成了密码学、访问控制和审计跟踪等技术手段，对企事业单位电子文件的存储、访问、传播和处理过程实施全方位保护。

强制加密：安装系统后，所有指定类型文件都是强制加密的；

使用方便：不影响原有作习惯，不需要限止端口；

于内无碍：内部交流时不需要作任何处理便能交流；

对外受阻：一旦文件离开使用环境，文件将自动失效，从而保护知识产权。

所谓透明，是指对使用者来说是无感知的。当使用者在打开或编辑指定文件时，系统将自动对未加密的文件进行加密，对已加密的文件自动解密。文件在硬盘上是密文，在内存中是明文。一旦离开使用环境，由于应用程序无法得到自动解密的服务而无法打开，从而起来保护文件内容的效果。

透明加密技术是与内核驱动层紧密结合的一种技术，它工作于 作系统 的底层。通过应用程序对文件的作，在打开文件时自动对密文进行解密，在写文件时自动将内存中的明文加密写入存储介质。从而保证存储介质上的文件始终处于加密状态。

由@德人合科技——提供软件系统及技术支持！

文件加密软件有很多好用的，我们使用安秉信息文件加密，软件功能强大，支持各种数据的加密保护。

文件加密软件功能介绍：

1、泄密控制：

对打开加密文档的应用程序进行如下控制：打印、内存窃取、拖拽和剪贴板等，用户不能主动或被动地泄漏机密数据。

2、审批管理：

支持共享、离线和外发文档，可以按照实际工作需求，配置是否对这些作进行强制审批。用户在执行加文档的共享、离线和外发等作时，将视的权限许可，可能需要经过审批审批。

3、离线文档管理：

客户端需要连接才能访问加密文档。通过本功能制作离线文档，即使客户端未连接，用户也可以阅读这些离线的文档。根据权限许可，离线文档可能需要经过审批审批离线时，可以控制客户端的离线时间和离线时是否允许打印。

4、外发文档管理：

外部人员不能阅读加密文档的内容。本功能制作外发文档，即使在未安装客户端的机器上，也可以阅读这些外发的文档。根据权限许可，外发文档可能需要经过审批审批外发的文档，和内部使用一样，受到加密保护和泄密控制，不会造成文档泄露，同时增加口令和机器码验证，增强外发文档的安全性。

在市场上有很多免费或可实用的透明加密软件可供选择。这些软件都能实现在传输或存储时自动加密，不影响性能。这些软件包括域之盾、网管家、eraCrypt、BitLocker等。

1.域之盾

域之盾是一家企业级别的免费透明加密技术软件，它能实现对word、ppt、PDF、ps、CAD、编程开发等200余项功能加密。加密模式可以分为透明加密、半透明加密、只解密不解密三种模式。还可以设置在终端电脑上显示加密文件图标和自动加密剪贴板内容等，从多角度保护核心文件机密。

2.网管家

网管家支持同时对上千台电脑同时管控，从源头上保障数据文件的安全，软件可以实现防泄密和上网行为管理功能，是一款性价比比较高的软件。

3.VeraCrypt

VeraCrypt是一个开源的加密软件，可以对整个磁盘或选定的文件夹进行加密。它支持多种加密算法，包括AES、Twofish和Serpent等。

4.BitLocker

BitLocker是微软Windows作系统中的加密软件，可以对整个磁盘或选定的文件夹进行加密。

总之，以上这些免费的透明加密技术软件都是非常值得考虑的选择，可以提供强大的隐私保护功能。在选择时，应根据自己的需求和作系统进行选择。

用c#做aes加密 为什么在线解密解不了

r2 = column[0] ^ column[1] ^ column[3];

///

state[ 1 + 04 ] = temp;

/// Aes解密

///

///

源字符串

///

aes密钥，长度必须32位

/// 解密后的字符串

public static string DecryptAes(string source, string key)

{using (AesCryptoServProvider aesProvider = new AesCryptoServProvider())

{aesProvider.Key = GetAesKey(key);

aesProvider.Mode = CipherMode.ECB;

aesProvider.Padding = PaddingMode.PKCS7;

using (ICryptoTransform cryptoTransform = aesProvider.CreateDecryptor())

{byte[] inputBuffers = Convert.FromBase64String(source);

byte[] results = cryptoTransform.TransformFinalBlock(inputBuffers, 0, inputBuffers.Length);

aesProvider.Clear();

return Encoding.UTF8.GetString(results);

}}

}

有什么好用的加密软件？

openssl 默认的数据填充方式是 PKCS7，为兼容 mcrpty 也提供处理 "0" 填充的数据的模式，具体为下：

说到隐私保护，文件加密，以下就一款免费透明加密软件，有需求的可以使用一下再做评论。

红线隐私保护系统目前是一款PC平台的加密工具，只要平时的工作和生活中，你有需要对自己重要的文件数据加密的，你就可以使用到。该软件属于免费软件，可以加密很多类型的文件，只要应用在红线授权的范围，当然应用也在不断地更新中，将会逐渐产生更多的新功能，例如正在研发的文件分享功能。该软件没有太复杂的作步骤，简单易用，编辑保存即被加密。透过高度的算法，加密性极高，即使也无法被。绿色，安全，无毒，可放心使用。

红线隐私保护系统的特点：透明加密。

所谓透明加密 是指文件被加密的过程中，文件作者感觉不出这个过程，所以对用户来讲是透明的，这样在电脑记录有信息资料的电子文档虽然处于加密状态，但不影响用户使用。而一旦用户推出保护系统，文件因为被加密便无法打开。这意味着这些信息只能是用户自己查阅使用，有效防止意外泄露

红线隐私保护系统是一款功能强大的程序加密文件，该软件具有自己专业的加密技术，采用加密算法AES256,512，SM2、SM3等，能够对所有的应用程序进行加密作，具有高强度的密码计算功能，可以在软件中生成自己的随机密码，采用数字、字符、特殊符号等复杂的密码组合方式，能够设计出最安全的密码程序，该软件的作模式非常简单，可以直接鼠标点击文件进行加密，也可以用批量加密方式对多个文件同时加密，支持设置不同的颜分加密的安全程度，文件被红线隐私系统加密后会显示不同状态的加密图标，用以区分不同的工作状态。

使用易通文件夹锁软件。支持所有windows系统。可以加密文件夹，加密文件，加密磁盘(磁盘分区加密和USB锁），安全易用。可隐藏加密，也可加锁加密。加密后的资料防删除，。

可以用360密盘这个工具，360密盘可以针对电脑磁盘中的某一部分数据进行加密，很好地保护你不想被查看的那部分隐私资料，再次查看需// Use 0x03 as root for exponentiation and logarithms.要通过软件输入解密码，是一款安全性很高的工具。

数据防泄密软件市场是一个非常专业的领域，国内市场知名品牌也就屈指可数的几家而已。您可以了解一下上海迅软信息科技有限公司防泄密软件，软件还是不错的，效果得到了广大用户的认可。上海迅软的加密软件有4道防线，在安全加密方面做的很到位。道防线：端口管控管控USB端口拷贝、刻录、打印行为，控制所有的终端端口外泄第二道防线：数据加密源头解决“信息安全”问题，杜绝数据泄密强制对计算机生成的文档图纸、源码、办公文档等数据自动透明加密，加密后仅在指定范围内进行数据交互；所有加密过程均为自动和透明，不影响原有工作习惯和管理流程；全生命周期、全流程保护，新建、修改、传递、存储、备份均加密。

这种照片对私密度要求比较高，个人Symantec Endpoint Encryption，网上有版；

软件的前身是PGP，采用不对称加密；

密码建议：区分字母大小写、带有数字和符号混合，且密码不低于16位；

严格意义上说，任何加密都是不安全的。

那用这个吧：，绿色简单，解压后，放在你要加密的文件夹里，双击输入密码即可。

你把插件卸了也不行吗,我是直接用的绿色免安装版的,用完之后用优化把"宏杰加密"的右键显示给删掉就根本看不出有这个软件出现过.

少量的可以WinRAR + 建议20位以上复杂密码。比较多可以用 VeraCrypt。

我本来就用的这个安装版的，但它老是开机启动禁都禁不了，所以就想换换。

求AES算法加密C语言完整程序

#include

#include "aes.h"

#include "commo.h"

#define byte unsigned char

#define BPOLY 0x1b //!< Lower 8 bits of (x^8+x^4+x^3+x+1), ie. (x^4+x^3+x+1).

#define BLOCKSIZE 16 //!< Block size in number of bytes.

#define KEYBITS 128 //!< Use AES128.

#define KEYLENGTH 16 //!< Key length in number of bytes.

byte xdata block1[ 256 ]; //!< Workspace 1.

byte xdata block2[ 256 ]; //!< Worksapce 2.

byte xdata powTbl; //!< Final location of exponentiation lookup table.

byte xdata logTbl; //!< Final location of logarithm lookup table.

byte xdata sBox; //!< Final location of s-box.

void CalcPowLog( byte powTbl, byte logTbl )

byte xdata t = 1;

do {

powTbl[i] = t;

logTbl[t] = i;

i++;

// Muliply t by 3 in GF(2^8).

t ^= (t << 1) ^ (t & 0x80 ? BPOLY : 0);

} while( t != 1 ); // Cyclic properties ensure that i < 255.

powTbl[255] = powTbl[0]; // 255 = '-0', 254 = -1, etc.

}void CalcSBox( byte sBox )

{byte xdata i, rot;

byte xdata temp;

byte xdata result;

i = 0;

do {

if( i > 0 ) {

temp = powTbl[ 255 - logTbl[i] ];

temp = 0;

}// Affine transformation in GF(2).

for( rot = 0; rot < 4; rot++ ) {

// Rotate left.

temp = (temp<<1) | (temp>>7);

// Add rotated byte in GF(2).

result ^= temp;

}// Put result in table.

sBox[i] = result;

} while( ++i != 0 );

}void CalcSBoxInv( byte sBox, byte sBoxInv )

byte xdata j = 0;

// Iterate through all elements in sBoxInv using i.

do {

// Search through sBox using j.

cleardog();

do {

// Check if current j is the inverse of current i.

if( sBox[ j ] == i ) {

// If so, set sBoxInc and indicate search finished.

j = 255;

}} while( ++j != 0 );

} while( ++i != 0 );

}void CycleLeft( byte row )

{// Cycle 4 bytes in an array left once.

byte xdata temp = row[0];

row[0] = row[1];

row[1] = row[2];

row[2] = row[3];

row[3] = temp;

}void InvMixColumn( byte column )

{byte xdata r0, r1, r2, r3;

r0 = column[1] ^ column[2] ^ column[3];

r1 = column[0] ^ column[2] ^ column[3];

r3 = column[0] ^ column[1] ^ column[2];

column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);

column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);

column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);

column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);

r0 ^= column[0] ^ column[1];

r1 ^= column[1] ^ column[2];

r2 ^= column[2] ^ column[3];

r3 ^= column[0] ^ column[3];

column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);

column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);

column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);

column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);

r0 ^= column[0] ^ column[2];

r1 ^= column[1] ^ column[3];

r2 ^= column[0] ^ column[2];

r3 ^= column[1] ^ column[3];

column[0] = (column[0] << 1) ^ (column[0] & 0x80 ? BPOLY : 0);

column[1] = (column[1] << 1) ^ (column[1] & 0x80 ? BPOLY : 0);

column[2] = (column[2] << 1) ^ (column[2] & 0x80 ? BPOLY : 0);

column[3] = (column[3] << 1) ^ (column[3] & 0x80 ? BPOLY : 0);

column[0] ^= column[1] ^ column[2] ^ column[3];

r0 ^= column[0];

r1 ^= column[0];

r2 ^= column[0];

r3 ^= column[0];

column[0] = r0;

column[1] = r1;

column[2] = r2;

column[3] = r3;

}byte Multiply( unsigned char num, unsigned char factor )

{byte mask = 1;

byte result = 0;

while( mask != 0 ) {

// Check bit of factor given by mask.

if( mask & factor ) {

// Add current multiple of num in GF(2).

result ^= num;

}// Shift mask to indicate next bit.

mask <<= 1;

// Double num.

num = (num << 1) ^ (num & 0x80 ? BPOLY : 0);

}return result;

}byte DotProduct( unsigned char vector1, unsigned char vector2 )

{byte result = 0;

result ^= Multiply( vector1++, vector2++ );

result ^= Multiply( vector1++, vector2++ );

result ^= Multiply( vector1++, vector2++ );

result ^= Multiply( vector1 , vector2 );

return result;

}void MixColumn( byte column )

{byte xdata row[8] = {

0x02, 0x03, 0x01, 0x01,

}; // Prepare first row of matrix tw, to eliminate need for cycling.

byte xdata result[4];

// Take dot products of each matrix row and the column vector.

result[0] = DotProduct( row+0, column );

result[1] = DotProduct( row+3, column );

result[2] = DotProduct( row+2, column );

result[3] = DotProduct( row+1, column );

// Copy temporary result to original column.

column[0] = result[0];

column[1] = result[1];

column[2] = result[2];

column[3] = result[3];

}void SubBytes( byte bytes, byte count )

{do {

bytes = sBox[ bytes ]; // Substitute ry byte in state.

bytes++;

} while( --count );

}void InvSubBytesAndXOR( byte bytes, byte key, byte count )

{do {

// bytes = sBoxInv[ bytes ] ^ key; // Inverse substitute ry byte in state and add key.

bytes = block2[ bytes ] ^ key; // Use block2 directly. Increases speed.

bytes++;

key++;

} while( --count );

}void InvShiftRows( byte state )

{byte temp;

// Note: State is arranged column by column.

// Cycle second row right one time.

temp = state[ 1 + 34 ];

state[ 1 + 34 ] = state[ 1 + 24 ];

state[ 1 + 24 ] = state[ 1 + 14 ];

state[ 1 + 14 ] = state[ 1 + 04 ];

// Cycle third row right two times.

state[ 2 + 04 ] = state[ 2 + 24 ];

state[ 2 + 24 ] = temp;

temp = state[ 2 + 14 ];

state[ 2 + 14 ] = state[ 2 + 34 ];

temp = state[ 3 + 04 ];

state[ 3 + 04 ] = state[ 3 + 14 ];

state[ 3 + 14 ] = state[ 3 + 24 ];

state[ 3 + 24 ] = state[ 3 + 34 ];

state[ 3 + 34 ] = temp;

}void ShiftRows( byte state )

{byte temp;

// Note: State is arranged column by column.

// Cycle second row left one time.

temp = state[ 1 + 04 ];

state[ 1 + 04 ] = state[ 1 + 14 ];

state[ 1 + 14 ] = state[ 1 + 24 ];

state[ 1 + 24 ] = state[ 1 + 34 ];

state[ 1 + 34 ] = temp;

// Cycle third row left two times.

state[ 2 + 04 ] = state[ 2 + 24 ];

state[ 2 + 24 ] = temp;

temp = state[ 2 + 14 ];

state[ 2 + 14 ] = state[ 2 + 34 ];

// Cycle fourth row left three times, ie. right once.

temp = state[ 3 + 34 ];

state[ 3 + 34 ] = state[ 3 + 24 ];

state[ 3 + 24 ] = state[ 3 + 14 ];

state[ 3 + 14 ] = state[ 3 + 04 ];

state[ 3 + 04 ] = temp;

}void InvMixColumns( byte state )

{InvMixColumn( state + 04 );

InvMixColumn( state + 14 );

InvMixColumn( state + 24 );

InvMixColumn( state + 34 );

}void MixColumns( byte state )

{MixColumn( state + 04 );

MixColumn( state + 14 );

MixColumn( state + 24 );

MixColumn( state + 34 );

}void XORBytes( byte bytes1, byte bytes2, byte count )

{do {

bytes1 ^= bytes2; // Add in GF(2), ie. XOR.

bytes1++;

bytes2++;

} while( --count );

}void CopyBytes( byte to, byte from, byte count )

{do {

to = from;

to++;

from++;

} while( --count );

}void KeyExpansion( byte expandedKey )

{byte xdata temp[4];

byte i;

byte xdata Rcon[4] = { 0x01, 0x00, 0x00, 0x00 }; // Round constant.

unsigned char xdata a[16];

key=a;

//以下为加解密密码，共16字节。可以选择任意值

key[0]=0x30;

key[1]=0x30;

key[2]=0x30;

key[3]=0x30;

key[4]=0x30;

key[5]=0x30;

key[6]=0x30;

key[7]=0x30;

key[8]=0x30;

key[9]=0x30;

key[10]=0x30;

key[11]=0byte xdata sBoxInv; //!< Final location of inverse s-box.x30;

key[12]=0x30;

key[13]=0x30;

key[14]=0x30;

key[15]=0x30;

////////////////////////////////////////////

// Copy key to start of expanded key.

i = KEYLENGTH;

do {

expandedKey = key;

expandedKey++;

key++;

} while( --i );

// Prepare last 4 bytes of key in temp.

expandedKey -= 4;

temp[0] = (expandedKey++);

temp[1] = (expandedKey++);

temp[2] = (expandedKey++);

temp[3] = (expandedKey++);

// Expand key.

i = KEYLENGTH;

while( i < BLOCKSIZE(ROUNDS+1) ) {

// Are we at the start of a multiple of the key size?

if( (i % KEYLENGTH) == 0 ) {

CycleLeft( temp ); // Cycle left once.

SubBytes( temp, 4 ); // Substitute each byte.

XORBytes( temp, Rcon, 4 ); // Add constant in GF(2).

#if KEYLENGTH > 24

// Are we right past a block size?

else if( (i % KEYLENGTH) == BLOCKSIZE ) {

SubBytes( temp, 4 ); // Substitute each byte.

}#endif

// Add bytes in GF(2) one KEYLENGTH away.

XORBytes( temp, expandedKey - KEYLENGTH, 4 );

// Copy result to current 4 bytes.

(expandedKey++) = temp[ 0 ];

(expandedKey++) = temp[ 1 ];

(expandedKey++) = temp[ 2 ];

(expandedKey++) = temp[ 3 ];

i += 4; // Next 4 bytes.

}}

void InvCipher( byte block, byte expandedKey )

{byte round = ROUNDS-1;

expandedKey += BLOCKSIZE ROUNDS;

XORBytes( block, expandedKey, 16 );

expandedKey -= BLOCKSIZE;

do {

InvSubBytesAndXOR( block, expandedKey, 16 );

expandedKey -= BLOCKSIZE;

InvMixColumns( block );

} while( --round );

InvSubBytesAndXOR( block, expandedKey, 16 );

}void Cipher( byte block, byte expandedKey ) //完成一个块(16字节，128bit)的加密

{byte round = ROUNDS-1;

XORBytes( block, expandedKey, 16 );

expandedKey += BLOCKSIZE;

do {

SubBytes( block, 16 );

ShiftRows( block );

MixColumns( block );

XORBytes( block, expandedKey, 16 );

expandedKey += BLOCKSIZE;

} while( --round );

SubBytes( block, 16 );

ShiftRows( block );

XORBytes( block, expandedKey, 16 );

}void aesInit( unsigned char tempbuf )

{powTbl = block1;

logTbl = block2;

CalcPowLog( powTbl, logTbl );

sBox = tempbuf;

CalcSBox( sBox );

expandedKey = block1; //至此block1用来存贮密码表

KeyExpansion( expandedKey );

sBoxInv = block2; // Must be block2. block2至此开始只用来存贮SBOXINV

CalcSBoxInv( sBox, sBoxInv );

}//对一个16字节块解密,参数buffer是解密密缓存，chainBlock是要解密的块

void aesDecrypt( unsigned char buffer, unsigned char chainBlock )

{//byte xdata temp[ BLOCKSIZE ];

//CopyBytes( temp, buffer, BLOCKSIZE );

CopyBytes(buffer,chainBlock,BLOCKSIZE);

InvCipher( buffer, expandedKey );

//XORBytes( buffer, chainBlock, BLOCKSIZE );

CopyBytes( chainBlock, buffer, BLOCKSIZE );

}//对一个16字节块完成加密，参数buffer是加密缓存，chainBlock是要加密的块

void aesEncrypt( unsigned char buffer, unsigned char chainBlock )

{CopyBytes( buffer, chainBlock, BLOCKSIZE );

//XORBytes( buffer, chainBlock, BLOCKSIZE );

Cipher( buffer, expandedKey );

CopyBytes( chainBlock, buffer, BLOCKSIZE );

}//加解密函数，参数为加解密标志，要加解密的数据缓存起始指针，要加解密的数据长度（如果解密运算，必须是16的整数倍。）

unsigned char aesBlockDecrypt(bit Direct,unsigned char ChiperDataBuf,unsigned char DataLen)

{unsigned char xdata i;

unsigned char xdata Blocks;

unsigned char xdata sBoxbuf[256];

unsigned long int xdata OrignLen=0; //未加密数据的原始长度

if(Direct==0)

{((unsigned char )&OrignLen+3)=ChiperDataBuf[0];

((unsigned char )&OrignLen+2)=ChiperDataBuf[1];

((unsigned char )&OrignLen+1)=ChiperDataBuf[2];

((unsigned char )&OrignLen)=ChiperDataBuf[3];

DataLen=DataLen-4;

}else

{memmove(ChiperDataBuf+4,ChiperDataBuf,DataLen);

OrignLen=DataLen;

ChiperDataBuf[0]=OrignLen;

ChiperDataBuf[1]=OrignLen>>8;

ChiperDataBuf[2]=OrignLen>>16;

ChiperDataBuf[3]=OrignLen>>24;

}cleardog();

aesInit(sBoxbuf); //初始化

if(Direct==0) //解密

{Blocks=DataLen/16;

for(i=0byte xdata expandedKey; //!< Final location of expanded key.;i

{cleardog();

aesDecrypt(tempbuf,ChiperDataBuf+4+16i);

}memmove(ChiperDataBuf,ChiperDataBuf+4,OrignLen);

cleardog();

return(OrignLen);

}else //加密

{if(DataLen%16!=0)

{Blocks=DataLen/16+1;

//memset(ChiperDataBuf+4+Blocks16-(DataLen%16),0x00,DataLen%16); //不足16字节的块补零处理

}else

{Blocks=DataLen/16;

}for(i=0;i

{cleardog();

aesEncrypt(tempbuf,ChiperDataBuf+4+16i);

}cleardog();

return(Blocks16+4);

}}

//#endif

以上是C文件。以下是头文件

#ifndef AES_H

#define AES_H

extern void aesInit( unsigned char tempbuf );

extern void aesDecrypt(unsigned char buffer, unsigned char chainBlock);

extern void aesEncrypt( unsigned char buffer, unsigned char chainBlock );

extern void aesInit( unsigned char tempbuf );

extern void aesDecrypt( unsigned char buffer, unsigned char chainBlock );

extern void aesEncrypt( unsigned char buffer, unsigned char chainBlock );

extern unsigned char aesBlockDecrypt(bit Direct,unsigned char ChiperDataBuf,unsigned char DataLen);

#endif // AES_H

这是我根据网上程序改写的。只支持128位加解密。没有使用占内存很多的查表法。故运算速度会稍慢。

WPA-PSK/WPA2-PSK AES加密之后小米手机不能连接,一直是密码错误怎么回事？在线等

{byte xdata i = 0;

就是你输入的密码不对呗，含有符号有密码在输入时一定要输入英文符号，输入中文符号是要报错的。

我也是WPA-PSK/WPA2-state[ 2 + 34 ] = temp;PSK AES加密，使用正常啊。

其实家用网范围有限，没必要弄太复杂的密码，用纯数字即可。何况有没有人蹭网是可以通过路由器查看到的。