0

我正在使用 Blowfish.NET 最新版本，但有一个问题。

responce = new byte[6]
{
     0x00, 0x80 ,0x01, 0x61, 0x00, 0x00
};
byte[] encrypted = new byte[responce.Length];
blowfish.Encrypt(responce, 2, encrypted, 2, input.Length - 2);

我用正确的方式称呼它，我希望它从第三个字节开始读/写，长度为 6 - 2，因为我不使用两个字节。

问题：

        public int Encrypt(
        byte[] dataIn,
        int posIn,
        byte[] dataOut,
        int posOut,
        int count) 
    {
        uint[] sbox1 = this.sbox1;
        uint[] sbox2 = this.sbox2;
        uint[] sbox3 = this.sbox3;
        uint[] sbox4 = this.sbox4;

        uint[] pbox = this.pbox;

        uint pbox00 = pbox[ 0];
        uint pbox01 = pbox[ 1];
        uint pbox02 = pbox[ 2];
        uint pbox03 = pbox[ 3];
        uint pbox04 = pbox[ 4];
        uint pbox05 = pbox[ 5];
        uint pbox06 = pbox[ 6];
        uint pbox07 = pbox[ 7];
        uint pbox08 = pbox[ 8];
        uint pbox09 = pbox[ 9];
        uint pbox10 = pbox[10];
        uint pbox11 = pbox[11];
        uint pbox12 = pbox[12];
        uint pbox13 = pbox[13];
        uint pbox14 = pbox[14];
        uint pbox15 = pbox[15];
        uint pbox16 = pbox[16];
        uint pbox17 = pbox[17]; // till this line count is 4

        count &= ~(BLOCK_SIZE - 1); //count becomes 0 after that calc :((

        int end = posIn + count; // 2 + 0 = 2

        while (posIn < end) //no loop :[
        {
            uint hi = (((uint)dataIn[posIn + 3]) << 24) |
                      (((uint)dataIn[posIn + 2]) << 16) |
                      (((uint)dataIn[posIn + 1]) <<  8) |
                              dataIn[posIn    ];

            uint lo = (((uint)dataIn[posIn + 7]) << 24) |
                      (((uint)dataIn[posIn + 6]) << 16) |
                      (((uint)dataIn[posIn + 5]) <<  8) |
                              dataIn[posIn + 4];
            posIn += 8; 

            hi ^= pbox00;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox01;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox02;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox03;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox04;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox05;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox06;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox07;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox08;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox09;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox10;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox11;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox12;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox13;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox14;
            lo ^= (((sbox1[(int)(hi >> 24)] + sbox2[(int)((hi >> 16) & 0x0ff)]) ^ sbox3[(int)((hi >> 8) & 0x0ff)]) + sbox4[(int)(hi & 0x0ff)]) ^ pbox15;
            hi ^= (((sbox1[(int)(lo >> 24)] + sbox2[(int)((lo >> 16) & 0x0ff)]) ^ sbox3[(int)((lo >> 8) & 0x0ff)]) + sbox4[(int)(lo & 0x0ff)]) ^ pbox16;

            lo ^= pbox17;

            dataOut[posOut + 3] = (byte)(lo >> 24);
            dataOut[posOut + 2] = (byte)(lo >> 16);
            dataOut[posOut + 1] = (byte)(lo >>  8);
            dataOut[posOut    ] = (byte) lo;

            dataOut[posOut + 7] = (byte)(hi >> 24);
            dataOut[posOut + 6] = (byte)(hi >> 16);
            dataOut[posOut + 5] = (byte)(hi >>  8);
            dataOut[posOut + 4] = (byte) hi;

            posOut += 8;
        }

        return count;
    }

如果我传递更长的数据，河豚工作正常，但我需要加密这个。我们找到了问题，但我的问题是：如何解决它？！

4

3 回答 3

7

我对 Blowfish 算法或者您使用的库不是很熟悉。但是，总的来说，我会说，如果你的数据不够长而无法加密，你可以填充它。换句话说...如果您的数据不够长，请在加密之前在数据的开头或结尾添加一堆零（或其他字符，如果零对您具有特殊意义）。然后，当你解密它时，修剪填充字符。

于 2009-03-31T22:41:18.837 回答
2

您正在尝试对大小不完全是一个块的东西使用块密码。如果您的数据不完全是 8 个字节长，您应该使用现有的填充算法以及定义明确的模式。也就是说，您为什么要实现自己的河豚功能而不是使用预制库？

于 2009-03-31T23:09:42.153 回答
2

有一些标准方法可以填充数据，使其具有适合给定块加密算法的长度。

此页面包含可用选项的良好概述。

我们需要用填充字节填充块以使其达到所需的长度。至少有五个常见的约定：

  1. 使用与填充字节数相同的字节填充
  2. 用 0x80 填充，后跟零字节
  3. 用零填充，除了使最后一个字节等于填充字节数
  4. 用零（空）字符填充
  5. 用空格字符填充

方法一是在 PKCS#5、PKCS#7 和 RFC 3852 第 6.3 节（以前的 RFC 3369 和 RFC 2630）中描述的方法。它是最常用的，也是我们在没有任何其他考虑的情况下推荐的。

但是由于您似乎总是在加密固定长度的短消息，因此填充可以有效地削弱加密。您可以用随机数填充它并在解密后将它们丢弃。

于 2009-03-31T23:30:56.173 回答