块密码的 CTR 计数器模式

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

加密:

解密:

图中 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
	}
}