Java中JPG/Zip文件的AES加密

我正在写两个程序；一个加密第一个参数中给出的文件，第二个参数中给出ASCII种子，另一个解密加密文件。该算法在CBC流密码模式下使用AES-128。将文件读入缓冲区，生成SHA-1散列并附加到明文，然后进行加密。种子也由SHA-1生产。解密程序（使用相同的种子）将消息从摘要中分离出来，并将摘要与本地生成的哈希进行比较。 到目前为止，这两个程序对于.txt文件非常有效，但如果我尝试对.jpg或.png文件进行加密/解密，原始图像只剩下顶部的一小部分，其余部分只是随机颜色。zip文件被破坏了

抱歉，我的代码太大了

加密：

public class secureFile 
{
private static SecretKeySpec sec_key_spec;
private static Cipher sec_cipher;
private static final int SIZE_LIMIT = 1024;
private static final int SHA1_SIZE = 20;


// encryption function
public static byte[] encrypt(byte[] plaintext) throws Exception
{
    byte[] encrypted = null;
    byte[] iv = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    IvParameterSpec ivspec = new IvParameterSpec(iv);
    try {
        //set cipher object to encrypt mode
        sec_cipher.init(Cipher.ENCRYPT_MODE, sec_key_spec, ivspec);

        //create ciphertext
        encrypted = sec_cipher.doFinal(plaintext);
    }
    catch(Exception e) {
        System.out.println(e);
    }
    return encrypted;
}


//creates SHA-1 message digest
public static byte[] createDigest(byte[] message) throws Exception
{
    byte[] hash = null;
    try{
        //create message digest object
        MessageDigest sha1 = MessageDigest.getInstance("SHA1");

        //make message digest
        hash = sha1.digest(message);    
    }
    catch(NoSuchAlgorithmException nsae) {
        System.out.println(nsae);
    }
    return hash;
}


public static void main (String args[]) throws Exception 
{   
    byte[] key;
    byte[] key128;
    FileInputStream mFile;
    FileOutputStream cFile;
    byte[] ciphertext;
    byte[] plaintext;
    byte[] sha1_hash;   
    byte[] message;
    String cFilename;
    int file_size;

    try {
        //gets filenames and fileinput
        String[] mFilename = args[0].split("\\.(?=[^\\.]+$)");
        cFilename = mFilename[0] + "EN." + mFilename[1];
        mFile = new FileInputStream(mFilename[0] + "." + mFilename[1]);

        //limits buffer size to 1024
        file_size = mFile.available();
        if (file_size > SIZE_LIMIT) {
            file_size = SIZE_LIMIT;
        }

        //reads message file in buffer
        message = new byte[file_size];
        mFile.read(message);
        mFile.close();

        //creates sha1 digest from message
        sha1_hash = createDigest(message);

        //combines message and digest
        plaintext = new byte[file_size + SHA1_SIZE];
        for (int i = 0; i < file_size; i++) {
            plaintext[i] = message[i];
        }
        for (int j = 0; j < SHA1_SIZE; j++) {
            plaintext[file_size + j] = sha1_hash[j];
        }

        //generates key
        key = createDigest(args[1].getBytes("us-ascii"));
        key128 = Arrays.copyOfRange(key, 0, 16);
        sec_key_spec = new SecretKeySpec(key128, "AES");

        //enciphers the plaintext
        sec_cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        ciphertext = encrypt(plaintext);

        //copies ciphertext to file
        cFile = new FileOutputStream(cFilename);
        cFile.write(ciphertext);
        cFile.close();
    }
    catch (Exception e) {
        System.out.println(e);
    }
  }

}

