对于项目，我需要在Android（使用java）中实现一个函数，该函数从文件生成CBC-MAC（AES）。所以基本上该函数从文件中获取不同的“块”并计算每个块的标识符，最后将其组合到整个文件的标识符中。
该功能效果很好，但是，对于较大的文件，由于实现了循环，它非常慢（可能需要几分钟到几小时）。但是，我对密码学的了解并不是很远，所以我不确定如何提高速度或者是否可能。输出提供与不同编程语言中的其他库完全相同的CBC-MAC，因此它可以正常工作。
不幸的是我在使用外部库时非常有限..虽然bouncycastle的CBCBlockCipherMac类是可能的，因为我能够只包含几个依赖项，但从来没有让它提供与下面提到的函数相同的输出。
欢迎所有反馈，我一直试图解决它3天，但无法弄清楚。谢谢！
*更新 看起来for循环中的函数str_to_a32（循环每16个字节）导致了最大的速度问题。因此，如果该功能可以更快，它将主要解决问题。 此外，遗憾的是，每16个字节的循环是必要的，因为我正在实现云提供商Mega也实现的相同CBC-MAC功能。
代码
//TEST IMPLEMENTATION
String _path_to_file = "";
Random _random = new Random();
long[] _key_file = new long[4];
_key_file[0] = _random.nextInt(Integer.MAX_VALUE);
_key_file[1] = _random.nextInt(Integer.MAX_VALUE);
_key_file[2] = _random.nextInt(Integer.MAX_VALUE);
_key_file[3] = _random.nextInt(Integer.MAX_VALUE);
long[] _iv_file = new long[4];
_iv_file[0] = _random.nextInt(Integer.MAX_VALUE);
_iv_file[1] = _random.nextInt(Integer.MAX_VALUE);
_iv_file[2] = 0;
_iv_file[3] = 0;
long[] _returned = cbc_mac(_path_to_file, _key_file, _iv_file);
//FUNCTIONS
//this function loops over the parts of the file to calculate the cbc-mac and is the problem
public static long[] cbc_mac(String _path, long[] k, long[] n) throws Exception {
File _file = new File(_path);
long _file_length = _file.length();
RandomAccessFile _raf = new RandomAccessFile(_file, "r");
//This works fine and fast
ArrayList<chunksData> chunks = get_chunks(_file_length);
long[] file_mac = new long[4];
file_mac[0] = 0;
file_mac[1] = 0;
file_mac[2] = 0;
file_mac[3] = 0;
//prepare encrypt
String iv = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());
SecretKeySpec keySpec = new SecretKeySpec(a32_to_str(k).getBytes("ISO-8859-1"), "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/NOPADDING");
cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
//end prepare encrypt
for(chunksData _chunksData : chunks) {
int pos = (int)_chunksData._key;
int size = (int)_chunksData._value;
long[] chunk_mac = new long[4];
chunk_mac[0] = n[0];
chunk_mac[1] = n[1];
chunk_mac[2] = n[0];
chunk_mac[3] = n[1];
byte[] bytes = new byte[16];
//this loop is the really slow part since it loops over every 16 bytes
for (int i = pos; i < pos + size; i += 16) {
_raf.seek(i);
int _did_read = _raf.read(bytes, 0, 16);
if(_did_read != 16) {
for(int o = _did_read;o<16;o++) {
bytes[o] = (byte)((char)'\0');
}
}
long[] block = str_to_a32(new String(bytes, "ISO-8859-1"));
chunk_mac[0] = chunk_mac[0] ^ block[0];
chunk_mac[1] = chunk_mac[1] ^ block[1];
chunk_mac[2] = chunk_mac[2] ^ block[2];
chunk_mac[3] = chunk_mac[3] ^ block[3];
chunk_mac = str_to_a32(new String(cipher.doFinal(a32_to_str(chunk_mac).getBytes("ISO-8859-1")), "ISO-8859-1"));
}
file_mac[0] = file_mac[0] ^ chunk_mac[0];
file_mac[1] = file_mac[1] ^ chunk_mac[1];
file_mac[2] = file_mac[2] ^ chunk_mac[2];
file_mac[3] = file_mac[3] ^ chunk_mac[3];
file_mac = str_to_a32(new String(cipher.doFinal(a32_to_str(file_mac).getBytes("ISO-8859-1")), "ISO-8859-1"));
}
_raf.close();
return file_mac;
}
//this function works fine and fast
public static ArrayList<chunksData> get_chunks(long size) {
ArrayList<chunksData> chunks = new ArrayList<chunksData>();
long p = 0;
long pp = 0;
for (int i = 1; i <= 8 && p < size - i * 0x20000; i++) {
chunksData chunks_temp = new chunksData(p, i*0x20000);
chunks.add(chunks_temp);
pp = p;
p += chunks_temp._value;
}
while(p < size) {
chunksData chunks_temp = new chunksData(p, 0x100000);
chunks.add(chunks_temp);
pp = p;
p += chunks_temp._value;
}
chunks.get(chunks.size()-1)._value = size-pp;
if((int)chunks.get(chunks.size()-1)._value == 0) {
chunks.remove(chunks.size()-1);
}
return chunks;
}
public static class chunksData {
public long _key = 0;
public long _value = 0;
public chunksData(long _keyT, long _valueT){
this._key = _keyT;
this._value = _valueT;
}
}
//helper function which also contains a loop and is used in the problematic loop, so might be a problem though I don't know how to speed it up
public static long[] str_to_a32(String string) {
if (string.length() % 4 != 0) {
string += new String(new char[4 - string.length() % 4]);
}
long[] data = new long[string.length() / 4];
byte[] part = new byte[8];
for (int k = 0, i = 0; i < string.length(); i += 4, k++) {
String sequence = string.substring(i, i + 4);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
baos.write(sequence.getBytes("ISO-8859-1"));
System.arraycopy(baos.toByteArray(), 0, part, 4, 4);
ByteBuffer bb = ByteBuffer.wrap(part);
data[k] = bb.getLong();
} catch (IOException e) {
data[k] = 0;
}
}
return data;
}
//helper function which also contains a loop and is used in the problematic loop, so might be a problem though I don't know how to speed it up
public static String a32_to_str(long[] data) {
byte[] part = null;
StringBuilder builder = new StringBuilder();
ByteBuffer bb = ByteBuffer.allocate(8);
for (int i = 0; i < data.length; i++) {
bb.putLong(data[i]);
part = copyOfRange(bb.array(), 4, 8);
bb.clear();
ByteArrayInputStream bais = new ByteArrayInputStream(part);
while (bais.available() > 0) {
builder.append((char) bais.read());
}
}
return builder.toString();
}
答案 0 :(得分：0)
我的主要疑问是你的第一个循环中的搜索操作，只处理16个字节。我不知道算法，但你的代码建议阅读完整的“块”是可能的，然后你可以处理它的部分是必要的。
此外，这些块似乎是顺序的（除非我错过了某些内容）因此可以在没有搜索的情况下按顺序完成整个读取。
您的助手方法中不需要ByteArrayOutput流。同时使子字符串有影响，因此在整个字符串上调用toBytes然后拾取字节数组的部分将更有效。
以下代码大约是原始代码的两倍。
public long[] fast_str_to_a32(String string) throws UnsupportedEncodingException {
if (string.length() % 4 != 0) {
string += new String(new char[4 - string.length() % 4]);
}
long[] data = new long[string.length() / 4];
byte[] bytes = string.getBytes("ISO-8859-1");
byte[] part = new byte[8];
ByteBuffer bb = ByteBuffer.wrap(part);
for (int k = 0, i = 0; i < bytes.length; i += 4, k++) {
System.arraycopy(bytes, i, part, 4, 4);
bb.rewind();
data[k] = bb.getLong();
}
return data;
}
同样在main方法中，您只将字节转换为字符串，以便在str_to_a32的开头将它们转换回byte []，您应该使用byte []作为此方法输入。
我仍然相信你应该立刻读取整个块，然后以16字节的块来处理它。
您的代码中可能存在问题：您尝试读取16个字节，但如果您获得的更少，则会开始填充。但是，读取的合同是“尝试读取多达len个字节，但可以读取较小的数字”。通常，较小的数字发生在文件的末尾，但原则上它可能随时发生。如果是这样，您将在流中间开始填充并完全弄乱您的部件。