解密使用openssl和aes-cbc-256加密的文件
我使用以下命令加密了一个文件
openssl rand 32>test.key
openssl enc-aes-256-cbc-iter 10000-pbkdf2-salt-输入test.txt-输出test.txt.enc-通过文件：test.key
我的代码
package test;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.security.GeneralSecurityException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.io.IOUtils;
public class OpenSSlDecryptor {
private static final Charset ASCII = Charset.forName("ASCII");
private static final int INDEX_KEY = 0;
private static final int INDEX_IV = 1;
private static final int ITERATIONS = 10000;
private static final int ARG_INDEX_FILENAME = 0;
private static final int ARG_INDEX_PASSWORD = 1;
private static final int SALT_OFFSET = 8;
private static final int SALT_SIZE = 8;
private static final int CIPHERTEXT_OFFSET = SALT_OFFSET + SALT_SIZE;
private static final int KEY_SIZE_BITS = 256;
/**
* Thanks go to Ola Bini for releasing this source on his blog.
* The source was obtained from <a href="http://olabini.com/blog/tag/evp_bytestokey/">here</a> .
*/
public static byte[][] EVP_BytesToKey(final int key_len, final int iv_len, final MessageDigest md,
final byte[] salt, final byte[] data, final int count) {
final byte[][] both = new byte[2][];
final byte[] key = new byte[key_len];
int key_ix = 0;
final byte[] iv = new byte[iv_len];
int iv_ix = 0;
both[0] = key;
both[1] = iv;
byte[] md_buf = null;
int nkey = key_len;
int niv = iv_len;
int i = 0;
if (data == null) {
return both;
}
int addmd = 0;
for (;;) {
md.reset();
if (addmd++ > 0) {
md.update(md_buf);
}
md.update(data);
if (null != salt) {
md.update(salt, 0, 8);
}
md_buf = md.digest();
for (i = 1; i < count; i++) {
md.reset();
md.update(md_buf);
md_buf = md.digest();
}
i = 0;
if (nkey > 0) {
for (;;) {
if (nkey == 0) {
break;
}
if (i == md_buf.length) {
break;
}
key[key_ix++] = md_buf[i];
nkey--;
i++;
}
}
if (niv > 0 && i != md_buf.length) {
for (;;) {
if (niv == 0) {
break;
}
if (i == md_buf.length) {
break;
}
iv[iv_ix++] = md_buf[i];
niv--;
i++;
}
}
if (nkey == 0 && niv == 0) {
break;
}
}
for (i = 0; i < md_buf.length; i++) {
md_buf[i] = 0;
}
return both;
}
public static void main(final String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException {
final String fileName = "test.txt.enc";
final File f = new File(fileName );
try {
// --- read base 64 encoded file ---
List<String> lines = new ArrayList<>();
try (BufferedReader br = new BufferedReader(new FileReader(f))) {
//br returns as stream and convert it into a List
lines = br.lines().collect(Collectors.toList());
} catch (final IOException e) {
e.printStackTrace();
}
final StringBuilder sb = new StringBuilder();
for (final String line : lines) {
sb.append(line.trim());
}
final String random_bin_key = "test.key";
final byte[] passwordKey = IOUtils.toByteArray(new FileInputStream(random_bin_key));
// --- extract salt & encrypted ---
final byte[] headerSaltAndCipherText = sb.toString().getBytes();
// header is "Salted__", ASCII encoded, if salt is being used (the default)
final byte[] salt = Arrays.copyOfRange(
headerSaltAndCipherText, SALT_OFFSET, SALT_OFFSET + SALT_SIZE);
final byte[] encrypted = Arrays.copyOfRange(
headerSaltAndCipherText, CIPHERTEXT_OFFSET, headerSaltAndCipherText.length);
// --- specify cipher and digest for EVP_BytesToKey method ---
final Cipher aesCBC = Cipher.getInstance("AES/CBC/PKCS5Padding");
final MessageDigest md5 = MessageDigest.getInstance("MD5");
// --- create key and IV ---
// the IV is useless, OpenSSL might as well have use zero's
final byte[][] keyAndIV = EVP_BytesToKey(
KEY_SIZE_BITS / Byte.SIZE,
aesCBC.getBlockSize(),
md5,
salt,
passwordKey,
ITERATIONS);
final SecretKeySpec key = new SecretKeySpec(keyAndIV[INDEX_KEY], "AES");
final IvParameterSpec iv = new IvParameterSpec(keyAndIV[INDEX_IV]);
// --- initialize cipher instance and decrypt ---
aesCBC.init(Cipher.DECRYPT_MODE, key, iv);
final byte[] decrypted = aesCBC.doFinal(encrypted);
final String answer = new String(decrypted);
System.out.println(answer);
} catch (final BadPaddingException e) {
System.out.println(e.getMessage());
} catch (final IllegalBlockSizeException e) {
System.out.println(e.getMessage());
} catch (final GeneralSecurityException e) {
System.out.println(e.getMessage());
} catch (final IOException e) {
System.out.println(e.getMessage());
}
}
我得到的错误
Given final block not properly padded. Such issues can arise if a bad key is used during decryption.
我引用了以下链接
` final Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
// strip off the salt and iv
final ByteBuffer buffer = ByteBuffer.wrap(encryptedText);
byte[] saltBytes = new byte[16];
buffer.get(saltBytes, 0, saltBytes.length);
saltBytes = Arrays.copyOfRange(saltBytes, 8, 16);
final byte[] ivBytes1 = new byte[cipher.getBlockSize()];
buffer.get(ivBytes1, 0, ivBytes1.length);
final int length = buffer.capacity() - 16 - ivBytes1.length;
// length = length+ 16 -(length%16);
final byte[] encryptedTextBytes = new byte[length];
buffer.get(encryptedTextBytes);
// Deriving the key
final SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
final PBEKeySpec spec = new PBEKeySpec(new String(password).toCharArray(), saltBytes, 10000,
256);
final SecretKey secretKey = factory.generateSecret(spec);
final SecretKeySpec secret = new SecretKeySpec(secretKey.getEncoded(), "AES");
cipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(ivBytes1));
byte[] decryptedTextBytes = null;
try {
decryptedTextBytes = cipher.doFinal(encryptedTextBytes);
} catch (final IllegalBlockSizeException e) {
e.printStackTrace();
} catch (final BadPaddingException e) {
e.printStackTrace();
}
尝试使用PBKDF2WithHMACSHA256时，仍然得到错误
共有1个答案
你有几个问题。最明显的是，您试图从文件中读取IV，但是OpenSSL enc在其默认的基于密码的模式下，从密码和salt中导出key和IV，即使在使用PBKDF2时也是如此。然而，Java中的标准（Sun/Oracle/OpenJDK）和BouncyCastle提供程序都实现了PBKDF2来只派生一个密钥--它在PBES2中的使用方式。
即使没有这一点，您将“密码”生成为随机字节的方法也不会起作用。PKCS5标准实际上将PBKDF2定义为将密码作为
任意长度的二进制八位数字符串，其作为文本字符串的解释未指定。然而，出于互操作性的考虑，建议应用程序遵循一些通用的文本编码规则。ASCII和UTF-8[RFC3629]是两种可能性。（ASCII是UTF-8的子集。）
许多系统更重视可互操作编码，特别是Java（从一开始就设计成世界性的）定义pbekeyspec来包含字符--char[]在Java中是UTF-16--当执行PBKDF2时，这些字符被编码为UTF-8。相反，OpenSSL是一个可以追溯到世纪之交之前的C程序，当时C开始承认美国以外的国家的存在，所以它只知道字节--字节可能是ASCII，或者其他一些单字节代码，比如EBCDIC，但可能根本不知道字符，当然也不知道任何不适合一个字节的奇怪的外来字符。32个随机字节序列为有效UTF-8的概率很低；这对我来说是太多的工作，无法进行分析，但我运行了1亿个随机值的测试，得到的只有一个可以与您的方案工作。（我本来要测试10亿，但等得不耐烦了。）
另外，由于密码应该是文本，openssl将-pass file:作为文本文件读取，并将其作为字符串处理。这意味着如果任意一个随机字节是空字节或对应于换行字符的字节，文件中的剩余数据将被丢弃并忽略，用于key-and-iv派生。对于随机的32字节值，平均每4次中就有1次发生这种情况，并且每20次中就有1次在文件中发生得足够早，从而使结果在密码学上变得脆弱和易碎。
这就引出了一个问题：你为什么要使用基于密码的加密？如果您的'key'来自一个相当安全的RNG--OpenSSL RAND就是这样--您不需要加强它，它已经作为一个密钥有效了。您可以使用OpenSSL enc来进行基于密钥的加密，而不是基于密码的加密，而且在Java中它更高效、更安全、更容易--这是一个巨大的胜利。如果您使用一个新的随机密钥进行每次加密，您甚至不需要使用一个真正的IV，您可以使用一个零IV就像我在下面所做的那样。但是如果要重用/any密钥，则需要对每次加密使用唯一的、不可预测的--通常是随机的--IV并将其与数据一起传递，也许只需将其放在前面。
总之，这里有一个相当简单的Java程序，它可以处理这两种情况：带有“password”的pdbkf2的openssl形式，实际上不是密码，也不是UTF-8，或者更明智的基于密钥的形式（但对于本演示来说是零IV）：
//nopackage
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.security.*;
import java.util.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public class SO61613286 {
static public void main (String[] args) throws Exception /* let JVM give error */{
// arguments: P/K, filename output from openssl enc, filename of text pw or binary key
byte[] file = Files.readAllBytes(Paths.get(args[1]));
byte[] fil2 = Files.readAllBytes(Paths.get(args[2]));
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
if( args[0].startsWith("P") ){
// possibly truncate 'password' in fil2
int n = 0; for( ; n < fil2.length; n++ ) if( fil2[n]==0 || fil2[n]=='\n' ) break;
if( n < fil2.length ) fil2 = Arrays.copyOf(fil2, n);
// extract salt and derive ...
byte[] salt = Arrays.copyOfRange(file, 8, 16);
byte[] derive = PBKDF2 ("HmacSHA256", fil2, salt, 10000, 48);
// ... key is first 32, IV is last 16
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(derive,0,32,"AES"), new IvParameterSpec(derive,32,16));
// remainder of file is ciphertext
System.out.write( cipher.doFinal(file,16,file.length-16) );
}else{
// just use fil2 as key and zeros for IV ...
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(fil2,"AES"), new IvParameterSpec(new byte[16]));
// ... all of file is ciphertext
System.out.write( cipher.doFinal(file,0,file.length) );
// !!!if key will be reused, must use better IVs and transmit with the data!!!
}
}
public static byte[] PBKDF2 (String prf, byte[] pass, byte[] salt, int iter, int len)
throws NoSuchProviderException, NoSuchAlgorithmException, InvalidKeyException {
byte[] result = new byte[len];
Mac mac = Mac.getInstance(prf);
mac.init (new SecretKeySpec (pass,prf));
byte[] saltcnt = Arrays.copyOf (salt, salt.length+4);
while( /*remaining*/len>0 ){
for( int o = saltcnt.length; --o>=saltcnt.length-4; ) if( ++saltcnt[o] != 0 ) break;
byte[] u = saltcnt, x = new byte[mac.getMacLength()];
for( int i = 1; i <= iter; i++ ){
u = mac.doFinal (u);
for( int o = 0; o < x.length; o++ ) x[o] ^= u[o];
}
int len2 = Math.min (len, x.length);
System.arraycopy (x,0, result,result.length-len, len2);
len -= len2;
}
return result;
}
public static void testutf8 (){
Random r = new Random();
byte[] t = new byte[32];
for( int i = 0; i < 1000000000; i++ ){
r.nextBytes(t);
if( Arrays.equals(new String (t, StandardCharsets.UTF_8).getBytes(StandardCharsets.UTF_8), t) )
System.out.println(i+" "+Arrays.toString(t));
if( i % 1000000 == 999999 ) System.out.println (i);
}
}
}
和演示：
$ openssl rand 32 >SO61613286.rnd # repeated several times until I got this:
$ xxd SO61613286.rnd # notice the null byte
0000000: ab1a 1384 9238 0900 c947 6b9a c23d 5ee0 .....8...Gk..=^.
0000010: 32f0 6b2f 91ec 2dd9 a69d eb7d e00e 37ff 2.k/..-....}..7.
$
$ echo the name of the cat >SO61613286.in
$
$ openssl aes-256-cbc -in SO61613286.in -out SO61613286.enc1 -pass file:SO61613286.rnd -pbkdf2 -iter 10000
$ java8 -cp . SO61613286 P SO61613286.enc1 SO61613286.rnd
the name of the cat
$
$ openssl aes-256-cbc -in SO61613286.in -out SO61613286.enc2 -K $(xxd -p -c32 SO61613286.rnd) -iv 00
hex string is too short, padding with zero bytes to length
$ # that's a warning and can be ignored, as long as we don't need real IVs (see above)
$ java8 -cp . SO61613286 K SO61613286.enc2 SO61613286.rnd
the name of the cat
$
-
我是密码学的新手。我的要求是对使用openssl加密/解密的文本进行解密/加密。我们在Openssl中使用的算法是aes-256-cbc。因此，我尝试在我的应用程序中实现相同的功能。到目前为止，在谷歌搜索了很多次之后，我所能做的就是。。 我的openssl命令是 我的密钥长度是32位IV是16位 Thnx...
-
我只想用这3种模式测试openSSL中的AES：128192和256密钥长度，但我解密的文本与我的输入不同，我不知道为什么。此外，当我传递一个巨大的输入长度（比如1024字节）时，我的程序显示。。。我的意见总是一样的，但这并不重要，至少现在是这样。代码如下： 编辑： 当我将输出大小更改为而不是时，我得到了结果： 那么，是否有可能存在Outpus大小和IV大小的问题？它们应该有什么尺寸（AES-CB
-
我希望有一个用C编写的程序，可以在没有openssl这样的大型库的帮助下，用AES-CBC对字符串进行编码/解码。 目标： 使用密码短语对字符串进行编码/解码： 因此，应用程序需要接受3个输入参数。。。 输入字符串（待编码）/或已编码字符串（待解码） 用于编码/解码字符串的密码 编码或解码指示器 我对C语言不熟悉（我可以用C#编码）。 我已经找到了https://github.com/kokke/
-
几天来，我一直试图用java解密一个用OpenSSL加密的消息。使用以下命令对邮件进行了加密： openssl enc-e-aes-256-cbc-kfile$file.key-in toto-out toto.enc。 文件file.key包含256位的对称密钥。命令中没有指定salt，但文件以salted__开头。下面是我编写的类，试图解密文件，但即使删除文件的16个字符也无法得到任何东西，即
-
目前，我正在使用以下OpenSSL命令加密敏感文件： 以及解密： 到目前为止，这一切都很好，但由于我对加密和密码学没有太多经验，所以我想了解一下这是否是最好的方法。 我是否正确加密/解密文件？这样我是否充分利用了AES-256？我是否在这里做了一些可能会影响加密文件安全性的错误操作？ 非常感谢评论/回复。 丹尼尔。 PS：我不太确定这是属于超级用户还是stackoverflow，请告知。
-
我一直在搜索一个Java代码示例来执行以下操作，但没有成功。我正在为我的特殊情况寻找解决办法。 已使用“testtest”为密码生成密钥和IV： 我可以访问加密文件，盐，钥匙和IV。我不相信我会收到密码。此外，我还安装了无限强度JCE策略。到目前为止，我只找到了另一个java程序进行加密并生成这些参数的示例。对于我的情况，我必须使用salt、key和iv值来解密一个文件。这在Java中是可能的吗？