提高 AES 在 Java 中的性能

Question

在java中使用加密库的速度不稳定第一轮比其他轮需要很多时间，一段时间后执行加密所需的时间是稳定的，这是为什么以及如何从一开始就达到稳定，如果需要一些intail代码我可以做到，但我确实知道需要调用 encrypt 方法来花费大量时间，请查看代码和包含结果的最后一行。

此类包含用于加密/解密的静态方法

package karp.generalutil.common;

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;


public class Encryptor {

/**
 * @param args
 */

static Cipher eCipher,dCipher;

public Encryptor()
{
    try {
        eCipher=Cipher.getInstance("AES");
        dCipher=Cipher.getInstance("AES");
    } catch (NoSuchAlgorithmException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (NoSuchPaddingException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


}

/// for test
public static void main (String args[])
{
try {
    KeyGenerator aes;


    aes = KeyGenerator.getInstance("AES");

    aes.init(128);

    SecretKey key = aes.generateKey();






} catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

}


public static String encrypt(String clearText,String keyString) throws NoSuchAlgorithmException, 
                                                       NoSuchPaddingException, InvalidKeyException,
                                                        IllegalBlockSizeException, BadPaddingException
{


    SecretKey key=loadKey(keyString);
    String encryptedText;

    eCipher.init(Cipher.ENCRYPT_MODE,key );
    encryptedText=new String(eCipher.doFinal(clearText.getBytes()));





    return encryptedText;
}

public static String decrypt(String encryptedText,String keyString) throws NoSuchAlgorithmException, 
                                                           NoSuchPaddingException, InvalidKeyException,
                                                           IllegalBlockSizeException, BadPaddingException
{

    SecretKey key=loadKey(keyString);
    String clearText;
    Cipher dCipher=Cipher.getInstance("AES");
    dCipher.init(Cipher.DECRYPT_MODE,key);
    clearText=new String(dCipher.doFinal(encryptedText.getBytes()));





    return clearText;


}


public static byte[] encrypt(byte [] clearByteArray,String keyString)throws NoSuchAlgorithmException, 
                                                            NoSuchPaddingException, InvalidKeyException,
                                                            IllegalBlockSizeException, BadPaddingException
{

    SecretKey key=loadKey(keyString);
    byte[] encryptedByteArray;
    Cipher eCipher=Cipher.getInstance("AES");
    eCipher.init(Cipher.ENCRYPT_MODE,key );
    encryptedByteArray=eCipher.doFinal(clearByteArray);

    return encryptedByteArray;
}


public static byte[] decrypt(byte [] encryptedByteArray,String keyString)throws NoSuchAlgorithmException, 
                                                            NoSuchPaddingException, InvalidKeyException,
                                                            IllegalBlockSizeException, BadPaddingException
{
    SecretKey key=loadKey(keyString);
    byte[] clearByteArray;

    Cipher dCipher=Cipher.getInstance("AES");
    dCipher.init(Cipher.DECRYPT_MODE,key );
    clearByteArray=dCipher.doFinal(encryptedByteArray);
    return clearByteArray;
}

public static SecretKey loadKey(String  keyString)  {

        byte[] encoded = keyString.getBytes();

        SecretKey key = new SecretKeySpec(encoded, "AES");
        return key;
    }

}

这是测试类

import java.io.ByteArrayInputStream;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.UnknownHostException;
import java.sql.Timestamp;
import java.util.Date;





public class tesst {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {


            long y1,y2;
            y1=System.nanoTime();
            Encryptor e=new Encryptor();
            String keyString="”{¶¹û¼«I?q-׫л•";
            e.encrypt(new byte[31], "”{¶¹û¼«I?q-׫л•");
             y2=System.nanoTime()-y1;
                System.out.println("ini:"+y2);

            for(int i=0;i<100000;i++)
            {   byte [] x=new byte [31];
                y1=System.nanoTime();

        byte [] y=e.encrypt(x, "”{¶¹û¼«I?q-׫л•");



        y2=System.nanoTime()-y1;
        System.out.println(y2);
            }



                    } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

第一个循环大约需要 193650106 ns 第二个循环大约需要 126150 ns 在 150 个循环之后加密时间减少到 11546 ns

Answer 1

要执行有意义的基准测试，请使用Java Microbenchmark Harness (JMH) 工具。

在针对底层硬件架构优化代码之前，Java 虚拟机配置运行代码一段时间。这会导致所有代码（不仅仅是 AES 加密）在一段时间后运行得更快。

关于您的加密代码本身，它有一些问题。（它们不会影响速度，但错误代码有多快并不重要。）

首先，您应该明确说明您的密码正在使用的模式和填充。通常，"AES"您应该使用类似"AES/CBC/PKCS5Padding". 这样，当您与另一个应用程序进行互操作时，您将能够告诉他们您使用了哪些算法。

其次，加密的结果看起来像随机字节。这些字节是字符串的有效编码的可能性几乎为零。因此，当您简单地String从密文创建一个新对象时，您可能会丢失一些信息，因为字符解码器会将任何无法识别的字节替换为 字符。相反，使用类似 Base-64 的编码将二进制数据编码为 ASCII 字符。这同样适用于您的“密钥字符串”。