zoukankan      html  css  js  c++  java

  • 加密算法之BLOWFISH算法

    加密信息

    　　BlowFish算法用来加密64Bit长度的字符串。

    　　BlowFish算法使用两个“盒”——ungignedlongpbox[18]和unsignedlongsbox[4,256]。

    　　BlowFish算法中，有一个核心加密函数:BF_En(后文详细介绍）。该函数输入64位信息，运算后，以64位密文的形式输出。用BlowFish算法加密信息，需要两个过程：

    　　1.密钥预处理

    　　2.信息加密

    　　分别说明如下：

    　　密钥预处理：

    　　BlowFish算法的源密钥——pbox和sbox是固定的。我们要加密一个信息，需要自己选择一个key，用这个key对pbox和sbox进行变换，得到下一步信息加密所要用的key_pbox和key_sbox。具体的变化算法如下：

    　　1)用sbox填充key_sbox

    　　2)用自己选择的key8个一组地去异或pbox，用异或的结果填充key_pbox。key可以循环使用。

    　　比如说：选的key是"abcdefghijklmn"。则异或过程为：

    　　key_pbox[0]=pbox[0]^abcdefgh

    　　key_pbox[1]=pbox[1]^ijklmnab

    　　…………

    　　…………

    　　如此循环，直到key_box填充完毕。

    　　3)用BF_En加密一个全0的64位信息，用输出的结果替换key_pbox[0]和key_pbox[1]。i=0

    　　4)用BF_En加密替换后的key_pbox,key_pbox[i+1],用输出替代key_pbox[i+2]和key_pbox[i+3]

    　　5)i+2，继续第4步，直到key_pbox全部被替换

    　　6)用key_pbox[16]和key_pbox[17]做首次输入（相当于上面的全0的输入），用类似的方法，替换key_sbox信息加密。信息加密就是用函数把待加密信息x分成32位的两部分:xL,xRBF_En对输入信息进行变换，BF_En函数详细过程如下：

    　　对于i=1至16

    　　xL=xL^Pi

    　　xR=F(xL)^xR

    　　交换xL和xR(最后一轮取消该运算)

     

    blowfish算法

    xR=xR^P17

    　　xL=xL^P18

    　　重新合并xL和xR

    　　函数F见下图:

    　　8位32位

    　　|-----------S盒1-----------

    　　||加

    　　|8位32位|----

    　　|-----------S盒2-----------|

    　　||

    　　||异或----

    　　32位-|||

    　　|8位32位||

    　　|-----------S盒3---------------|加

    　　||-----------------32位

    　　||

    　　||

    　　|8位32位|

    　　|-----------S盒4-----------------------

    　　把xL分成4个8位分组:a,b,c和d

    　　输出为：F(xL)=((((S[1,a]+S[2,b])MOD4294967296)^s[3,c])+S[4,d])MOD4294967296

    　　(2的32次方)(2的32次方)

    　　重新合并后输出的结果就是我们需要的密文。

    算法解密

    　　用BlowFish算法解密，同样也需要两个过程。

    　　1.密钥预处理

    　　2.信息解密

    　　密钥预处理的过程与加密时完全相同

    　　信息解密的过程就是把信息加密过程的key_pbox逆序使用即可。

    　　可以看出，选择不同的key，用BlowFish算法加密同样的信息，可以得出不同的结果。

    　　要破解BlowFish算法，就是要得到BlowFish算法的key。所以，使用BlowFish算法进行加密，最重要的也就是key的选择以及key的保密。其中key的选择可以使用bf_sdk中的_WeakKey函数进行检验。以下是该函数的说明：

    　　源文：

    　　---------------------------------------------------------------------------------------

    　　_WeakKey

    　　Function:TestifthegeneratedBoxesareweak

    　　Argument:none

    　　Return:AX=Status(1=weak,0=good)

    　　Affects:AX,BX,CX,DX,SI,DI,directionFlag

    　　Description:After"_InitCrypt"youshouldtesttheBoxeswiththisfunction.

    　　Iftheyprovideaweaknesswhichacryptoanalystcoulduseto

    　　breaktheciphera"1"isreturned.Inthiscaseyoushould

    　　reloadtheoriginalboxesandlettheuserchooseadifferent

    　　password.

    　　---------------------------------------------------------------------------------------

    　　译文：

    　　---------------------------------------------------------------------------------------

    　　_WeakKey

    　　功能：测试产生的box是否安全

    　　参数：无

    　　返回：AX=1不安全；AX=0安全

    　　影响：AX,BX,CX,DX,SI,DI,方向标志

    描述：使用"_InitCrypt"函数产生用于加密的Boxes后，你应该用这个函数测试产生的Boxes是否安全，如果该key产生的Boxes不安全——可以被密码分析者通过分析Boxes得到key，那么，你应该采用另外一个key产生一个安全的Boxes用来加密。

     

    BlowFish's 分析

    　　由于该CrackMe主要是测试你的密码学知识，所以没有在其他方面设关卡。为了减小文件体积，缩短大家下载的时间，用upx加了壳，直接用Trw2000的"PNewSec+Makepe"很方便地就能脱掉壳。

    　　用常规的方法，很快找到下面关键比较处：

    　　:004015D951pushecx

    　　:004015DA52pushedx

    　　:004015DB6880894000push00408980

    　　:004015E0E8EBFAFFFFcall004010D0//BF_De(sn)

    　　:004015E58B442464moveax,dwordptr[esp+64]

    　　:004015E98B0DF0994000movecx,dwordptr[004099F0]

    　　:004015EF83C41Caddesp,0000001C

    　　:004015F23BC1cmpeax,ecx//比较

    　　:004015F47529jne0040161F

    　　:004015F68B4C244Cmovecx,dwordptr[esp+4C]

    　　:004015FAA1EC994000moveax,dwordptr[004099EC]

    　　:004015FF3BC8cmpecx,eax//比较

    　　:00401601751Cjne0040161F

    　　:004016036A30push00000030

    　　由于BlowFish算法加密，解密输出的信息都是64Bit的，所以要进行两次比较。

    　　我们既然知道了他对我们的sn进行的变换是BF_De，那么，很显然，我们要找到程序初始化key_pbox和key_sbox的地方。跟进4015E0的Call，找到key_pbox在408980处，下bpm，然后跟踪，分析，找到程序初始化key_pbox和key_sbox的地方，如下：

    　　:004016C050pusheax

    　　*PossibleStringDataReffromDataObj->"CrackingForFun"

    　　|

    　　:004016C16844804000push00408044

    　　:004016C66880894000push00408980

    　　:004016CBE860FAFFFFcall00401130//初始化Boxes

    　　由此我们知道了BF_De(sn)的key是"CrackingForFun"。

    　　问题的一半已经解决了。下面我们来看用来比较的另外的64Bit的数是从何而来。

    　　bpm4099ECw

    　　跟踪分析后，发现这个用来比较的数是由BF_En(ComputerID,key="ChinaCrackingGroup")生成。

    　　至此，我们可以写出注册机的算法：

    　　sn=BF_En((BF_En(ComputerID,key="ChinaCrackingGroup"),key="CrackingForFun")

    　　只要你编程够强，密码学也还过得去，写出这个东西的注册机就不是困难的事情了。

    　　附：

    　　ComputerID的产生

    　　如果你对这个CrackMe很有兴趣，还想研究一下他的ComputerID是如何产生的，也可以继续跟踪，分析，在这里，我给处我分析的结果：

    　　ComputerID=BF_En(0776f6c62h,068736966h,key=PW_1)

    　　其中，PW_1就是你的Windows版本号，可以在“系统属性”里头看到，也就是注册表中的

    　　H_L_MSoftwareMicrosoftWindowsCurrentVersion中的ProductId项。在我的机器上是：

    　　"25001-OEM-0080247-46673"

    　　注册机源码里头有一些语句没有派上用场，用“;”屏蔽了，如果你有兴趣，可以把前面的;号去掉然后把.data段里头的PW_1换成你机器的ComputerID,再按照程序中的说明自己修改一下源程序，用Masm32V6重新编译，直接按Generate，也能得到正确的序列号。

     

    代码：

     

    [cpp] view plaincopy
    1. ////////////////////////////////////////////////////////////////////////////  
    2. ///  
    3. // Blowfish.h Header File  
    4. //  
    5. //    BLOWFISH ENCRYPTION ALGORITHM  
    6. //  
    7. //    Encryption and Decryption of Byte Strings using the Blowfish Encryption Algorithm.  
    8. //    Blowfish is a block cipher that encrypts data in 8-byte blocks. The algorithm consists  
    9. //    of two parts: a key-expansion part and a data-ancryption part. Key expansion converts a  
    10. //    variable key of at least 1 and at most 56 bytes into several subkey arrays totaling  
    11. //    4168 bytes. Blowfish has 16 rounds. Each round consists of a key-dependent permutation,  
    12. //    and a key and data-dependent substitution. All operations are XORs and additions on 32-bit words.  
    13. //    The only additional operations are four indexed array data lookups per round.  
    14. //    Blowfish uses a large number of subkeys. These keys must be precomputed before any data  
    15. //    encryption or decryption. The P-array consists of 18 32-bit subkeys: P0, P1,...,P17.  
    16. //    There are also four 32-bit S-boxes with 256 entries each: S0,0, S0,1,...,S0,255;  
    17. //    S1,0, S1,1,...,S1,255; S2,0, S2,1,...,S2,255; S3,0, S3,1,...,S3,255;  
    18. //  
    19. //    The Electronic Code Book (ECB), Cipher Block Chaining (CBC) and Cipher Feedback modes  
    20. //    are used:  
    21. //  
    22. //    In ECB mode if the same block is encrypted twice with the same key, the resulting  
    23. //    ciphertext blocks are the same.  
    24. //  
    25. //    In CBC Mode a ciphertext block is obtained by first xoring the  
    26. //    plaintext block with the previous ciphertext block, and encrypting the resulting value.  
    27. //  
    28. //    In CFB mode a ciphertext block is obtained by encrypting the previous ciphertext block  
    29. //    and xoring the resulting value with the plaintext  
    30. //  
    31. //    The previous ciphertext block is usually stored in an Initialization Vector (IV).  
    32. //    An Initialization Vector of zero is commonly used for the first block, though other  
    33. //    arrangements are also in use.  
    34.   
    35. /* 
    36. http://www.counterpane.com/vectors.txt 
    37. Test vectors by Eric Young.  These tests all assume Blowfish with 16 
    38. rounds. 
    39.  
    40. All data is shown as a hex string with 012345 loading as 
    41. data[0]=0x01; 
    42. data[1]=0x23; 
    43. data[2]=0x45; 
    44. ecb test data (taken from the DES validation tests) 
    45.  
    46. key bytes               clear bytes             cipher bytes 
    47. 0000000000000000        0000000000000000        4EF997456198DD78 
    48. FFFFFFFFFFFFFFFF        FFFFFFFFFFFFFFFF        51866FD5B85ECB8A 
    49. 3000000000000000        1000000000000001        7D856F9A613063F2  ??? 
    50. 1111111111111111        1111111111111111        2466DD878B963C9D 
    51. 0123456789ABCDEF        1111111111111111        61F9C3802281B096 
    52. 1111111111111111        0123456789ABCDEF        7D0CC630AFDA1EC7 
    53. 0000000000000000        0000000000000000        4EF997456198DD78 
    54. FEDCBA9876543210        0123456789ABCDEF        0ACEAB0FC6A0A28D 
    55. 7CA110454A1A6E57        01A1D6D039776742        59C68245EB05282B 
    56. 0131D9619DC1376E        5CD54CA83DEF57DA        B1B8CC0B250F09A0 
    57. 07A1133E4A0B2686        0248D43806F67172        1730E5778BEA1DA4 
    58. 3849674C2602319E        51454B582DDF440A        A25E7856CF2651EB 
    59. 04B915BA43FEB5B6        42FD443059577FA2        353882B109CE8F1A 
    60. 0113B970FD34F2CE        059B5E0851CF143A        48F4D0884C379918 
    61. 0170F175468FB5E6        0756D8E0774761D2        432193B78951FC98 
    62. 43297FAD38E373FE        762514B829BF486A        13F04154D69D1AE5 
    63. 07A7137045DA2A16        3BDD119049372802        2EEDDA93FFD39C79 
    64. 04689104C2FD3B2F        26955F6835AF609A        D887E0393C2DA6E3 
    65. 37D06BB516CB7546        164D5E404F275232        5F99D04F5B163969 
    66. 1F08260D1AC2465E        6B056E18759F5CCA        4A057A3B24D3977B 
    67. 584023641ABA6176        004BD6EF09176062        452031C1E4FADA8E 
    68. 025816164629B007        480D39006EE762F2        7555AE39F59B87BD 
    69. 49793EBC79B3258F        437540C8698F3CFA        53C55F9CB49FC019 
    70. 4FB05E1515AB73A7        072D43A077075292        7A8E7BFA937E89A3 
    71. 49E95D6D4CA229BF        02FE55778117F12A        CF9C5D7A4986ADB5 
    72. 018310DC409B26D6        1D9D5C5018F728C2        D1ABB290658BC778 
    73. 1C587F1C13924FEF        305532286D6F295A        55CB3774D13EF201 
    74. 0101010101010101        0123456789ABCDEF        FA34EC4847B268B2 
    75. 1F1F1F1F0E0E0E0E        0123456789ABCDEF        A790795108EA3CAE 
    76. E0FEE0FEF1FEF1FE        0123456789ABCDEF        C39E072D9FAC631D 
    77. 0000000000000000        FFFFFFFFFFFFFFFF        014933E0CDAFF6E4 
    78. FFFFFFFFFFFFFFFF        0000000000000000        F21E9A77B71C49BC 
    79. 0123456789ABCDEF        0000000000000000        245946885754369A 
    80. FEDCBA9876543210        FFFFFFFFFFFFFFFF        6B5C5A9C5D9E0A5A 
    81.  
    82. set_key test data 
    83. data[8]= FEDCBA9876543210 
    84. c=F9AD597C49DB005E k[ 1]=F0 
    85. c=E91D21C1D961A6D6 k[ 2]=F0E1 
    86. c=E9C2B70A1BC65CF3 k[ 3]=F0E1D2 
    87. c=BE1E639408640F05 k[ 4]=F0E1D2C3 
    88. c=B39E44481BDB1E6E k[ 5]=F0E1D2C3B4 
    89. c=9457AA83B1928C0D k[ 6]=F0E1D2C3B4A5 
    90. c=8BB77032F960629D k[ 7]=F0E1D2C3B4A596 
    91. c=E87A244E2CC85E82 k[ 8]=F0E1D2C3B4A59687 
    92. c=15750E7A4F4EC577 k[ 9]=F0E1D2C3B4A5968778 
    93. c=122BA70B3AB64AE0 k[10]=F0E1D2C3B4A596877869 
    94. c=3A833C9AFFC537F6 k[11]=F0E1D2C3B4A5968778695A 
    95. c=9409DA87A90F6BF2 k[12]=F0E1D2C3B4A5968778695A4B 
    96. c=884F80625060B8B4 k[13]=F0E1D2C3B4A5968778695A4B3C 
    97. c=1F85031C19E11968 k[14]=F0E1D2C3B4A5968778695A4B3C2D 
    98. c=79D9373A714CA34F k[15]=F0E1D2C3B4A5968778695A4B3C2D1E ??? 
    99. c=93142887EE3BE15C k[16]=F0E1D2C3B4A5968778695A4B3C2D1E0F 
    100. c=03429E838CE2D14B k[17]=F0E1D2C3B4A5968778695A4B3C2D1E0F00 
    101. c=A4299E27469FF67B k[18]=F0E1D2C3B4A5968778695A4B3C2D1E0F0011 
    102. c=AFD5AED1C1BC96A8 k[19]=F0E1D2C3B4A5968778695A4B3C2D1E0F001122 
    103. c=10851C0E3858DA9F k[20]=F0E1D2C3B4A5968778695A4B3C2D1E0F00112233 
    104. c=E6F51ED79B9DB21F k[21]=F0E1D2C3B4A5968778695A4B3C2D1E0F0011223344 
    105. c=64A6E14AFD36B46F k[22]=F0E1D2C3B4A5968778695A4B3C2D1E0F001122334455 
    106. c=80C7D7D45A5479AD k[23]=F0E1D2C3B4A5968778695A4B3C2D1E0F00112233445566 
    107. c=05044B62FA52D080 k[24]=F0E1D2C3B4A5968778695A4B3C2D1E0F0011223344556677 
    108.  
    109. chaining mode test data 
    110. key[16]   = 0123456789ABCDEFF0E1D2C3B4A59687 
    111. iv[8]     = FEDCBA9876543210 
    112. data[29]  = "7654321 Now is the time for " (includes trailing '') 
    113. data[29]  = 37363534333231204E6F77206973207468652074696D6520666F722000 
    114. cbc cipher text 
    115. cipher[32]= 6B77B4D63006DEE605B156E27403979358DEB9E7154616D959F1652BD5FF92CC 
    116. cfb64 cipher text cipher[29]=  
    117. E73214A2822139CAF26ECF6D2EB9E76E3DA3DE04D1517200519D57A6C3  
    118. ofb64 cipher text cipher[29]=  
    119. E73214A2822139CA62B343CC5B65587310DD908D0C241B2263C2CF80DA 
    120.  
    121. */  
    122.   
    123. #ifndef __BLOWFISH_H__  
    124. #define __BLOWFISH_H__  
    125.   
    126. //Block Structure  
    127. struct SBlock  
    128. {  
    129.     //Constructors  
    130.     SBlock(unsigned int l=0, unsigned int r=0) : m_uil(l), m_uir(r) {}  
    131.     //Copy Constructor  
    132.     SBlock(const SBlock& roBlock) : m_uil(roBlock.m_uil), m_uir(roBlock.m_uir) {}  
    133.     SBlock& operator^=(SBlock& b) { m_uil ^= b.m_uil; m_uir ^= b.m_uir; return *this; }  
    134.     unsigned int m_uil, m_uir;  
    135. };  
    136.   
    137. class CBlowFish  
    138. {  
    139. public:  
    140.     enum { ECB=0, CBC=1, CFB=2 };  
    141.   
    142.     //Constructor - Initialize the P and S boxes for a given Key  
    143.     CBlowFish(unsigned char* ucKey, size_t n, const SBlock& roChain = SBlock(0UL,0UL));  
    144.   
    145.     //Resetting the chaining block  
    146.     void ResetChain() { m_oChain = m_oChain0; }  
    147.   
    148.     // Encrypt/Decrypt Buffer in Place  
    149.     void Encrypt(unsigned char* buf, size_t n, int iMode=ECB);  
    150.     void Decrypt(unsigned char* buf, size_t n, int iMode=ECB);  
    151.   
    152.     // Encrypt/Decrypt from Input Buffer to Output Buffer  
    153.     void Encrypt(const unsigned char* in, unsigned char* out, size_t n, int iMode=ECB);  
    154.     void Decrypt(const unsigned char* in, unsigned char* out, size_t n, int iMode=ECB);  
    155.   
    156. //Private Functions  
    157. private:  
    158.     unsigned int F(unsigned int ui);  
    159.     void Encrypt(SBlock&);  
    160.     void Decrypt(SBlock&);  
    161.   
    162. private:  
    163.     //The Initialization Vector, by default {0, 0}  
    164.     SBlock m_oChain0;  
    165.     SBlock m_oChain;  
    166.     unsigned int m_auiP[18];  
    167.     unsigned int m_auiS[4][256];  
    168.     static const unsigned int scm_auiInitP[18];  
    169.     static const unsigned int scm_auiInitS[4][256];  
    170. };  
    171.   
    172. //Extract low order byte  
    173. inline unsigned char Byte(unsigned int ui)  
    174. {  
    175.     return (unsigned char)(ui & 0xff);  
    176. }  
    177.   
    178. //Function F  
    179. inline unsigned int CBlowFish::F(unsigned int ui)  
    180. {  
    181.     return ((m_auiS[0][Byte(ui>>24)] + m_auiS[1][Byte(ui>>16)]) ^ m_auiS[2][Byte(ui>>8)]) + m_auiS[3][Byte(ui)];  
    182. }  
    183.   
    184. #endif // __BLOWFISH_H__  


    [cpp] view plaincopy
    1. ////////////////////////////////////////////////////////////////////////////  
    2. ///  
    3. // BlowFish.cpp  
    4. //  
    5. //    Implementation of Bruce Schneier's BLOWFISH algorithm from "Applied   
    6. //    Cryptography", Second Edition.  
    7.   
    8. #include <cstring>  
    9. #include <exception>  
    10. #include "Blowfish.h"  
    11.   
    12. //Initialization with a fixed string which consists of the hexadecimal digits of PI (less the initial 3)  
    13. //P-array, 18 32-bit subkeys  
    14. const unsigned int CBlowFish::scm_auiInitP[18] = {  
    15.     0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,  
    16.     0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,  
    17.     0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,  
    18.     0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,  
    19.     0x9216d5d9, 0x8979fb1b  
    20. };  
    21.   
    22. //Four 32-bit S-boxes with 256 entries each  
    23. const unsigned int CBlowFish::scm_auiInitS[4][256] = {  
    24.     //0  
    25.     {0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,  
    26.      0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,  
    27.      0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,  
    28.      0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,  
    29.      0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,  
    30.      0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,  
    31.      0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,  
    32.      0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,  
    33.      0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,  
    34.      0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,  
    35.      0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,  
    36.      0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,  
    37.      0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,  
    38.      0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,  
    39.      0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,  
    40.      0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,  
    41.      0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,  
    42.      0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,  
    43.      0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,  
    44.      0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,  
    45.      0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,  
    46.      0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,  
    47.      0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,  
    48.      0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,  
    49.      0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,  
    50.      0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,  
    51.      0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,  
    52.      0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,  
    53.      0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,  
    54.      0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,  
    55.      0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,  
    56.      0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,  
    57.      0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,  
    58.      0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,  
    59.      0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,  
    60.      0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,  
    61.      0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,  
    62.      0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,  
    63.      0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,  
    64.      0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,  
    65.      0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,  
    66.      0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,  
    67.      0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,  
    68.      0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,  
    69.      0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,  
    70.      0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,  
    71.      0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,  
    72.      0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,  
    73.      0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,  
    74.      0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,  
    75.      0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,  
    76.      0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,  
    77.      0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,  
    78.      0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,  
    79.      0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,  
    80.      0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,  
    81.      0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,  
    82.      0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,  
    83.      0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,  
    84.      0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,  
    85.      0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,  
    86.      0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,  
    87.      0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,  
    88.      0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a},  
    89.   
    90.     //1  
    91.     {0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,  
    92.      0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,  
    93.      0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,  
    94.      0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,  
    95.      0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,  
    96.      0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,  
    97.      0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,  
    98.      0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,  
    99.      0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,  
    100.      0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,  
    101.      0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,  
    102.      0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,  
    103.      0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,  
    104.      0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,  
    105.      0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,  
    106.      0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,  
    107.      0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,  
    108.      0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,  
    109.      0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,  
    110.      0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,  
    111.      0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,  
    112.      0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,  
    113.      0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,  
    114.      0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,  
    115.      0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,  
    116.      0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,  
    117.      0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,  
    118.      0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,  
    119.      0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,  
    120.      0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,  
    121.      0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,  
    122.      0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,  
    123.      0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,  
    124.      0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,  
    125.      0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,  
    126.      0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,  
    127.      0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,  
    128.      0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,  
    129.      0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,  
    130.      0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,  
    131.      0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,  
    132.      0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,  
    133.      0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,  
    134.      0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,  
    135.      0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,  
    136.      0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,  
    137.      0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,  
    138.      0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,  
    139.      0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,  
    140.      0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,  
    141.      0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,  
    142.      0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,  
    143.      0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,  
    144.      0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,  
    145.      0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,  
    146.      0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,  
    147.      0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,  
    148.      0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,  
    149.      0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,  
    150.      0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,  
    151.      0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,  
    152.      0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,  
    153.      0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,  
    154.      0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7},  
    155.   
    156.     //2  
    157.     {0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,  
    158.      0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,  
    159.      0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,  
    160.      0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,  
    161.      0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,  
    162.      0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,  
    163.      0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,  
    164.      0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,  
    165.      0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,  
    166.      0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,  
    167.      0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,  
    168.      0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,  
    169.      0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,  
    170.      0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,  
    171.      0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,  
    172.      0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,  
    173.      0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,  
    174.      0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,  
    175.      0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,  
    176.      0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,  
    177.      0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,  
    178.      0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,  
    179.      0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,  
    180.      0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,  
    181.      0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,  
    182.      0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,  
    183.      0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,  
    184.      0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,  
    185.      0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,  
    186.      0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,  
    187.      0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,  
    188.      0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,  
    189.      0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,  
    190.      0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,  
    191.      0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,  
    192.      0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,  
    193.      0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,  
    194.      0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,  
    195.      0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,  
    196.      0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,  
    197.      0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,  
    198.      0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,  
    199.      0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,  
    200.      0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,  
    201.      0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,  
    202.      0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,  
    203.      0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,  
    204.      0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,  
    205.      0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,  
    206.      0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,  
    207.      0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,  
    208.      0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,  
    209.      0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,  
    210.      0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,  
    211.      0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,  
    212.      0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,  
    213.      0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,  
    214.      0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,  
    215.      0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,  
    216.      0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,  
    217.      0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,  
    218.      0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,  
    219.      0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,  
    220.      0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0},  
    221.   
    222.     //3  
    223.     {0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,  
    224.      0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,  
    225.      0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,  
    226.      0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,  
    227.      0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,  
    228.      0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,  
    229.      0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,  
    230.      0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,  
    231.      0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,  
    232.      0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,  
    233.      0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,  
    234.      0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,  
    235.      0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,  
    236.      0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,  
    237.      0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,  
    238.      0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,  
    239.      0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,  
    240.      0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,  
    241.      0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,  
    242.      0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,  
    243.      0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,  
    244.      0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,  
    245.      0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,  
    246.      0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,  
    247.      0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,  
    248.      0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,  
    249.      0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,  
    250.      0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,  
    251.      0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,  
    252.      0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,  
    253.      0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,  
    254.      0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,  
    255.      0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,  
    256.      0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,  
    257.      0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,  
    258.      0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,  
    259.      0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,  
    260.      0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,  
    261.      0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,  
    262.      0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,  
    263.      0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,  
    264.      0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,  
    265.      0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,  
    266.      0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,  
    267.      0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,  
    268.      0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,  
    269.      0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,  
    270.      0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,  
    271.      0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,  
    272.      0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,  
    273.      0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,  
    274.      0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,  
    275.      0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,  
    276.      0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,  
    277.      0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,  
    278.      0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,  
    279.      0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,  
    280.      0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,  
    281.      0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,  
    282.      0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,  
    283.      0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,  
    284.      0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,  
    285.      0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,  
    286.      0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6}  
    287. };  
    288.   
    289. //Constructor - Initialize the P and S boxes for a given Key  
    290. CBlowFish::CBlowFish(unsigned char* ucKey, size_t keysize, const SBlock& roChain) : m_oChain0(roChain), m_oChain(roChain)  
    291. {  
    292.     if(keysize<1)  
    293.         throw exception("Incorrect key length");  
    294.     //Check the Key - the key length should be between 1 and 56 bytes  
    295.     if(keysize>56)  
    296.         keysize = 56;  
    297.     unsigned char aucLocalKey[56];  
    298.     unsigned int i, j;  
    299.     memcpy(aucLocalKey, ucKey, keysize);  
    300.     //Reflexive Initialization of the Blowfish.  
    301.     //Generating the Subkeys from the Key flood P and S boxes with PI  
    302.     memcpy(m_auiP, scm_auiInitP, sizeof m_auiP);  
    303.     memcpy(m_auiS, scm_auiInitS, sizeof m_auiS);  
    304.     //Load P boxes with key bytes  
    305.     const unsigned char* p = aucLocalKey;  
    306.     unsigned int x=0;  
    307.     //Repeatedly cycle through the key bits until the entire P array has been XORed with key bits  
    308.     int iCount = 0;  
    309.     for(i=0; i<18; i++)  
    310.     {  
    311.         x=0;  
    312.         for(int n=4; n--; )  
    313.         {  
    314.             int iVal = (int)(*p);  
    315.             x <<= 8;  
    316.             x |= *(p++);  
    317.             iCount++;  
    318.             if(iCount == keysize)  
    319.             {  
    320.                 //All bytes used, so recycle bytes   
    321.                 iCount = 0;  
    322.                 p = aucLocalKey;  
    323.             }  
    324.         }  
    325.         m_auiP[i] ^= x;  
    326.     }  
    327.     //Reflect P and S boxes through the evolving Blowfish  
    328.     SBlock block(0UL,0UL); //all-zero block  
    329.     for(i=0; i<18; )  
    330.         Encrypt(block), m_auiP[i++] = block.m_uil, m_auiP[i++] = block.m_uir;  
    331.     for(j=0; j<4; j++)  
    332.         for(int k=0; k<256; )  
    333.             Encrypt(block), m_auiS[j][k++] = block.m_uil, m_auiS[j][k++] = block.m_uir;  
    334. }  
    335.   
    336. //Sixteen Round Encipher of Block  
    337. void CBlowFish::Encrypt(SBlock& block)  
    338. {  
    339.     unsigned int uiLeft = block.m_uil;  
    340.     unsigned int uiRight = block.m_uir;  
    341.     uiLeft ^= m_auiP[0];  
    342.     uiRight ^= F(uiLeft)^m_auiP[1]; uiLeft ^= F(uiRight)^m_auiP[2];  
    343.     uiRight ^= F(uiLeft)^m_auiP[3]; uiLeft ^= F(uiRight)^m_auiP[4];  
    344.     uiRight ^= F(uiLeft)^m_auiP[5]; uiLeft ^= F(uiRight)^m_auiP[6];  
    345.     uiRight ^= F(uiLeft)^m_auiP[7]; uiLeft ^= F(uiRight)^m_auiP[8];  
    346.     uiRight ^= F(uiLeft)^m_auiP[9]; uiLeft ^= F(uiRight)^m_auiP[10];  
    347.     uiRight ^= F(uiLeft)^m_auiP[11]; uiLeft ^= F(uiRight)^m_auiP[12];  
    348.     uiRight ^= F(uiLeft)^m_auiP[13]; uiLeft ^= F(uiRight)^m_auiP[14];  
    349.     uiRight ^= F(uiLeft)^m_auiP[15]; uiLeft ^= F(uiRight)^m_auiP[16];  
    350.     uiRight ^= m_auiP[17];  
    351.     block.m_uil = uiRight;  
    352.     block.m_uir = uiLeft;  
    353. }  
    354.   
    355. //Sixteen Round Decipher of SBlock  
    356. void CBlowFish::Decrypt(SBlock& block)  
    357. {  
    358.     unsigned int uiLeft = block.m_uil;  
    359.     unsigned int uiRight = block.m_uir;  
    360.     uiLeft ^= m_auiP[17];  
    361.     uiRight ^= F(uiLeft)^m_auiP[16]; uiLeft ^= F(uiRight)^m_auiP[15];  
    362.     uiRight ^= F(uiLeft)^m_auiP[14]; uiLeft ^= F(uiRight)^m_auiP[13];  
    363.     uiRight ^= F(uiLeft)^m_auiP[12]; uiLeft ^= F(uiRight)^m_auiP[11];  
    364.     uiRight ^= F(uiLeft)^m_auiP[10]; uiLeft ^= F(uiRight)^m_auiP[9];  
    365.     uiRight ^= F(uiLeft)^m_auiP[8]; uiLeft ^= F(uiRight)^m_auiP[7];  
    366.     uiRight ^= F(uiLeft)^m_auiP[6]; uiLeft ^= F(uiRight)^m_auiP[5];  
    367.     uiRight ^= F(uiLeft)^m_auiP[4]; uiLeft ^= F(uiRight)^m_auiP[3];  
    368.     uiRight ^= F(uiLeft)^m_auiP[2]; uiLeft ^= F(uiRight)^m_auiP[1];  
    369.     uiRight ^= m_auiP[0];  
    370.     block.m_uil = uiRight;  
    371.     block.m_uir = uiLeft;  
    372. }  
    373.   
    374. //Semi-Portable Byte Shuffling  
    375. inline void BytesToBlock(unsigned char const* p, SBlock& b)  
    376. {  
    377.     unsigned int y;  
    378.     //Left  
    379.     b.m_uil = 0;  
    380.     y = *p++;  
    381.     y <<= 24;  
    382.     b.m_uil |= y;  
    383.     y = *p++;  
    384.     y <<= 16;  
    385.     b.m_uil |= y;  
    386.     y = *p++;  
    387.     y <<= 8;  
    388.     b.m_uil |= y;  
    389.     y = *p++;  
    390.     b.m_uil |= y;  
    391.     //Right  
    392.     b.m_uir = 0;  
    393.     y = *p++;  
    394.     y <<= 24;  
    395.     b.m_uir |= y;  
    396.     y = *p++;  
    397.     y <<= 16;  
    398.     b.m_uir |= y;  
    399.     y = *p++;  
    400.     y <<= 8;  
    401.     b.m_uir |= y;  
    402.     y = *p++;  
    403.     b.m_uir |= y;  
    404. }  
    405.   
    406. inline void BlockToBytes(SBlock const& b, unsigned char* p)  
    407. {  
    408.     unsigned int y;  
    409.     //Right  
    410.     y = b.m_uir;  
    411.     *--p = Byte(y);  
    412.     y = b.m_uir >> 8;  
    413.     *--p = Byte(y);  
    414.     y = b.m_uir >> 16;  
    415.     *--p = Byte(y);  
    416.     y = b.m_uir >> 24;  
    417.     *--p = Byte(y);  
    418.     //Left  
    419.     y = b.m_uil;  
    420.     *--p = Byte(y);  
    421.     y = b.m_uil >> 8;  
    422.     *--p = Byte(y);  
    423.     y = b.m_uil >> 16;  
    424.     *--p = Byte(y);  
    425.     y = b.m_uil >> 24;  
    426.     *--p = Byte(y);  
    427. }  
    428.   
    429. //Encrypt Buffer in Place  
    430. //Returns false if n is multiple of 8  
    431. void CBlowFish::Encrypt(unsigned char* buf, size_t n, int iMode)  
    432. {  
    433.     //Check the buffer's length - should be > 0 and multiple of 8  
    434.     if((n==0)||(n%8!=0))  
    435.         throw exception("Incorrect buffer length");  
    436.     SBlock work;  
    437.     if(iMode == CBC) //CBC mode, using the Chain  
    438.     {  
    439.         SBlock chain(m_oChain);  
    440.         for(; n >= 8; n -= 8)  
    441.         {  
    442.             BytesToBlock(buf, work);  
    443.             work ^= chain;  
    444.             Encrypt(work);  
    445.             chain = work;  
    446.             BlockToBytes(work, buf+=8);  
    447.         }  
    448.     }  
    449.     else if(iMode == CFB) //CFB mode, using the Chain  
    450.     {  
    451.         SBlock chain(m_oChain);  
    452.         for(; n >= 8; n -= 8)  
    453.         {  
    454.             Encrypt(chain);  
    455.             BytesToBlock(buf, work);  
    456.             work ^= chain;  
    457.             chain = work;  
    458.             BlockToBytes(work, buf+=8);  
    459.         }  
    460.     }  
    461.     else //ECB mode, not using the Chain  
    462.     {  
    463.         for(; n >= 8; n -= 8)  
    464.         {  
    465.             BytesToBlock(buf, work);  
    466.             Encrypt(work);  
    467.             BlockToBytes(work, buf+=8);  
    468.         }  
    469.     }  
    470. }  
    471.   
    472. //Decrypt Buffer in Place  
    473. //Returns false if n is multiple of 8  
    474. void CBlowFish::Decrypt(unsigned char* buf, size_t n, int iMode)  
    475. {  
    476.     //Check the buffer's length - should be > 0 and multiple of 8  
    477.     if((n==0)||(n%8!=0))  
    478.         throw exception("Incorrect buffer length");  
    479.     SBlock work;  
    480.     if(iMode == CBC) //CBC mode, using the Chain  
    481.     {  
    482.         SBlock crypt, chain(m_oChain);  
    483.         for(; n >= 8; n -= 8)  
    484.         {  
    485.             BytesToBlock(buf, work);  
    486.             crypt = work;  
    487.             Decrypt(work);  
    488.             work ^= chain;  
    489.             chain = crypt;  
    490.             BlockToBytes(work, buf+=8);  
    491.         }  
    492.     }  
    493.     else if(iMode == CFB) //CFB mode, using the Chain, not using Decrypt()  
    494.     {  
    495.         SBlock crypt, chain(m_oChain);  
    496.         for(; n >= 8; n -= 8)  
    497.         {  
    498.             BytesToBlock(buf, work);  
    499.             Encrypt(chain);  
    500.             crypt = work;  
    501.             work ^= chain;  
    502.             chain = crypt;  
    503.             BlockToBytes(work, buf+=8);  
    504.         }  
    505.     }  
    506.     else //ECB mode, not using the Chain  
    507.     {  
    508.         for(; n >= 8; n -= 8)  
    509.         {  
    510.             BytesToBlock(buf, work);  
    511.             Decrypt(work);  
    512.             BlockToBytes(work, buf+=8);  
    513.         }  
    514.     }  
    515. }  
    516.   
    517. //Encrypt from Input Buffer to Output Buffer  
    518. //Returns false if n is multiple of 8  
    519. void CBlowFish::Encrypt(const unsigned char* in, unsigned char* out, size_t n, int iMode)  
    520. {  
    521.     //Check the buffer's length - should be > 0 and multiple of 8  
    522.     if((n==0)||(n%8!=0))  
    523.         throw exception("Incorrect buffer length");  
    524.     SBlock work;  
    525.     if(iMode == CBC) //CBC mode, using the Chain  
    526.     {  
    527.         SBlock chain(m_oChain);  
    528.         for(; n >= 8; n -= 8, in += 8)  
    529.         {  
    530.             BytesToBlock(in, work);  
    531.             work ^= chain;  
    532.             Encrypt(work);  
    533.             chain = work;  
    534.             BlockToBytes(work, out+=8);  
    535.         }  
    536.     }  
    537.     else if(iMode == CFB) //CFB mode, using the Chain  
    538.     {  
    539.         SBlock chain(m_oChain);  
    540.         for(; n >= 8; n -= 8, in += 8)  
    541.         {  
    542.             Encrypt(chain);  
    543.             BytesToBlock(in, work);  
    544.             work ^= chain;  
    545.             chain = work;  
    546.             BlockToBytes(work, out+=8);  
    547.         }  
    548.     }  
    549.     else //ECB mode, not using the Chain  
    550.     {  
    551.         for(; n >= 8; n -= 8, in += 8)  
    552.         {  
    553.             BytesToBlock(in, work);  
    554.             Encrypt(work);  
    555.             BlockToBytes(work, out+=8);  
    556.         }  
    557.     }  
    558. }  
    559.   
    560. //Decrypt from Input Buffer to Output Buffer  
    561. //Returns false if n is multiple of 8  
    562. void CBlowFish::Decrypt(const unsigned char* in, unsigned char* out, size_t n, int iMode)  
    563. {  
    564.     //Check the buffer's length - should be > 0 and multiple of 8  
    565.     if((n==0)||(n%8!=0))  
    566.         throw exception("Incorrect buffer length");  
    567.     SBlock work;  
    568.     if(iMode == CBC) //CBC mode, using the Chain  
    569.     {  
    570.         SBlock crypt, chain(m_oChain);  
    571.         for(; n >= 8; n -= 8, in += 8)  
    572.         {  
    573.             BytesToBlock(in, work);  
    574.             crypt = work;  
    575.             Decrypt(work);  
    576.             work ^= chain;  
    577.             chain = crypt;  
    578.             BlockToBytes(work, out+=8);  
    579.         }  
    580.     }  
    581.     else if(iMode == CFB) //CFB mode, using the Chain, not using Decrypt()  
    582.     {  
    583.         SBlock crypt, chain(m_oChain);  
    584.         for(; n >= 8; n -= 8, in += 8)  
    585.         {  
    586.             BytesToBlock(in, work);  
    587.             Encrypt(chain);  
    588.             crypt = work;  
    589.             work ^= chain;  
    590.             chain = crypt;  
    591.             BlockToBytes(work, out+=8);  
    592.         }  
    593.     }  
    594.     else //ECB mode, not using the Chain  
    595.     {  
    596.         for(; n >= 8; n -= 8, in += 8)  
    597.         {  
    598.             BytesToBlock(in, work);  
    599.             Decrypt(work);  
    600.             BlockToBytes(work, out+=8);  
    601.         }  
    602.     }  
    603. }  


    [cpp] view plaincopy
    1. 使用实例  
    2. try  
    3. {  
    4.   CBlowFish oBlowFish((unsigned char*)"1234567890123456", 16);  
    5.   char szDataIn1[49] = "ababababccccccccababababccccccccababababcccccccc";  
    6.   char szDataIn[49];  
    7.   char szDataOut[49];  
    8.   memset(szDataIn, 0, 49);  
    9.   memset(szDataOut, 0, 49);  
    10.   
    11.   //Test ECB  
    12.   strcpy(szDataIn, szDataIn1);  
    13.   memset(szDataOut, 0, 49);  
    14.   oBlowFish.Encrypt((unsigned char*)szDataIn,   
    15.                     (unsigned char*)szDataOut, 48, CBlowFish::ECB);  
    16.   memset(szDataIn, 0, 49);  
    17.   oBlowFish.Decrypt((unsigned char*)szDataOut,   
    18.                     (unsigned char*)szDataIn, 48, CBlowFish::ECB);  
    19.   
    20.   //Test CBC  
    21.   oBlowFish.ResetChain();  
    22.   strcpy(szDataIn, szDataIn1);  
    23.   memset(szDataOut, 0, 49);  
    24.   oBlowFish.Encrypt((unsigned char*)szDataIn,   
    25.                     (unsigned char*)szDataOut, 48, CBlowFish::CBC);  
    26.   memset(szDataIn, 0, 49);  
    27.   oBlowFish.ResetChain();  
    28.   oBlowFish.Decrypt((unsigned char*)szDataOut,   
    29.                     (unsigned char*)szDataIn, 48, CBlowFish::CBC);  
    30.   
    31.   //Test CFB  
    32.   oBlowFish.ResetChain();  
    33.   strcpy(szDataIn, szDataIn1);  
    34.   memset(szDataOut, 0, 49);  
    35.   oBlowFish.Encrypt((unsigned char*)szDataIn,   
    36.                     (unsigned char*)szDataOut, 48, CBlowFish::CFB);  
    37.   memset(szDataIn, 0, 49);  
    38.   oBlowFish.ResetChain();  
    39.   oBlowFish.Decrypt((unsigned char*)szDataOut,   
    40.                     (unsigned char*)szDataIn, 48, CBlowFish::CFB);  
    41.   cout << endl;  
    42. }  
    43. catch(exception& roException)  
    44. {  
    45.   cout << "Exception: "   
    46.        << roException.what() << endl;  
    47. }  


    代码下载：http://download.csdn.net/detail/byxdaz/4057820
  • 相关阅读:
    未让换行符弄错了数据
    REPLICATE
    内存 商业智能
    sql
    PageMethods介绍
    在ASP.NET AJAX中如何判断浏览器及计算其宽高
    用JavaScript实现网页图片等比例缩放
    js技巧收集(200多个)(转自:asp.net中文俱乐部)
    C#调用ORACLE存储过程返回结果集及函数
    Using PageMethods to access Session data
  • 原文地址：https://www.cnblogs.com/mtcnn/p/9410070.html
Copyright © 2011-2022 走看看