NIST SP 800-56A 串联/单步键派生函数的现有实现？[已关闭]

有谁知道NIST SP 800-56A串联密钥派生函数/ CONCAT KDF的任何现有实现（最好是Java）？

密钥派生功能记录在NIST出版物的第5.8.1节中：使用离散对数加密的成对密钥建立方案的建议

链接这里： http://csrc.nist.gov/publications/nistpubs/800-56A/SP800-56A_Revision1_Mar08-2007.pdf

微软的CNG在这里有一个实现，但是如果你比较微软实现的功能，与NIST SP 800-56A中记录的参数相比，它们没有计数，微软的实现是不可用的。我也尝试过在C++中实现一个示例程序，但我无法匹配参数。

有没有人能够尝试实现它或知道任何现有的实现？

我正在寻找一种能够证明为什么它符合NIST规范的实现。我已经看到了几个实现，我觉得它们不符合NIST规范（缺少参数，逻辑流无效等）。

如果你能自己实现它，我总是很乐意分享我自己的源代码进行辩论。谢谢！这将是对开源社区的一个很好的贡献！

编辑：

多亏了@Rasmus Faber，我终于可以结束这个问题，并希望回答其他人和我一样的问题。

以下是我根据@Rasmus Faber 和我的原始代码编辑的代码：

ConcatKeyDerivationFunction.java

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * 
 * Implementation of Concatenation Key Derivation Function<br/>
 * http://csrc.nist.gov/publications/nistpubs/800-56A/SP800-56A_Revision1_Mar08-2007.pdf
 *
 */

public class ConcatKeyDerivationFunction {

    private static final long MAX_HASH_INPUTLEN = Long.MAX_VALUE;
    private static final long UNSIGNED_INT_MAX_VALUE = 4294967295L;
    private static MessageDigest md;

    public ConcatKeyDerivationFunction(String hashAlg) throws NoSuchAlgorithmException {
        md = MessageDigest.getInstance(hashAlg);
    }

    public byte[] concatKDF(byte[] z, int keyDataLen, byte[] algorithmID, byte[] partyUInfo, byte[] partyVInfo, byte[] suppPubInfo, byte[] suppPrivInfo) {
        int hashLen = md.getDigestLength() * 8;

        if (keyDataLen % 8 != 0) {
            throw new IllegalArgumentException("keydatalen should be a multiple of 8");
        }

        if (keyDataLen > (long) hashLen * UNSIGNED_INT_MAX_VALUE) {
            throw new IllegalArgumentException("keydatalen is too large");
        }

        if (algorithmID == null || partyUInfo == null || partyVInfo == null) {
            throw new NullPointerException("Required parameter is null");
        }

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            baos.write(algorithmID);
            baos.write(partyUInfo);
            baos.write(partyVInfo);
            if (suppPubInfo != null) {
                baos.write(suppPubInfo);
            }
            if (suppPrivInfo != null) {
                baos.write(suppPrivInfo);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        byte[] otherInfo = baos.toByteArray();
        return concatKDF(z, keyDataLen, otherInfo);
    }

    private byte[] concatKDF(byte[] z, int keyDataLen, byte[] otherInfo) {
        keyDataLen = keyDataLen / 8;
        byte[] key = new byte[keyDataLen];

        int hashLen = md.getDigestLength();
        int reps = keyDataLen / hashLen;

        if (reps > UNSIGNED_INT_MAX_VALUE) {
            throw new IllegalArgumentException("Key derivation failed");
        }

        int counter = 1;
        byte[] counterInBytes = intToFourBytes(counter);

        if ((counterInBytes.length + z.length + otherInfo.length) * 8 > MAX_HASH_INPUTLEN) {
            throw new IllegalArgumentException("Key derivation failed");
        }

        for (int i = 0; i <= reps; i++) {
            md.reset();
            md.update(intToFourBytes(i + 1));
            md.update(z);
            md.update(otherInfo);

            byte[] hash = md.digest();
            if (i < reps) {
                System.arraycopy(hash, 0, key, hashLen * i, hashLen);
            } else {
                System.arraycopy(hash, 0, key, hashLen * i, keyDataLen % hashLen);
            }
        }
        return key;
    }

    private byte[] intToFourBytes(int i) {
        byte[] res = new byte[4];
        res[0] = (byte) (i >>> 24);
        res[1] = (byte) ((i >>> 16) & 0xFF);
        res[2] = (byte) ((i >>> 8) & 0xFF);
        res[3] = (byte) (i & 0xFF);
        return res;
    }
}

@Rasmus费伯：谢谢你的努力。我完全归功于您的上述代码。我对上面的代码所做的是添加代码以按照NIST规范的要求执行验证。

另外，我修复了一个错误，其中密钥DataLen传入的目的是以位为单位指定长度，但它被视为以字节为单位的长度。因此，生成的密钥最终要大 8 倍。

此问题已通过在第二种方法的第一行中添加一行来修复。keyDataLen = keyDataLen/8;

我感谢大家的支持，并希望这段代码能为开源社区带来长足的进步！