blowfish java_Java语言实现Blowfish加密算法完整代码分享

关学

2023-12-01

前几天网上突然出现流言：某东发生数据泄露12G，最终某东在一篇声明中没有否认，还算是勉强承认了吧，这件事对于一般人有什么影响、应该怎么做已经有一堆人说了，所以就不凑热闹了，咱来点对程序猿来说实际点的，说一个个人认为目前比较安全的加密算法：Blowfish。

上代码之前，先说几点Blowfish加密算法的特点：

1. 对称加密，即加密的密钥和解密的密钥是相同的；

2. 每次加密之后的结果是不同的(这也是老夫比较欣赏的一点)；

3. 可逆的，和老夫之前的文章介绍的md5等摘要算法不一样，他是可逆的；

4. 速度快，加密和解密的过程基本上由ADD和XOR指令运算组成；

5. 免费，任何人都可以免费使用不需要缴纳版权费；

6. BlowFish 每次只能加密和解密8字节数据；

Blowfish算法是一种对称的分组加密算法，算法核心在于子密钥生成，它将变长密钥扩展成总长4168Byte的子密钥数组。算法中使用了大量的子密钥，而子密钥又依赖于用户密钥，实际加/解密过程中使用的是更新后的子密钥数组，子密钥即P数组和S盒。Blowfish算法有一个核心加密函数:BF_En()，该函数的输人是64位明文信息，经过运算，以64位密文信息的形式输出。用Blowfish算法加密信息，需要两个过程:密钥预处理和信息加密。同样，解密亦需要两个过程，密钥预处理和信息解密。

Blowfish算法的源密钥——pbox和sbox是固定的，而我们要加密一个信息，需要自己选择一个key，用这个key对pbox和sbox进行变换，得到下一步信息加密所要用的key_pbox和key_sbox。解密亦是如此，由于Blowfish是对称加密算法，解密方在得到key后根据key生成解密所需的key_box和key_sbox。对同一个信息加密解密，选取的key的不同会导致密文的不同。因此，Blowfish算法的关键在于key的选择以及保密。

由于Blowfish算法采用变长密钥，这在给用户带来极大便利的同时也有隐患。由于算法加/解密核心在于密钥的选择和保密，但在实际应用中经常使用一些弱密钥对信息资源进行加密，导致存在着很大的安全隐患

接下来就是最重要的部分，Blowfish加密算法的实现：

package cn.bridgeli.encrypt;

public enum BlowfishManager {

BRIDGELI_CN("bridgeli_cn!@#$abc123_");

private BlowfishManager(String secret) {

this.blowfish = new Blowfish(secret);

}

private Blowfish blowfish;

public Blowfish getBlowfish() {

return blowfish;

}

/**

* 解密

* @param sCipherText

* @return

public String decryptString(String sCipherText){

return this.getBlowfish().decryptString(sCipherText);

}

/**

* 加密

* @param sPlainText

* @return

public String encryptString(String sPlainText){

return this.getBlowfish().encryptString(sPlainText);

}

public static void main(String[] args) {

String encryptString = BlowfishManager.BRIDGELI_CN.encryptString(10 + "");

System.out.println(encryptString);

String decryptString = BlowfishManager.BRIDGELI_CN.decryptString(encryptString);

System.out.println(decryptString);

}

这是对外的接口，使用起来非常简单，对用户很友好，下面是算法的具体实现：

package cn.bridgeli.encrypt;

import java.security.MessageDigest;

import java.util.Random;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Blowfish {

private static final Logger LOG = LoggerFactory.getLogger(Blowfish.class);

private static class BlowfishCBC extends BlowfishECB {

public void setCBCIV(long lNewCBCIV) {

m_lCBCIV = lNewCBCIV;

}

public void setCBCIV(byte newCBCIV[]) {

m_lCBCIV = Blowfish.byteArrayToLong(newCBCIV, 0);

}

@Override

public void cleanUp() {

m_lCBCIV = 0L;

super.cleanUp();

}

private long encryptBlockCBC(long lPlainblock) {

lPlainblock ^= m_lCBCIV;

lPlainblock = super.encryptBlock(lPlainblock);

return m_lCBCIV = lPlainblock;

}

private long decryptBlockCBC(long lCipherblock) {

long lTemp = lCipherblock;

lCipherblock = super.decryptBlock(lCipherblock);

lCipherblock ^= m_lCBCIV;

m_lCBCIV = lTemp;

return lCipherblock;

}

public void encrypt(byte buffer[]) {

int nLen = buffer.length;

for (int nI = 0; nI < nLen; nI += 8) {

long lTemp = Blowfish.byteArrayToLong(buffer, nI);

lTemp = encryptBlockCBC(lTemp);

Blowfish.longToByteArray(lTemp, buffer, nI);

}

public void decrypt(byte buffer[]) {

int nLen = buffer.length;

for (int nI = 0; nI < nLen; nI += 8) {

long lTemp = Blowfish.byteArrayToLong(buffer, nI);

lTemp = decryptBlockCBC(lTemp);

Blowfish.longToByteArray(lTemp, buffer, nI);

}

long m_lCBCIV;

public BlowfishCBC(byte bfkey[]) {

super(bfkey);

setCBCIV(0L);

}

public BlowfishCBC(byte bfkey[], long lInitCBCIV) {

super(bfkey);

setCBCIV(lInitCBCIV);

}

public BlowfishCBC(byte bfkey[], byte initCBCIV[]) {

super(bfkey);

setCBCIV(initCBCIV);

}

private static class BlowfishECB {

public void cleanUp() {

for (int nI = 0; nI < 18; nI++) {

m_pbox[nI] = 0;

}

for (int nI = 0; nI < 256; nI++) {

m_sbox1[nI] = m_sbox2[nI] = m_sbox3[nI] = m_sbox4[nI] = 0;

}

protected long encryptBlock(long lPlainBlock) {

int nHi = Blowfish.longHi32(lPlainBlock);

int nLo = Blowfish.longLo32(lPlainBlock);

int sbox1[] = m_sbox1;

int sbox2[] = m_sbox2;

int sbox3[] = m_sbox3;

int sbox4[] = m_sbox4;

int pbox[] = m_pbox;

nHi ^= pbox[0];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[1];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[2];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[3];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[4];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[5];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[6];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[7];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[8];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[9];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[10];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[11];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[12];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[13];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[14];

nLo ^= (sbox1[nHi >>> 24] + sbox2[nHi >>> 16 & 0xff] ^ sbox3[nHi >>> 8 & 0xff])

+ sbox4[nHi & 0xff] ^ pbox[15];

nHi ^= (sbox1[nLo >>> 24] + sbox2[nLo >>> 16 & 0xff] ^ sbox3[nLo >>> 8 & 0xff])

+ sbox4[nLo & 0xff] ^ pbox[16];

return Blowfish.makeLong(nHi, nLo ^ pbox[17]);

}

protected long decryptBlock(long lCipherBlock) {

int nHi = Blowfish.longHi32(lCipherBlock);

int nLo = Blowfish.longLo32(lCipherBlock);

nHi ^= m_pbox[17];