公共类安全文件
{
私有静态SecretKeySpec secu key_spec；
私有静态密码；
私有静态最终整数大小_限制=1024；
专用静态最终int SHA1_尺寸=20；
//加密功能
公共静态字节[]加密（字节[]明文）引发异常
{
字节[]加密=空；
字节[]iv={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}；
IvParameterSpec ivspec=新的IvParameterSpec（iv）；
试一试{
//将cipher对象设置为加密模式
sec_cipher.init（cipher.ENCRYPT_模式，sec_密钥_规范，ivspec）；
//创建密文
加密=sec_cipher.doFinal（明文）；
}
捕获（例外e）{
系统输出打印ln（e）；
}
返回加密；
}
//创建SHA-1消息摘要
公共静态字节[]createDigest（字节[]消息）引发异常
{
字节[]散列=null；
试一试{
//创建消息摘要对象
MessageDigest sha1=MessageDigest.getInstance（“sha1”）；
//制作消息摘要
hash=sha1.digest（消息）；
}
捕获（无算法异常nsae）{
系统输出打印（nsae）；
}
返回散列；
}
公共静态void main（字符串args[]）引发异常
{   
字节[]键；
字节[]键128；
文件输入流文件；
FileOutputStream文件；
字节[]密文；
字节[]明文；
字节[]sha1_散列；
字节[]消息；
字符串cFilename；
int文件大小；
试一试{
//获取文件名和文件输入
字符串[]mFilename=args[0]。拆分（“\\.（？=[^\.]+$”）；
cFilename=mFilename[0]+“EN.”+mFilename[1]；
mFile=newfileinputstream（mFilename[0]+“+mFilename[1]）；
//将缓冲区大小限制为1024
file_size=mFile.available（）；
如果（文件大小>大小限制）{
文件大小=大小限制；
}
//读取缓冲区中的消息文件
消息=新字节[文件大小]；
mFile.read（消息）；
mFile.close（）；
//从消息创建sha1摘要
sha1_hash=createDigest（消息）；
//结合了信息和摘要
明文=新字节[文件大小+SHA1大小]；
对于（int i=0；i<文件大小；i++）{
明文[i]=消息[i]；
}
对于（int j=0；j

解密文件：

import java.io.*;
import java.util.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class decryptFile
{
private static SecretKeySpec sec_key_spec = null;
private static Cipher sec_cipher = null;
private static final int SHA1_SIZE = 20;


//decryption function
public static byte[] decrypt(byte[] ciphertext) throws Exception{
    byte[] decrypted = null;
    byte[] iv = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    IvParameterSpec ivspec = new IvParameterSpec(iv);
    try{
        //set cipher to decrypt mode
        sec_cipher.init(Cipher.DECRYPT_MODE, sec_key_spec, ivspec);

        //do decryption
        decrypted = sec_cipher.doFinal(ciphertext);
    }
    catch (BadPaddingException b)
    {
        sec_cipher.init(Cipher.ENCRYPT_MODE, sec_key_spec, ivspec);
        decrypted = sec_cipher.doFinal(ciphertext);
    }
    catch(Exception e){
        System.out.println(e);
    }

    return decrypted;
}


//creates digest
public static byte[] createDigest(byte[] message) throws Exception
{
    byte[] hash = null;
    try{
        //create message digest object
        MessageDigest sha1 = MessageDigest.getInstance("SHA1");

        //make message digest
        hash = sha1.digest(message);    
    }
    catch(NoSuchAlgorithmException nsae) {
        System.out.println(nsae);
    }
    return hash;
}


//compares two digests
public static String compareDigests(byte[] digest, byte[] local_digest)
{
    for (int i = 0; i < SHA1_SIZE; i++)
    {
        if (digest[i] != local_digest[i]) {
            return "Digests don't match; your file may have been tampered with.";
        }
    }
    return "Digests match!";
}


public static void main (String args[]) 
{
    FileInputStream cFile;
    FileOutputStream mFile;
    byte[] key;
    byte[] key128;
    byte[] ciphertext;
    byte[] decrypted;
    byte[] message;
    byte[] digest;
    byte[] local_digest;
    byte[] local_digest2;
    String mFilename;
    int file_size;

    try {
        //obtains filenames
        String[] cFilename = args[0].split("\\.(?=[^\\.]+$)");
        mFilename = cFilename[0] + "DE." + cFilename[1];
        cFile = new FileInputStream(cFilename[0] + "." + cFilename[1]);

        //reads ciphertext file
        cFile = new FileInputStream(cFilename[0] + "." + cFilename[1]);
        ciphertext = new byte[cFile.available()];
        cFile.read(ciphertext);
        cFile.close();

        //generates key
        key = createDigest(args[1].getBytes("us-ascii"));
        key128 = Arrays.copyOfRange(key, 0, 16);
        sec_key_spec = new SecretKeySpec(key128, "AES");

        //deciphers the plaintext
        sec_cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        decrypted = decrypt(ciphertext);

        //splits plaintext between message and digest
        file_size = decrypted.length;
        message = Arrays.copyOfRange(decrypted, 0, (file_size - SHA1_SIZE));
        digest = Arrays.copyOfRange(decrypted, (file_size - SHA1_SIZE), file_size);

        //compares digests
        local_digest = createDigest(message);
        System.out.println(compareDigests(digest, local_digest));

        //copies message to file
        mFile = new FileOutputStream(mFilename);
        mFile.write(message);
        mFile.close();
    }
    catch (Exception e) {
        System.out.println(e);
    }
 }
}

import java.io.*；
导入java.util.*；
导入java.security.*；
导入javax.crypto.*；
导入javax.crypto.spec.*；
公共类解密文件
{
私有静态SecretKeySpec secu key_spec=null；
私有静态密码sec_Cipher=null；
专用静态最终int SHA1_尺寸=20；
//解密函数
公共静态字节[]解密（字节[]密文）引发异常{
字节[]已解密=空；
字节[]iv={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}；
IvParameterSpec ivspec=新的IvParameterSpec（iv）；
试一试{
//将密码设置为解密模式
sec_cipher.init（cipher.DECRYPT_模式，sec_密钥规范，ivspec）；
//解密
解密=sec_cipher.doFinal（密文）；
}
捕获（BadPaddingException b）
{
sec_cipher.init（cipher.ENCRYPT_模式，sec_密钥_规范，ivspec）；
解密=sec_cipher.doFinal（密文）；
}
捕获（例外e）{
系统输出打印ln（e）；
}
返回解密；
}
//创建摘要
公共静态字节[]createDigest（字节[]消息）引发异常
{
字节[]散列=null；
试一试{
//创建消息摘要对象
MessageDigest sha1=MessageDigest.getInstance（“sha1”）；
//制作消息摘要
hash=sha1.digest（消息）；
}
捕获（无算法异常nsae）{
系统输出打印（nsae）；
}
返回散列；
}
//比较两个摘要
公共静态字符串比较摘要（字节[]摘要，字节[]本地摘要）
{
对于（int i=0；i