aes128ecb加密解密

㈠ AES加密算法256位密钥与128位密钥的不同是什么

一、指代不同

1、256位密钥：AES的区块长度固定为256位，密钥长度则可以是256。

2、128位密钥：AES的区块长度固定为128位，密钥长度则可以是128。

二、安全性不同

1、256位密钥：256位密钥安全性高于128位密钥。

2、128位密钥：128位密钥安全性低于256位密钥。

(1)aes128ecb加密解密扩展阅读

AES和Rijndael加密法并不完全一样（虽然在实际应用中二者可以互换），因为Rijndael加密法可以支持更大范围的区块和密钥长度。

AES的区块长度固定为128位，密钥长度则可以是128，192或256位；而Rijndael使用的密钥和区块长度可以是32位的整数倍，以128位为下限，256位为上限。加密过程中使用的密钥是由Rijndael密钥生成方案产生。

对称/分组密码一般分为流加密(如OFB、CFB等)和块加密(如ECB、CBC等)。对于流加密，需要将分组密码转化为流模式工作。对于块加密(或称分组加密)，如果要加密超过块大小的数据，就需要涉及填充和链加密模式。

ECB模式是最早采用和最简单的模式，将加密的数据分成若干组，每组的大小跟加密密钥长度相同，然后每组都用相同的密钥进行加密。

㈡ 如何使用CryptoJS的AES方法进行加密和解密

首先准备一份明文和秘钥：
var plaintText = 'aaaaaaaaaaaaaaaa'; // 明文
var keyStr = 'bbbbbbbbbbbbbbbb'; // 一般key为一个字符串

参看官网文档，AES方法是支持AES-128、AES-192和AES-256的，加密过程中使用哪种加密方式取决于传入key的类型，否则就会按照AES-256的方式加密。
CryptoJS supports AES-128, AES-192, and AES-256. It will pick the variant by the size of the key you pass in. If you use a passphrase, then it will generate a 256-bit key.
由于java就是按照128bit给的，但是由于是一个字符串，需要先在前端将其转为128bit的才行。
最开始以为使用CryptoJS.enc.Hex.parse就可以正确地将其转为128bit的key。但是不然...
经过多次尝试，需要使用CryptoJS.enc.Utf8.parse方法才可以将key转为128bit的。好吧，既然说了是多次尝试，那么就不知道原因了，后期再对其进行更深入的研究。
// 字符串类型的key用之前需要用uft8先parse一下才能用
var key = CryptoJS.enc.Utf8.parse(keyStr);

由于后端使用的是PKCS5Padding，但是在使用CryptoJS的时候发现根本没有这个偏移，查询后发现PKCS5Padding和PKCS7Padding是一样的东东，使用时默认就是按照PKCS7Padding进行偏移的。
// 加密
var encryptedData = CryptoJS.AES.encrypt(plaintText, key, {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
});

由于CryptoJS生成的密文是一个对象，如果直接将其转为字符串是一个Base64编码过的，在encryptedData.ciphertext上的属性转为字符串才是后端需要的格式。
var encryptedBase64Str = encryptedData.toString();
// 输出：'+ot8JuxWVdLgY='
console.log(encryptedBase64Str);

// 需要读取encryptedData上的ciphertext.toString()才能拿到跟Java一样的密文
var encryptedStr = encryptedData.ciphertext.toString();
// 输出：''
console.log(encryptedStr);

由于加密后的密文为128位的字符串，那么解密时，需要将其转为Base64编码的格式。
那么就需要先使用方法CryptoJS.enc.Hex.parse转为十六进制，再使用CryptoJS.enc.Base64.stringify将其变为Base64编码的字符串，此时才可以传入CryptoJS.AES.decrypt方法中对其进行解密。
// 拿到字符串类型的密文需要先将其用Hex方法parse一下
var encryptedHexStr = CryptoJS.enc.Hex.parse(encryptedStr);

