IOTA 基石 - Sponge 算法详解

一、概要

    Sponge是IOTA自身抽象的 ,目前有两种实现,一个是kerl,另外一个curl。而kerl 是基于hash 散列函数Keccak 封装。而curl 自是自己法明的hash 散列函数。一方面,像区块链地址生成,交易签名的实现等,都需要依赖于此hash散列函数;另一方面,基于该类hash 签名具有防量子算法攻击的作用,导致iota 目前的 账户体系的特殊(区块链地址不可重用,后面在详细分析),所以,有必要深入该算法实现。

二、详细介绍&解析

     IOTA 使用了三进制作为编码方式,所以使用了 SHA-3 发明者设计的三进制哈希算法 Curl;但是波士顿和 MIT 大学在 2017 年 9 月发布了一篇名为IOTA Vulnerability Report: Cryptanalysis of the Curl Hash Function Enabling Practical Signature Forgery Attacks on the IOTA Cryptocurrency的报告,指出IOTA 的签名实现中,使用 Curl 三进制哈希算法,会存在hash 碰撞。

     作为区块链项目底层的重要设施的哈希算法,Curl 并没有经历过较长时间的研究和审查就这样使用在了公链中,这种做法并不是特别的明智,在出现安全隐患之后,IOTA 团队切换至更加成熟的 Keccak 哈希算法,当然,curl 本身作为hash 摘要还是没问题的。这里额外像补充密码学中的一条『黄金法则』- 永远不要自己发明加密算法。

The golden rule of cryptographic systems is “don’t roll your own crypto.”

因此,本章节打算用4小节来详细分析
1)Sponge 算法蔟设计
2)Keccak 算法详解
3)Kerl 算法详解
4)Curl 算法详解

2.1 Sponge算法蔟设计

Sponge 算法蔟

    上面为IOTA 设计的海绵函数类图,主要实现有Kerl 以及 Curl。然后下面为这俩类函数在IOTA 中的用途:

Sponge 用途

    根据[Sponge 用途]总结,我们可以知道,区块链地址生成、签名生成、验签 以及 bundle hash 生成都是使用Kerl hash 算法,另外,iota 地址是81t'rytes组成,然后在用9个trytes 作为校验和;这里需要注意的是,在iota 中的bundle模型 才对应我们日常理解的transaction,而iota 中的transaction 模型 则对应比特币中input/output,这个在后续会详细分析。,
    另外Curl-P-N 中的N 则表明对一个输入运算相同的hash 转换函数N 次;transaction 模型的hash 生成 以及 bundle 中的微型 pow 使用Curl-P-81, Milestone 校验则使用Curl-P-27。

2.2 Keccak 算法详解

    在介绍Sponge 前,我们先来介绍Keccak,Keccak使用的是海绵函数:


海绵函数

它使用有限的状态,接收任何长度的输入字节数组,然后按照指定长度字节数组输出。

海绵函数是由三个部分组成:

  • 一个内存状态 S,包含 b个 bit
  • 一个能置换或者转换内存状态,固定大小的转换函数 f
  • 一个填充函数(padding function)P

内存状态会分成两个区块,R(大小为 r bit)与 C(大小为b-r bit)。这里的参数 r又叫做转换率(bitrate),而 c叫做容量(capacity)。填充函数会在输入里面增加足够的长度,让输入的比特流长度变成 r的整数倍。因此填充过后的输入可以被切成长度为 r的数个分段。然后,海绵函数运作如下:

  • S先初始化为零
  • 输入经过填充函数处理
  • 填充后输入的前面 r个bit会与R进行XOR运算
  • S经过函数 f转换成 f(S)
  • 如果填充后输入还有剩余,下一 r bit的分段与 R进行XOR运算
  • S转换成f(S)

这过程一直重复到所有的输入都用完为止(在海棉的譬喻里面,被函数“吸收[absorb]”了)。

现在海绵函数可以依照如下的过程输出(“挤出”[squeeze]内容):

  • 此时 R里面的数据是输出的前面 r个 bit
  • 如果需要更多输出,先把 S转换成f(S)
  • 此时R里面的数据是输出的下面 r个bit

这过程会重复到满足输出所需要的长度为止。这里值得注意的地方是,输入绝对不会与C这部分的存储器作XOR运算,而且 C这一部分存储器也不会直接被输出。 C这一部分的存储器仅仅只和转换函数f相关。在散列里面,防止撞击攻击(Collision attack)或者原像攻击(preimage attack)是依靠 C这段存储器作到的。一般实做上 C的大小会是所希望防止等级的两倍。

    开源hash算法实现org.bouncycastle中,其海绵函数实现则对应于 KeccakDigest(implement of Keccak)。这里补充一下,sha3 的核心是进一步封装了KeccakDigest 中 absorb 以及 squeeze。我们通过一段代码来了解一下:

    // 接受任意长度的字节数组内容输入
    // 返回长度为 256字节的散列结果
    public static byte[] sha3_256(byte[] bytes) {
        Digest digest256 = new SHA3Digest(256);
        //absorb
        digest256.update(bytes, 0, bytes.length);

        //结果存放,大小为256
        byte[] result = new byte[digest256.getDigestSize()];

        // squeeze,将散列结果写入result
        digest256.doFinal(result, 0);

        return result;
    }

   //SHA3Digest 继承于 Keccak ,对hash 结果的大小进行裁剪封装
    public class SHA3Digest extends KeccakDigest {
        public SHA3Digest(int bitLength) {
            //KeccakDigest(int bitLength)
            super(checkBitLength(bitLength));
        }
    }

