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;
}