最近由于工作的需要，需要的实现一个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)
}
