所以..这是类：（我使用并制作用于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 中加密和解密信息，我还使用哈希算法来哈希我的密码。
注意：我知道这个程序中存在一些效率问题，例如为什么我一直计算从文件中获取的密钥块。我稍后会修复它..它只是在那里测试一些东西。
无论如何，我正在使用 encrypt（File） 方法，当我给它一个文件时，它一次获取 1024 字节的信息并加密该信息，然后隐蔽到 BASE64 以避免编码问题.. 然后将其写回具有相同名称但前面有"加密"或"解密"字样的不同文件......并且与父文件位于同一目录中。
现在我的问题是当它加密信息时，我正在发送 1024 字节的信息进行处理，然后使用 BASE64 来避免编码问题，例如 UTF 等......但最终，我正在加密的 1024 字节如何变成 1388 字节的数据，这就是我得到的......这是为什么呢？
第二个问题：除了上面的问题之外，它还有一些工作，也许这不是问题，但我很想知道为什么。无论如何，第二个问题也是使用encrypt（File）方法以及decrypt（File）。当我加密文件时，它会以某种方式为其增加一些额外的长度（可能与上面的问题直接相关......），因此当我解密文件时，文件的文本已完全解密，但随后我得到一些额外的重复文本在底部出于任何原因...就像文件将按顺序排列，直到最后有一些重复的信息..所以我不知道这些随机字节来自哪里，但我很想知道..
无论如何，如果您发现我的加密方法有任何其他问题，请在这里告诉我，可能是弱加密选择？也许很容易被蛮力破解？使用低效的方法？不明白我想要完成的事情？可能就像保存具有相同名称和相同目录的文件一样。有没有更简单的方法？
字符串进行 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 字节。只是如果文件在最后一个块上有简短的读取，其中一些是错误的。