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中的信息，我也使用哈希算法来哈希密码..

注意：我知道这个程序存在一些效率问题，比如为什么我要继续计算我从文件中得到的密钥...我以后修复它...它只是在那里测试一些东西进行。

无论如何，我使用的是加密（File）方法，当我给它一个文件时，它一次获取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'的值传递到'encrypt'方法并使用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个字节。如果文件在最后一个块上有一个简短的读取，那只是其中一些是错误的。）

在Java中使用AES256加密的Prolblem

1 个答案: