java - java中AES256加密的问题

Question

所以..这是类:(我使用并为 AES256 加密制作)

public class AES256
{
private String charSet = "UTF-8";
private String algo = "AES/CBC/PKCS5Padding";
private String baseAlgo = "AES";
private String hashAlgo = "PBKDF2WithHmacSHA1";

private String key = null;
private String salt = "defaultsaltsalt";
private String iv = "a1bC@6jZ!#sL1z0y";

private Cipher cipher;
private BufferedInputStream bIs;
private BufferedOutputStream bOs;

public AES256()
{

}

public AES256(String pass)
{
    this.key = pass;
}

public AES256(String pass, String salty)
{
    this.key = pass;
    this.salt = salty;
}

public AES256(String pass, String salty, String ivs)
{
    this.key = pass;
    this.salt = salty;
    this.iv = ivs;
}

public void setKey(String key)
{
    this.key = key;
}

public void setSalt(String salt)
{
    this.salt = salt;
}

public void setIV(String ivs)
{
    this.iv = ivs;
}

/**
 * @Method Pads and constructs the SecretKey (Padding @ 32)
 * @return Returns the padded key.
 * @throws Exception Exception is thrown if the key is null or something else wrong..
 */
public SecretKeySpec getKey() throws Exception
{
     byte[] saltBytes = salt.getBytes(charSet);

     SecretKeyFactory factory = SecretKeyFactory.getInstance(hashAlgo);
     PBEKeySpec spec = new PBEKeySpec(
             this.key.toCharArray(), 
             saltBytes, 
             300000, //make variable
             263 //default 32 bytes
     );

     SecretKey secretKey = factory.generateSecret(spec);
     SecretKeySpec secret = new SecretKeySpec(secretKey.getEncoded(), baseAlgo);

     return secret;
}

/**
 * @Method Pads and returns the IV (Padding @ 16)
 * @return
 * @throws Exception
 */
public byte[] getIV() throws Exception
{
    byte[] byteKey = iv.getBytes(charSet);
    MessageDigest sha = MessageDigest.getInstance("SHA-512");
    byteKey = sha.digest(byteKey);
    byteKey = Arrays.copyOf(byteKey, 16);
    return byteKey;
}

public byte[] encrypt(byte[] plainText) throws Exception
{
    cipher = Cipher.getInstance(algo);
    cipher.init(Cipher.ENCRYPT_MODE, getKey(), new IvParameterSpec(getIV()));

    System.out.println("Plain text length: "+plainText.length);
    byte[] enc = Base64.encodeBase64(cipher.doFinal(plainText));
    System.out.println("Encrypted text length "+enc.length);

    return  enc;
}

public byte[] decrypt(byte[] encryptedText) throws Exception
{
    cipher = Cipher.getInstance(algo);
    cipher.init(Cipher.DECRYPT_MODE, getKey(), new IvParameterSpec(getIV()));

    System.out.println("Encrypted Decrypted Text length: "+encryptedText.length);
    byte[] de = cipher.doFinal(Base64.decodeBase64(encryptedText));
    System.out.println("Decrypted Text length: "+de.length);

    return de;
}

public void encrypt(File fileToEncrypt) throws FileNotFoundException, IOException, Exception
{
    if(fileToEncrypt == null)
        throw new FileNotFoundException("File given to encrypt was not found!");
    File encrypted = new File(cutPath(fileToEncrypt.getPath()), "ENCRYPTED "+fileToEncrypt.getName());
    if(!encrypted.exists())
        encrypted.createNewFile();
    bIs = new BufferedInputStream(new FileInputStream(fileToEncrypt));
    bOs = new BufferedOutputStream(new FileOutputStream(encrypted));

    @SuppressWarnings("unused")
    int read = 0;
    byte[] buff = new byte[1024];
    while((read = bIs.read(buff)) != -1)
    {
        byte[] enc = encrypt(buff);
        bOs.write(enc, 0, enc.length);
    }
    bIs.close();
    bOs.close();
}

public void decrypt(File fileToDecrypt) throws FileNotFoundException, IOException, Exception
{
    if(fileToDecrypt == null)
        throw new FileNotFoundException("File given to decrypt was not found!");
    File decrypted = new File(cutPath(fileToDecrypt.getPath()), "DECRYPTED "+fileToDecrypt.getName().replace("ENCRYPTED ", ""));
    if(!decrypted.exists())
        decrypted.createNewFile();
    bIs = new BufferedInputStream(new FileInputStream(fileToDecrypt));
    bOs = new BufferedOutputStream(new FileOutputStream(decrypted));

    @SuppressWarnings("unused")
    int read = 0;
    byte[] buff = new byte[1388];
    while((read = bIs.read(buff)) != -1)
    {
        byte[] de = decrypt(buff);
        bOs.write(de, 0, de.length);
    }
    bIs.close();
    bOs.close();
}

private String cutPath(String path)
{
    String temp = "";
    String[] parts = path.split(Pattern.quote(File.separator));
    for(int i = 0; i < parts.length-1; i++)
        temp+=parts[i]+"/";
    return temp;
}

}

