[golang] Blowfish算法的go实现

最近由于工作的需要，需要的实现一个go的Blowfish算法。其实go本身有一个加密算法库crypto，其中有Blowfish。但是该算法在很多细节上跟我的需求不同，导致最终加密结果千差万别。

Blowfish算法

BlowFish是对称加密算法的其中一种。在很多场景下，作为DES的替代出现。BlowFish并不是直接用我们指定的密钥对数据加密，而是先对密钥进行预处理，然后用处理的结果再对数据加密。解密过程同理。

BlowFish算法内置两个源密钥：pbox和sbox，pbox18位数组，sbox4个256位数组组成。算法在加密解密时，根据两个盒子大量使用位移运算和逻辑位运算。具体的算法细节自行百度/谷歌，本文就不详述了。

GO实现

1. 生成pbox和sbox

几个重要的变量声明

var (
    Pencs string = "!!!这是一个18位长度的串!!!"
    Sencs string = "!!!这是一个1024位长度的串!!!"

    Penc []uint8 = []uint8(Pencs)
    Senc []uint8 = []uint8(Sencs)

    Pinit []uint32 = make([]uint32, len(Penc)*7/32)
    Sinit []uint32 = make([]uint32, len(Senc)*7/32)

    PPP  []uint32 = make([]uint32, 18)  //p盒子
    SSS0 []uint32 = make([]uint32, 256) //第一个盒子
    SSS1 []uint32 = make([]uint32, 256) //第二个盒子
    SSS2 []uint32 = make([]uint32, 256) //第三个盒子
    SSS3 []uint32 = make([]uint32, 256) //第四个盒子
)

生成pbox和sbox

将2个盒子的源串Pencs和Sencs，每个字节右移一定位数，生成中间数组Pinit和Sinit

func initParam() {
    var poff int32 = 25
    plen := len(Penc)
    for i, j := 0, 0; j < plen; j++ {
        if j == plen-1 {
            Pinit[i] |= uint32(Penc[j]) >> uint32(-poff)
        } else if poff < 0 {
            Pinit[i] |= uint32(Penc[j]) >> uint32(-poff)
            i++
            poff += 32
            Pinit[i] |= uint32(Penc[j]) << uint32(poff)
        } else {
            Pinit[i] |= uint32(Penc[j]) << uint32(poff)
        }
        poff -= 7
    }
    var soff int32 = 25
    slen := len(Senc)
    for i, j := 0, 0; j < slen; j++ {
        if j == slen-1 {
            Sinit[i] |= uint32(Senc[j]) >> uint32(-soff)
        } else if soff < 0 {
            Sinit[i] |= uint32(Senc[j]) >> uint32(-soff)
            i++
            soff += 32
            Sinit[i] |= uint32(Senc[j]) << uint32(soff)
        } else {
            Sinit[i] |= uint32(Senc[j]) << uint32(soff)
        }
        soff -= 7
    }
}

2. 密钥预处理

func SetKey(key []uint8) {
    ptemp := []uint32{0, 0}
    stemp := [][]uint32{SSS0, SSS1, SSS2, SSS3}
    copy(PPP, Pinit)
    for i, j := 0, 0; i < 4; i++ {
        copy(stemp[i], Sinit[j:])
        j += 256
    }

    lenth := len(key)
    ll := 0
    for i, j := uint32(0), uint32(0); i < 18; i++ {
        for k := 0; k < 4; k++ {
            ll %= lenth
            j = j<<8 | uint32(key[ll])&255
            ll++
        }
        PPP[i] ^= j
    }
    encryptKey(ptemp, 0, PPP, 0)
    for i := uint32(0); i < 16; i += 2 {
        encryptKey(PPP, i, PPP, i+2)
    }
    encryptKey(PPP, 16, stemp[0], 0)
    for j := uint32(2); j < 256; j += 2 {
        encryptKey(stemp[0], uint32(j-2), stemp[0], uint32(j))
    }
    k := 0
    l := 254
    for i := 1; i < 4; i++ {
        for j := 0; j < 256; j += 2 {
            encryptKey(stemp[k], uint32(l), stemp[i], uint32(j))
            k = i
            l = j
        }
    }
}

func encryptKey(in []uint32, inOff uint32, out []uint32, outOff uint32) {
    left := in[inOff] ^ PPP[0]
    inOff++
    right := in[inOff]
    for i := 0; i < 16; i++ {
        temp := (SSS0[left>>24&255] + SSS1[left>>16&255] ^ SSS2[left>>8&255]) + SSS3[left&255]
        i++
        right ^= temp ^ PPP[i]
        temp = (SSS0[right>>24&255] + SSS1[right>>16&255] ^ SSS2[right>>8&255]) + SSS3[right&255]
        left ^= temp ^ PPP[i+1]
    }
    out[outOff] = right ^ PPP[17]
    outOff++
    out[outOff] = left
}

3. 加密

func Encrypt(encryptable []uint8) []uint8 {
    blocks := len(encryptable) / 64
    rem := len(encryptable) % 64
    length := blocks * 64
    var output []uint8
    if rem > 0 {
        output = make([]uint8, length+64)
    } else {
        output = make([]uint8, length)
    }
    for i := 0; i < 64-rem; i++ {
        encryptable = append(encryptable, 0)
    }
    for i := 0; i < len(encryptable); i += 8 {
        encryptBytes(encryptable, uint32(i), output, uint32(i))
    }
    return output
}

func encryptBytes(in []uint8, inOff uint32, out []uint8, outOff uint32) {
    left := ((uint32(in[inOff])&255)<<24 | (uint32(in[inOff+1])&255)<<16 | (uint32(in[inOff+2])&255)<<8 | (uint32(in[inOff+3]) & 255)) ^ PPP[0]
    right := (uint32(in[inOff+4])&255)<<24 | (uint32(in[inOff+5])&255)<<16 | (uint32(in[inOff+6])&255)<<8 | uint32(in[inOff+7])&255
    for i := 1; i < 17; i += 2 {
        right ^= (SSS0[left>>24&255] + SSS1[left>>16&255] ^ SSS2[left>>8&255]) + SSS3[left&255] ^ PPP[i]
        left ^= (SSS0[right>>24&255] + SSS1[right>>16&255] ^ SSS2[right>>8&255]) + SSS3[right&255] ^ PPP[i+1]
    }
    right ^= PPP[17]
    out[outOff] = uint8(right >> 24 & 255)
    out[outOff+1] = uint8(right >> 16 & 255)
    out[outOff+2] = uint8(right >> 8 & 255)
    out[outOff+3] = uint8(right & 255)
    out[outOff+4] = uint8(left >> 24 & 255)
    out[outOff+5] = uint8(left >> 16 & 255)
    out[outOff+6] = uint8(left >> 8 & 255)
    out[outOff+7] = uint8(left & 255)
}