java - 多线程中的 AES+HMAC 加密 - Java

Question

我正在开发一个小程序来使用 AES-256 和 HMAC 来加密/解密二进制文件以检查结果。

我的代码基于 Java 中的 AESCrypt 实现，但我想修改它以允许多个线程同时完成这项工作。

我得到原始字节的大小并计算每个线程的16字节 block 的数量，然后我用关于偏移量的信息启动线程申请读写(因为加密文件有一个头，所以offset_write = offset_read+header_length)。

当它完成加密时，我通过 HMAC 传递输出内容(没有 header )以生成校验和。

问题是一些字节在两个线程之间的字节中被破坏。

主要代码:

//..
// Initialization and creation of iv, aesKey
//..

in = new FileInputStream(fromPath);
out = new FileOutputStream(toPath);

//..
// Some code for generate the header and write it to out
//..
double totalBytes = new Long(archivo.length()).doubleValue();
int bloquesHilo = new Double(Math.ceil(totalBytes/(AESCrypt.NUM_THREADS*AESCrypt.BLOCK_SIZE))).intValue();
int offset_write = new Long((out.getChannel()).position()).intValue();

for (int i = 0; i < AESCrypt.NUM_THREADS; i++)
{
    int offset = bloquesHilo*AESCrypt.BLOCK_SIZE*i;
    HiloCrypt hilo = new HiloCrypt(fromPath, toPath, ivSpec, aesKey, offset, offsetInicio, bloquesHilo, this);
    hilo.start();
}

线程代码(类 HiloCrypt): 公共(public)类 HiloCrypt 扩展线程 {

    private RandomAccessFile in;
    private RandomAccessFile out;

    private Cipher cipher;
    private Mac hmac;
    private IvParameterSpec ivSpec2;
    private SecretKeySpec aesKey2;

    private Integer num_blocks;
    private Integer offset_read;
    private Integer offset_write;

    private AESCrypt parent;

    public HiloCrypt(String input, String output, IvParameterSpec ivSpec, SecretKeySpec aesKey, Integer offset_thread, Integer offset_write, Integer blocks, AESCrypt parent2) 
    {
        try
        {
                        // If i don't use RandomAccessFile there is a problem copying data
            this.in = new RandomAccessFile(input, "r");
            this.out = new RandomAccessFile(output, "rw");

            int total_offset_write = offset_write + offset_thread;

                        // Adjust the offset for reading and writing 
            this.out.seek(total_offset_write);
            this.in.seek(offset_thread);

            this.ivSpec2 = ivSpec;
            this.aesKey2 = aesKey;

            this.cipher = Cipher.getInstance(AESCrypt.CRYPT_TRANS);
            this.hmac = Mac.getInstance(AESCrypt.HMAC_ALG);

            this.num_blocks = blocks;
            this.offset_read = offset_thread;
            this.offset_write = total_offset_write;
            this.parent = parent2;

        } catch (Exception e)
        {
            System.err.println(e);
            return;
        }
    }


    public void run()
        {
        int len, last,block_counter,total = 0;
        byte[] text = new byte[AESCrypt.BLOCK_SIZE];

        try{
            // Start encryption objects
            this.cipher.init(Cipher.ENCRYPT_MODE, this.aesKey2, this.ivSpec2);
            this.hmac.init(new SecretKeySpec(this.aesKey2.getEncoded(), AESCrypt.HMAC_ALG));

            while ((len = this.in.read(text)) > 0 && block_counter < this.num_blocks) 
            {
                this.cipher.update(text, 0, AESCrypt.BLOCK_SIZE, text);
                this.hmac.update(text);

                // Write the block
                this.out.write(text);

                last = len;
                total+=len;

                block_counter++;
            }

            if (len < 0) // If it's the last block, calculate the HMAC
            {
                last &= 0x0f;
                this.out.write(last);

                this.out.seek(this.offset_write-this.offset_read);

                while ((len = this.out.read(text)) > 0) 
                {
                    this.hmac.update(text);
                }

                // write last block of HMAC
                text=this.hmac.doFinal();
                this.out.write(text);
            }

                        // Close streams
            this.in.close();
            this.out.close();

                        // Code to notify the end of the thread
        }
        catch(Exception e)
        {
            System.err.println("Hola!");
            System.err.println(e);
        }
    }
}

使用这段代码，如果我只执行 1 个线程，加密/解密会很完美，但是如果有 2 个以上的线程，线程作业之间的区域中的字节就会出现问题，那里的数据会被破坏，校验和也会失败。

我正在尝试使用线程执行此操作，因为它比使用一个线程快近 2 倍，我认为这应该是因为处理而不是通过访问文件。

作为无关数据，它在 MB Air 上用 43 秒压缩了 250Mb 的数据。 ¿现在是个好时机？

Answer 1

AESCrypt 是 not thread safe .您不能对它使用多个线程。

一般来说，加密代码很少是线程安全的，因为它需要复杂的数学运算才能生成安全输出。 AES 本身相对较快，如果您需要更快的速度，请考虑垂直扩展或硬件加速器作为第一步。稍后，您可以添加更多服务器以同时加密不同 文件(水平缩放)。