我正在使用我编写的这个类，使用 CBC/PKCS5PADDING 来加密和解密 java 中的信息，并且我还使用哈希算法来哈希我的密码..

注意:我知道这个程序存在一些效率问题，比如为什么我要继续计算从文件中获得的 key 。我稍后会修复这个问题。它只是为了测试一些东西。

无论如何，我正在使用加密(文件)方法，当我给它一个文件时，它一次获取1024字节的信息并加密该信息，然后转换为BASE64以避免编码问题..然后将其写回到具有相同名称但前面有ENCRYPTED或DECRYPTED字样的不同文件...并且与父文件在同一目录中..

现在我的问题是，当它加密信息时，我向它发送 1024 字节的信息进行处理，然后使用 BASE64 来避免诸如 UTF 之类的编码问题..但最终我正在加密的 1024 字节如何变成 1388 字节的数据，这就是我返回的...现在为什么会这样？

第二个问题:除了上面的问题之外，它还有些工作，也许不是问题，但我很想知道为什么。无论如何，第二个问题也是使用加密(文件)方法以及解密(文件)..当我加密文件时，它以某种方式增加了一些额外的长度(可能与上面的问题直接相关...)，这样当我解密文件时，文件的文本完美解密，但无论出于何种原因，我都会在底部得到一些额外的重复文本...就像文件将在顺序直到最后有一些重复信息..所以我不知道这些随机字节来自哪里，但我很想知道..

无论如何，如果您发现我的加密方法有任何其他问题，请在这里告诉我，可能是弱加密选择？也许很容易被暴力破解？使用低效方法？不明白我想要完成的事情？ 可能就像用相同的名称和相同的目录保存文件..有更简单的方法吗？

Answer 1

对字符串进行 Base-64 编码会产生比开始时更长的字符串。

这样想吧。您有一个每个字节有 8 个有效位的数组。最终得到的字符串中只有 6 位很重要(因此名称中为 64，base-64，因为 2^6 = 64)，因此它必须长大约 1/3。

向后推算，使用您拥有的模式的 AES 加密将添加 16 字节的填充，因此结果将比您输入的内容长 16 字节。这意味着您给它 1024，加密(在 Base-64 编码之前)将产生 1040 字节的长度。

算术是这样计算的:

1024 bytes + 16 padding = 1040 bytes
1040 bytes is not divisible by 3 (as required by base-64) so add 1 byte
1041 bytes * 8 = 8328 bits / 6 = 1388
1388 base-64 characters

第 2 部分

末尾有额外字节的原因在以下代码中:

byte[] buff = new byte[1024];
while((read = bIs.read(buff)) != -1)
{
    byte[] enc = encrypt(buff);
    bOs.write(enc, 0, enc.length);
}

在最后一次读取时，它没有将完整的 1024 字节读入缓冲区。上次读取的字节仍然存在。

变量“read”保存实际读取的字节数。请注意该变量是如何未被使用的。但是您正在加密整个缓冲区，而不仅仅是第一个“读取”的字节数。

您可以通过将“read”的值传递到“加密”方法中并使用 doFinal(buff, 0, read) 方法的替代形式来仅加密读取的内容来解决此问题。

更改此行:

    byte[] enc = encrypt(buff, read);

还有这个:

public byte[] encrypt(byte[] plainText, int len) throws Exception

还有这个:

byte[] enc = Base64.encodeBase64(cipher.doFinal(plainText, 0, len));

您将需要执行与解密类似的操作，因为上次读取的字节数可能没有 1388 个字节，并且旧字节将位于缓冲区中。 (你现在不会有这个问题，因为你总是加密 1024 字节。只是如果文件在最后一个 block 上有一个短读取，其中一些是错误的。)