iovxw

块密码的 CTR 计数器模式

简单到不用讲。异或!XOR!

块加密流加密之类的就不说了,只是单独说一下这个加密模式


加密:

https://img.vim-cn.com/40/11dd9afbfff13f3e30abc05e629ede5ee6f7df.svg

解密:

https://img.vim-cn.com/7c/dfaca07b79623cd25859cff4813465b19260ce.svg

图中 Nonce 为一个随机值,就是 IV,加密端和解密端的 Nonce 需相同

Counter 是计数器,一般来说就是普通的递增计数器。不过只要能保证输出不重复就行(比如一次增加2或者弄个伪随机数生成器都是可以的,当然加密解密端都要一样实现)

Counter 的作用是保证同一个流中一样的数据加密后不是一样的结果,比如 [1, 1, 1] 加密后不是 [2 ,2, 2] 而是 [2, 3, 4]

而 Nonce 的作用是多个流中相同的数据加密后不一样,比如第一个流的 Nonce 为 0,[1, 1, 1] 加密后为 [2, 3, 4],第二个流的 Nonce 为 1,[1, 1, 1] 加密后为 [3, 4, 5]

当然上面的 [1, 1, 1] 只是演示一下,真的加密不是这样的

CTR 模式只需要一个加密方法(比如AES,甚至直接计算hash都可以,只要长度没问题),因为密文是加密 Nonce + Counter 后与明文异或得到的

解密的时候也只需要再加密一遍 Nonce + Counter 后与密文异或(异或运算是个好东西啊)

又因为是用的计数器,块之前的加密没有直接联系,所以只要知道块的位置就可以直接加密解密,并行加解密也成为可能(在多处理器上优势大)


最后附上肯定没人看的 golang 的 CTR 实现:

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Counter (CTR) mode.

// CTR converts a block cipher into a stream cipher by
// repeatedly encrypting an incrementing counter and
// xoring the resulting stream of data with the input.

// See NIST SP 800-38A, pp 13-15

package cipher

type ctr struct {
    b       Block
    ctr     []byte
    out     []byte
    outUsed int
}

const streamBufferSize = 512

// NewCTR returns a Stream which encrypts/decrypts using the given Block in
// counter mode. The length of iv must be the same as the Block's block size.
func NewCTR(block Block, iv []byte) Stream {
    if len(iv) != block.BlockSize() {
        panic("cipher.NewCTR: IV length must equal block size")
    }
    bufSize := streamBufferSize
    if bufSize < block.BlockSize() {
        bufSize = block.BlockSize()
    }
    return &ctr{
        b:       block,
        ctr:     dup(iv),
        out:     make([]byte, 0, bufSize),
        outUsed: 0,
    }
}

func (x *ctr) refill() {
    remain := len(x.out) - x.outUsed
    if remain > x.outUsed {
        return
    }
    copy(x.out, x.out[x.outUsed:])
    x.out = x.out[:cap(x.out)]
    bs := x.b.BlockSize()
    for remain < len(x.out)-bs {
        x.b.Encrypt(x.out[remain:], x.ctr)
        remain += bs

        // Increment counter
        for i := len(x.ctr) - 1; i >= 0; i-- {
            x.ctr[i]++
            if x.ctr[i] != 0 {
                break
            }
        }
    }
    x.out = x.out[:remain]
    x.outUsed = 0
}

func (x *ctr) XORKeyStream(dst, src []byte) {
    for len(src) > 0 {
        if x.outUsed >= len(x.out)-x.b.BlockSize() {
            x.refill()
        }
        n := xorBytes(dst, src, x.out[x.outUsed:])
        dst = dst[n:]
        src = src[n:]
        x.outUsed += n
    }
}