// 将密文转为Base64的字符串
// 只有Base64类型的字符串密文才能对其进行解密
var encryptedBase64Str = CryptoJS.enc.Base64.stringify(encryptedHexStr);

使用转为Base64编码后的字符串即可传入CryptoJS.AES.decrypt方法中进行解密操作。
// 解密
var decryptedData = CryptoJS.AES.decrypt(encryptedBase64Str, key, {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
});

经过CryptoJS解密后，依然是一个对象，将其变成明文就需要按照Utf8格式转为字符串。
// 解密后，需要按照Utf8的方式将明文转位字符串
var decryptedStr = decryptedData.toString(CryptoJS.enc.Utf8);
console.log(decryptedStr); // 'aaaaaaaaaaaaaaaa'

㈢ openssl unix口令密文怎么解密

下面我将单介绍使用Openssl进行文件的对称加密操作。
一、Openssl支持的加密算法有：
-aes-128-cbc -aes-128-cfb -aes-128-cfb1
-aes-128-cfb8 -aes-128-ecb -aes-128-ofb
-aes-192-cbc -aes-192-cfb -aes-192-cfb1
-aes-192-cfb8 -aes-192-ecb -aes-192-ofb
-aes-256-cbc -aes-256-cfb -aes-256-cfb1
-aes-256-cfb8 -aes-256-ecb -aes-256-ofb
-aes128 -aes192 -aes256
-bf -bf-cbc -bf-cfb
-bf-ecb -bf-ofb -blowfish
-cast -cast-cbc -cast5-cbc
-cast5-cfb -cast5-ecb -cast5-ofb
-des -des-cbc -des-cfb
-des-cfb1 -des-cfb8 -des-ecb
-des-ede -des-ede-cbc -des-ede-cfb
-des-ede-ofb -des-ede3 -des-ede3-cbc
-des-ede3-cfb -des-ede3-ofb -des-ofb
-des3 -desx -desx-cbc
-rc2 -rc2-40-cbc -rc2-64-cbc
-rc2-cbc -rc2-cfb -rc2-ecb
-rc2-ofb -rc4 -rc4-40
二、Openssl加密指令语法：
SYNOPSIS
openssl enc -ciphername [-in filename] [-out filename] [-pass arg] [-e]
[-d] [-a] [-A] [-k password] [-kfile filename] [-K key] [-iv IV] [-p]
[-P] [-bufsize number] [-nopad] [-debug]
说明：
-chipername选项：加密算法，Openssl支持的算法在上面已经列出了，你只需选择其中一种算法即可实现文件加密功能。
-in选项：输入文件，对于加密来说，输入的应该是明文文件；对于解密来说，输入的应该是加密的文件。该选项后面直接跟文件名。
-out选项：输出文件，对于加密来说，输出的应该是加密后的文件名；对于解密来说，输出的应该是明文文件名。
-pass选项：选择输入口令的方式，输入源可以是标准输入设备，命令行输入，文件、变量等。
-e选项：实现加密功能（不使用-d选项的话默认是加密选项）。
-d选项：实现解密功能。
-a和-A选项：对文件进行BASE64编解码操作。
-K选项：手动输入加密密钥（不使用该选项，Openssl会使用口令自动提取加密密钥）。
-IV选项：输入初始变量（不使用该选项，Openssl会使用口令自动提取初始变量）。
-salt选项：是否使用盐值，默认是使用的。
-p选项：打印出加密算法使用的加密密钥。
三、案例：
1. 使用aes-128-cbc算法加密文件：
openssl enc -aes-128-cbc -in install.log -out enc.log
(注：这里install.log是你想要加密的文件，enc.log是加密后的文件，回车后系统会提示你输入口令）
2. 解密刚刚加密的文件：
openssl enc -d -aes-128-cbc -in enc.log -out install.log
（注：enc.log是刚刚加密的文件，install.log是解密后的文件，-d选项实现解密功能）
3.加密文件后使用BASE64格式进行编码：
openssl enc -aes-128-cbc -in install.log -out enc.log -a
4.使用多种口令输入方式加密：
openssl enc -des-ede3-cbc -in install.log -out enc.log -pass pass:111111
(这种方式的好处是你可以把它写入到脚本中，自动完成加密功能，不使用pass选项默认系统会提示输入口令，并且确认，是需要人工操作的）
四、Openssl的功能还远不只于此，感兴趣的朋友可以参考Openssl的手册学习。在Linux系统中你可以通过：man openssl 快速获得帮助文件。

例：对文件file.tar.gz进行加密，密码为123456
openssl des3 -salt -k 123456 -in file.tar.gz -out file.tar.gz.des3

对file.tar.gz.des3 解密
openssl enc -des3 -d -in file.tar.gz.des3 -out file.tar.gz

㈣ 在DES加密里边，ECB和CBC有什么区别

一、优点不同:

ECB模式

1、简单；

2、有利于并行计算；

3、误差不会被传送；

CBC模式：

1、不容易主动攻击,安全性好于ECB,适合传输长度长的报文,是SSL、IPSec的标准。

二、缺点不同:

ECB模式

1、不能隐藏明文的模式；

2、可能对明文进行主动攻击；

CBC模式：

1、不利于并行计算；

2、误差传递；

3、需要初始化向量IV

三、概念不同

1、ECB模式又称电子密码本模式：Electronic codebook，是最简单的块密码加密模式，加密前根据加密块大小（如AES为128位）分成若干块，之后将每块使用相同的密钥单独加密，解密同理。

2、密码分组链接（CBC，Cipher-block chaining）模式，由IBM于1976年发明，每个明文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有明文块。同时，为了保证每条消息的唯一性，在第一个块中需要使用初始化向量IV。

(4)aes128ecb加密解密扩展阅读：

1976年，IBM发明了密码分组链接（CBC，Cipher-block chaining）模式。在CBC模式中，每个明文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有明文块。同时，为了保证每条消息的唯一性，在第一个块中需要使用初始化向量。

若第一个块的下标为1，则CBC模式的加密过程为：

Ci = Ek (P ⊕ Ci-1), C0 = IV.

而其解密过程则为：

Pi = Dk (Ci) ⊕Ci-1, C0 = IV.

CBC是最为常用的工作模式。它的主要缺点在于加密过程是串行的，无法被并行化，而且消息必须被填充到块大小的整数倍。解决后一个问题的一种方法是利用密文窃取。

注意在加密时，明文中的微小改变会导致其后的全部密文块发生改变，而在解密时，从两个邻接的密文块中即可得到一个明文块。因此，解密过程可以被并行化，而解密时，密文中一位的改变只会导致其对应的明文块完全改变和下一个明文块中对应位发生改变，不会影响到其它明文的内容。

㈤ aes 128，192，256如何加密如何解密有没有在线工具在线加密，在线解密

....比如‘明文’用aes-ecb-256加密 zp填充 密码123 以utf8输出b64加密后就变成了‘/9+LAeoE=’解密就要反过来
所以你要知道你要解密的文件 加密方式 密码 填充 输出（二次加密） 和 编码 甚至还有偏移量所以 爆破？不存在的

㈥ python进行 AES CBC-128bit PKCS7/PKCS5 填充加密解密

你看一下这个例子吧。可以参考下面的地址：前面加上http，把句号改成点。

likang。me/blog/2013/06/05/python-pycrypto-aes-ecb-pkcs-5/

#-*-coding:utf-8-*-
fromCrypto.CipherimportAES
importos

BS=AES.block_size
pad=lambdas:s+(BS-len(s)%BS)*chr(BS-len(s)%BS)
unpad=lambdas:s[0:-ord(s[-1])]

key=os.urandom(16)#thelengthcanbe(16,24,32)
text='tobeencrypted'

cipher=AES.new(key)

encrypted=cipher.encrypt(pad(text)).encode('hex')
printencrypted#willbesomethinglike''

decrypted=unpad(cipher.decrypt(encrypted.decode('hex')))
printdecrypted#willbe'tobeencrypted'

㈦ java实现aes加密或者解密，不用工具包的怎么做

importjava.security.InvalidKeyException;
importjava.security.Key;
importjava.security.NoSuchAlgorithmException;

importjavax.crypto.*;
importjavax.crypto.spec.*;

/**
*
*@authorwchun
*
*AES128算法，加密模式为ECB，填充模式为pkcs7（实际就是pkcs5）
*
*
*/
publicclassAES{
	
	staticfinalStringalgorithmStr="AES/ECB/PKCS5Padding";
	
	;
	
	staticprivateCiphercipher;
	
	staticbooleanisInited=false;
	
	//初始化
	staticprivatevoidinit()
	{
		
		//初始化keyGen
		try{
			keyGen=KeyGenerator.getInstance("AES");
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		keyGen.init(128);
		
		//初始化cipher
		try{
			cipher=Cipher.getInstance(algorithmStr);
		}catch(NoSuchAlgorithmExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(NoSuchPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		isInited=true;
	}
	
	publicstaticbyte[]GenKey()
	{
		if(!isInited)//如果没有初始化过,则初始化
		{
			init();
		}
		returnkeyGen.generateKey().getEncoded();
	}
	
	publicstaticbyte[]Encrypt(byte[]content,byte[]keyBytes)
	{
		byte[]encryptedText=null;
		
		if(!isInited)//为初始化
		{
			init();
		}
		
		Keykey=newSecretKeySpec(keyBytes,"AES");
		
		try{
			cipher.init(Cipher.ENCRYPT_MODE,key);
		}catch(InvalidKeyExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		try{
			encryptedText=cipher.doFinal(content);
		}catch(IllegalBlockSizeExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(BadPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		returnencryptedText;
	}
	
	//解密为byte[]
	publicstaticbyte[]DecryptToBytes(byte[]content,byte[]keyBytes)
	{
		byte[]originBytes=null;
		if(!isInited)
		{
			init();
		}
		
		Keykey=newSecretKeySpec(keyBytes,"AES");
		
		try{
			cipher.init(Cipher.DECRYPT_MODE,key);
		}catch(InvalidKeyExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		//解密
		try{
			originBytes=cipher.doFinal(content);
		}catch(IllegalBlockSizeExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}catch(BadPaddingExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		returnoriginBytes;
	}
}

㈧ 如何调用openssl 的加解密算法 进行base64 aes-128

提供个加密函数代码：

#define MAX_ENCRYPT_LEN 1024
void MyEncrypt(const unsigned char *sMsg, int cbMsg, unsigned char *sEncryptMsg, int &cbEncryptMsg)
{

OpenSSL_add_all_algorithms();

//产生会话密钥

unsigned char SessionKey[16];

RAND_bytes(SessionKey,16);

//加密

EVP_CIPHER_CTX ctx;

EVP_CIPHER_CTX_init(&ctx);

if(EVP_EncryptInit_ex(&ctx,EVP_get_cipherbynid(NID_aes_128_ecb),NULL,SessionKey,NULL))

{

int offseti=0;

int offseto=0;

int offsett=0;

for(;;)

{

if(cbMsg-offseti<=MAX_ENCRYPT_LEN)

{

EVP_EncryptUpdate(&ctx, sEncryptMsg+offseto, &offsett, sMsg+offseti, cbMsg-offseti);

offseto+=offsett;

break;

}

else

{

EVP_EncryptUpdate(&ctx, sEncryptMsg+offseto, &offsett, sMsg+offseti, MAX_SIGN_MSG);

offseti+=MAX_SIGN_MSG;

offseto+=offsett;

}

}

EVP_EncryptFinal_ex(&ctx, sEncryptMsg+offseto, &offsett);

offseto+=offsett;

cbEncryptMsg=offseto;

}

EVP_CIPHER_CTX_cleanup(&ctx);
}

参数解释：
const unsigned char *sMsg 需要解密的明文
int cbMsg 明文长度
unsigned char *sEncryptMsg 输出密文
int &cbEncryptMsg 密文长度

好了，这个函数刚写的，验证了一下，是没有问题的
解密与这个比较类似

㈨ 如何使用eas加密技术加密解密

AES分为几种模式，比如ECB，CBC，CFB等等，这些模式除了ECB由于没有使用IV而不太安全，其他模式差别并没有太明显，大部分的区别在IV和KEY来计算密文的方法略有区别。具体可参考WIKI的说明。
另外，AES分为AES128，AES256等，表示期待秘钥的长度，比如AES256秘钥的长度应该是256/8的32字节，一些语言的库会进行自动截取，让人以为任何长度的秘钥都可以。

㈩ iOS AES128 ECB加密 对字节数组而不是字符串怎么进行加密

// 开发中用到AES128加密、解密
#import <Foundation/Foundation.h>
#import <CommonCrypto/CommonCryptor.h>
@interface NSData (AES)
- (NSData *)AES128Operation:(CCOperation)operation key:(NSString *)key iv:(NSString *)iv;
- (NSData *)AES128EncryptWithKey:(NSString *)key iv:(NSString *)iv;
- (NSData *)AES128DecryptWithKey:(NSString *)key iv:(NSString *)iv;
@end

@implementation NSData (AES)
- (NSData *)AES128Operation:(CCOperation)operation key:(NSString *)key iv:(NSString *)iv
{
char keyPtr[kCCKeySizeAES128 + 1];
memset(keyPtr, 0, sizeof(keyPtr));
[key getCString:keyPtr maxLength:sizeof(keyPtr) encoding:NSUTF8StringEncoding];

char ivPtr[kCCBlockSizeAES128 + 1];
memset(ivPtr, 0, sizeof(ivPtr));
[iv getCString:ivPtr maxLength:sizeof(ivPtr) encoding:NSUTF8StringEncoding];

NSUInteger dataLength = [self length];
size_t bufferSize = dataLength + kCCBlockSizeAES128;
void *buffer = malloc(bufferSize);

size_t numBytesCrypted = 0;
CCCryptorStatus cryptStatus = CCCrypt(operation,
kCCAlgorithmAES128,
kCCOptionPKCS7Padding,
keyPtr,
kCCBlockSizeAES128,
ivPtr,
[self bytes],
dataLength,
buffer,
bufferSize,
&numBytesCrypted);
if (cryptStatus == kCCSuccess) {
return [NSData dataWithBytesNoCopy:buffer length:numBytesCrypted];
}
free(buffer);
return nil;
}

- (NSData *)AES128EncryptWithKey:(NSString *)key iv:(NSString *)iv
{
return [self AES128Operation:kCCEncrypt key:key iv:iv];
}

- (NSData *)AES128DecryptWithKey:(NSString *)key iv:(NSString *)iv
{
return [self AES128Operation:kCCDecrypt key:key iv:iv];
}
@end

int main(int argc, char const* argv[])
{
NSAutoreleasePool* pool;
pool = [[NSAutoreleasePool alloc] init];

NSString *key = [NSString stringWithCString:argv[1] encoding:NSUTF8StringEncoding];
NSString *iv = [NSString stringWithCString:argv[2] encoding:NSUTF8StringEncoding];
NSString *data_str = [NSString stringWithCString:argv[3] encoding:NSUTF8StringEncoding];
NSData *data = [data_str dataUsingEncoding:NSUTF8StringEncoding];

NSData *en_data = [data AES128EncryptWithKey:key iv:iv];
NSData *de_data = [en_data AES128DecryptWithKey:key iv:iv];

NSString *de_str = [[[NSString alloc] initWithData:de_data
encoding:NSUTF8StringEncoding] autorelease];

NSLog(@"%@", en_data);
NSLog(@"%@", de_str);

[pool drain];
return 0;
}