上述代码段是sha3_256 的封装,入参是任意长度的字节数组,返回长度为 256/8 = 32字节数组的散列结果,具体的做法是通过海绵函数Keccak所提供absorb-squeeze 来实现,当然,根据上述absorb-squeeze 可以反复调用的,具体看使用者如何来架构自身的加密体系。另外,本章节不会升入Keccak 中的absorb-squeeze的代码详细。

    而IOTA 中的Kerl hash 算法,同样也是封装了KeccakDigest(384),下面详细分析。

2.3 Kerl 算法详解

    经过上面的分析,我们了解了Keccak 算法的实现原理。一方面,我们在《IOTA基石 - 三进制系统之 Trit 和 Tryte》章节中已详细分析iota 是基于三级制构建的,而KeccakDigest 接受的输入是byte 数组,返回也是字节数组;因此,Kerl 算法核心是在将输入的三进制数组转成 byte 数组作为输入,经过Keccak的absorb-squeeze 后,把输出结果转为再次转为三进制,详细先看absorb:

    public void absorb(final byte[] trits, final int offset, final int length) {
        if (length % 243 != 0) {
            throw new RuntimeException("Illegal length: " + length);
        }
        // HASH_LENGTH = 243
        // 分段处理
        for (int pos = offset; pos < offset + length; pos += HASH_LENGTH) {
            //BYTE_HASH_LENGTH = 384/8
            //convert to bytes && update
            byte[] state = new byte[BYTE_HASH_LENGTH];
            // 最后一位设置为0?
            trits[pos + HASH_LENGTH - 1] = 0;
            bytesFromBigInt(bigIntFromTrits(trits, pos, HASH_LENGTH), state);
            // absorb
            keccak.update(state);
        }
    }

上述代码段为封装keccak的absorb的实现,核心是先通过bigIntFromTrits(...)将传进的三进制字节转bigInt,然后在通过bytesFromBigInt(...)将biguInt 转成正常的字节数组,最后在使用keccak原生的absorb 实现。当然,这里是以243大小 对trits进行分段absorb,基于iota 定义hash 大小为243。对于具体的bigIntFromTrits(...) 以及 bytesFromBigInt(...) 已在《IOTA 三进制系统之 Trit 和 Tryte》中详细分析,这里不再深入。我们接着分析squeeze(...):

    public void squeeze(final byte[] trits, final int offset, final int length) {
        if (length % 243 != 0) {
            throw new IllegalArgumentException("Illegal length: " + length);
        }
        try {
            for (int pos = offset; pos < offset + length; pos += HASH_LENGTH) {

                byte[] state = new byte[BYTE_HASH_LENGTH];
                //squeeze
                keccak.digest(state, 0, BYTE_HASH_LENGTH);

                //convert into trits
                BigInteger value = new BigInteger(state);
                tritsFromBigInt(value, trits, pos, Sponge.HASH_LENGTH);
                trits[pos + HASH_LENGTH - 1] = 0;

                //calculate hash again
                for (int i = state.length; i-- > 0; ) {
                    state[i] = (byte) (state[i] ^ 0xFF);
                }
                keccak.update(state);
            }
        } catch (DigestException e) {
            e.printStackTrace(System.err);
            throw new RuntimeException(e);
        }
    }

基于absorb 是分段处理,同理,squeeze也需要分段处理,通过keccak原生的squeeze(这里对应方法keccak.digest(state, 0, BYTE_HASH_LENGTH))对相应的243 分段获取hash摘要结果,结果是byte 字节数组,存放于临时字节数组遍历state中,然后在通过tritsFromBigInt(...)将state 转为 trits。
到这里,kerl 实现分析完毕。

2.4 Curl 算法详解

    刚刚在上文有提到,Curl hash 算法用途主要有两类,一类是生成transaction 模型的唯一hash,另外一类主要是用于pow 运行;而Curl 的pow 类运算实现已有相应PearlDiver (可理解为Curl中相应的pow 实现被移到PearlDiver 中)类实现,因此,本章节不会分析pow 相应hash 运算,会在后续的pow 实现中在详细分析,这里主要是分析生成唯一hash的转换实现。当然,这里也只是分析其工程实现,至于具体的数学论证本章节不会涉及。

    因为Curl 也是海绵函数,因此我们只需分析absorb-squeeze 即可:

//------------------------absorb
    private static final int STATE_LENGTH = 3 * HASH_LENGTH; // HASH_LENGTH = 243

    private final byte[] state;

    // 构造函数,27/81
    protected Curl(SpongeFactory.Mode mode) {
        switch(mode) {
            case CURLP27: {
                numberOfRounds = NUMBER_OF_ROUNDSP27;
            } break;
            case CURLP81: {
                numberOfRounds = NUMBER_OF_ROUNDSP81;
            } break;
            default: throw new NoSuchElementException("Only Curl-P-27 and Curl-P-81 are supported.");
        }
        state = new byte[STATE_LENGTH];
        //...
    }

    public JCurl absorb(final int[] trits) {
        return absorb(trits, 0, trits.length);
    }

    public JCurl absorb(final int[] trits, int offset, int length) {

        do {
            System.arraycopy(trits, offset, state, 0, length < HASH_LENGTH ? length : HASH_LENGTH);
            transform();
            offset += HASH_LENGTH;
        } while ((length -= HASH_LENGTH) > 0);

        return this;
    }

    public int[] squeeze(final int[] trits) {
        return squeeze(trits, 0, trits.length);
    }
//-------------------------- sqeeze
    public int[] squeeze(final int[] trits, int offset, int length) {

        do {
            System.arraycopy(state, 0, trits, offset, length < HASH_LENGTH ? length : HASH_LENGTH);
            transform();
            offset += HASH_LENGTH;
        } while ((length -= HASH_LENGTH) > 0);

        return state;
    }

从上述实现中,我们可以看到absorb以及 squeeze 实现一致,首先都是 分段处理输入,每段大小为3 * 243;然后在通过当前状态存储 字节数组 state 以及 入参trits作transform()转换。当然,absorb 流程中,将入参trits 的内容作为 state 的初始值;因此,我们继续深入transform():


    private static final byte[] TRUTH_TABLE = {1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0};

    private final byte[] state;

    // STATE_LENGTH = 3 * 243
    private final byte[] scratchpad = new byte[STATE_LENGTH];

    private void transform() {

        int scratchpadIndex = 0;
        int prevScratchpadIndex = 0;
        // 转换轮次numberOfRounds(27/81)
        for (int round = 0; round < numberOfRounds; round++) {
             // 将没一轮次的转换结果state 全量拷贝至scratchpad
            System.arraycopy(state, 0, scratchpad, 0, STATE_LENGTH);
            for (int stateIndex = 0; stateIndex < STATE_LENGTH; stateIndex++) {
                prevScratchpadIndex = scratchpadIndex;
                if (scratchpadIndex < 365) {
                    scratchpadIndex += 364;
                } else {
                    scratchpadIndex += -365;
                }
                state[stateIndex] = TRUTH_TABLE[scratchpad[prevScratchpadIndex] + (scratchpad[scratchpadIndex] << 2) + 5];
            }
        }
    }

上面的转换算法比较简单易读,核心是反复对自身转换的结果按照同样的方式进行转换指定次数(27 或者 81 次),第一个for 主要是控制转换轮次,并将上一次转换结果全量拷贝至辅助状态scratchpad 中(两者都是长度相同的字节数组);第二个for 循环式执行正真的转换,根据上次转换结果scratchpad 作为参考转。

转换方式如下:

stateIndex从0到STATE_LENGTH 重新计算每一个state[stateIndex] 的数值。计算方式为TRUTH_TABLE[scratchpad[prevScratchpadIndex] + (scratchpad[scratchpadIndex] << 2) + 5] 。即根据scratchpad[prevScratchpadIndex] + (scratchpad[scratchpadIndex] << 2) + 5作为index,从TRUTH_TABLE 获取相应的整数值。scratchpadIndex 从0开始,每一次for 循环作一次变更,变更条件是如果当前scratchpadIndex值小于365,则加364,否则减365;而prevScratchpadIndex则取上一次scratchpadIndex的值。上述所使用的是(代换-置换网络)算法实现。

到这里,Sponge 算法详解 分析完毕。

推荐阅读更多精彩内容

  • 一:项目简介 IOTA全称MIOTA, 它是一个开源的分布式账户,IOTA的初衷是一个给物联网(IoT, Inte...
    钰真阅读 1,435评论 0 5
  • 一:项目简介 IOTA全称MIOTA, 它是一个开源的分布式账户,IOTA的初衷是一个给物联网(IoT, Inte...
    张锦沛翀阅读 348评论 1 2
  • 一、什么是CURL? cURL 是一个利用URL语法规定来传输文件和数据的工具,支持很多协议,如HTTP、FTP、...
    伊Summer阅读 663评论 0 4
  • Hash函数的核心在于设计压缩函数。可以证明,如果压缩函数具有抗碰撞能力,那么迭代Hash函数也具有抗碰撞能力。2...
    wenj1997阅读 1,927评论 1 2
  • IOTA项目的评级结果为BB,该项目存在一定的风险,容易受内部和外部因素影响,且有可能出现大的波动。 针对物联网存...
    TokenInsight阅读 570评论 0 3