001    package railo.runtime.crypt;
002    
003    public class BlowfishECB {
004      /** maximum possible key length */
005      public final static int MAXKEYLENGTH = 56;
006      /** block size of this cipher (in bytes) */
007      public final static int BLOCKSIZE = 8;
008      // size of the single boxes
009      final static int PBOX_ENTRIES = 18;
010      final static int SBOX_ENTRIES = 256;
011      // the boxes
012      int[] m_pbox;
013      int[] m_sbox1;
014      int[] m_sbox2;
015      int[] m_sbox3;
016      int[] m_sbox4;
017      /**
018        * default constructor
019        * @param bfkey key material, up to MAXKEYLENGTH bytes
020        */
021      public BlowfishECB(byte[] bfkey) {
022        // create the boxes
023        int nI;
024        m_pbox = new int[PBOX_ENTRIES];
025        for (nI = 0; nI < PBOX_ENTRIES; nI++)
026          m_pbox[nI] = pbox_init[nI];
027        m_sbox1 = new int[SBOX_ENTRIES];
028        m_sbox2 = new int[SBOX_ENTRIES];
029        m_sbox3 = new int[SBOX_ENTRIES];
030        m_sbox4 = new int[SBOX_ENTRIES];
031        for (nI = 0; nI < SBOX_ENTRIES; nI++) {
032          m_sbox1[nI] = sbox_init_1[nI];
033          m_sbox2[nI] = sbox_init_2[nI];
034          m_sbox3[nI] = sbox_init_3[nI];
035          m_sbox4[nI] = sbox_init_4[nI];
036        };
037        // xor the key over the p-boxes
038        int nLen = bfkey.length;
039        if (nLen == 0) return; // such a setup is also valid (zero key "encryption" is possible)
040        int nKeyPos = 0;
041        int nBuild = 0;
042        int nJ;
043        for (nI = 0; nI < PBOX_ENTRIES; nI++) {
044          for (nJ = 0; nJ < 4; nJ++) {
045            nBuild = (nBuild << 8) | (( bfkey[nKeyPos]) & 0x0ff);
046            if (++nKeyPos == nLen) nKeyPos = 0;
047          };
048          m_pbox[nI] ^= nBuild;
049        };
050        // encrypt all boxes with the all zero string
051        long lZero = 0;
052        // (same as above)
053        for (nI = 0; nI < PBOX_ENTRIES; nI += 2) {
054          lZero = encryptBlock(lZero);
055          m_pbox[nI] = (int) (lZero >>> 32);
056          m_pbox[nI+1] = (int) (lZero & 0x0ffffffffL);
057        };
058        for (nI = 0; nI < SBOX_ENTRIES; nI += 2) {
059          lZero = encryptBlock(lZero);
060          m_sbox1[nI] = (int) (lZero >>> 32);
061          m_sbox1[nI+1] = (int) (lZero & 0x0ffffffffL);
062        };
063        for (nI = 0; nI < SBOX_ENTRIES; nI += 2) {
064          lZero = encryptBlock(lZero);
065          m_sbox2[nI] = (int) (lZero >>> 32);
066          m_sbox2[nI+1] = (int) (lZero & 0x0ffffffffL);
067        };
068        for (nI = 0; nI < SBOX_ENTRIES; nI += 2) {
069          lZero = encryptBlock(lZero);
070          m_sbox3[nI] = (int) (lZero >>> 32);
071          m_sbox3[nI+1] = (int) (lZero & 0x0ffffffffL);
072        };
073        for (nI = 0; nI < SBOX_ENTRIES; nI += 2) {
074          lZero = encryptBlock(lZero);
075          m_sbox4[nI] = (int) (lZero >>> 32);
076          m_sbox4[nI+1] = (int) (lZero & 0x0ffffffffL);
077        };
078      };
079      /**
080        * to clear data in the boxes before an instance is freed
081        */
082      public void cleanUp() {
083        int nI;
084        for (nI = 0; nI < PBOX_ENTRIES; nI++)
085          m_pbox[nI] = 0;
086        for (nI = 0; nI < SBOX_ENTRIES; nI++)
087          m_sbox1[nI] = m_sbox2[nI] = m_sbox3[nI] = m_sbox4[nI] = 0;
088      };
089      /**
090        * selftest routine, to check e.g. for a valid class file transmission
091        * @return true: selftest passed / false: selftest failed
092        */
093      public static boolean selfTest() {
094        // test vector #1 (checking for the "signed bug")
095    
096        byte[] testKey1 = { (byte) 0x1c, (byte) 0x58, (byte) 0x7f, (byte) 0x1c,
097    
098                            (byte) 0x13, (byte) 0x92, (byte) 0x4f, (byte) 0xef };
099    
100        int[] tv_p1 = { 0x30553228, 0x6d6f295a };
101    
102        int[] tv_c1 = { 0x55cb3774, 0xd13ef201 };
103    
104        int[] tv_t1 = new int[2];
105    
106    
107    
108        // test vector #2 (offical vector by Bruce Schneier)
109    
110        String sTestKey2 = "Who is John Galt?";
111    
112        byte[] testKey2 = sTestKey2.getBytes();
113    
114    
115    
116        int[] tv_p2 = { 0xfedcba98, 0x76543210 };
117    
118        int[] tv_c2 = { 0xcc91732b, 0x8022f684 };
119    
120        int[] tv_t2 = new int[2];
121    
122    
123    
124    
125    
126        // start the tests, check for a proper decryption, too
127    
128    
129    
130        BlowfishECB testbf1 = new BlowfishECB(testKey1);
131    
132        testbf1.encrypt(tv_p1, tv_t1);
133    
134        if ((tv_t1[0] != tv_c1[0]) || (tv_t1[1] != tv_c1[1]))
135    
136          return false;
137    
138        testbf1.decrypt(tv_t1);
139    
140        if ((tv_t1[0] != tv_p1[0]) || (tv_t1[1] != tv_p1[1]))
141    
142          return false;
143    
144    
145    
146        BlowfishECB testbf2 = new BlowfishECB(testKey2);
147    
148        testbf2.encrypt(tv_p2, tv_t2);
149    
150        if ((tv_t2[0] != tv_c2[0]) || (tv_t2[1] != tv_c2[1]))
151    
152          return false;
153    
154        testbf2.decrypt(tv_t2);
155    
156        if ((tv_t2[0] != tv_p2[0]) || (tv_t2[1] != tv_p2[1]))
157    
158          return false;
159    
160    
161    
162        // all tests passed
163    
164        return true;
165    
166      };
167    
168    
169    
170    
171    
172    
173    
174    
175    
176      // internal routine to encrypt a 64bit block
177    
178      protected long encryptBlock(long lPlainBlock) {
179    
180    
181    
182        // split the block in two 32 bit halves
183    
184        int nLeft = BinConverter.longHi32(lPlainBlock);
185    
186        int nRight = BinConverter.longLo32(lPlainBlock);
187    
188    
189    
190        // encrypt the block, gain more speed by unrooling the loop
191    
192        // (we avoid swapping by using nLeft and nRight alternating
193    
194        //  at odd an even loop nubers)
195    
196    
197    
198        // unrolled loop #1 (odd)
199    
200        nLeft ^= m_pbox[0];
201    
202        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
203    
204        // unrolled loop #2 (even)
205    
206        nRight ^= m_pbox[1];
207    
208        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
209    
210        // unrolled loop #3 (odd)
211    
212        nLeft ^= m_pbox[2];
213    
214        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
215    
216        // unrolled loop #4 (even)
217    
218        nRight ^= m_pbox[3];
219    
220        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
221    
222        // unrolled loop #5 (odd)
223    
224        nLeft ^= m_pbox[4];
225    
226        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
227    
228        // unrolled loop #6 (even)
229    
230        nRight ^= m_pbox[5];
231    
232        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
233    
234        // unrolled loop #7 (odd)
235    
236        nLeft ^= m_pbox[6];
237    
238        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
239    
240        // unrolled loop #8 (even)
241    
242        nRight ^= m_pbox[7];
243    
244        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
245    
246        // unrolled loop #9 (odd)
247    
248        nLeft ^= m_pbox[8];
249    
250        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
251    
252        // unrolled loop #10 (even)
253    
254        nRight ^= m_pbox[9];
255    
256        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
257    
258        // unrolled loop #11 (odd)
259    
260        nLeft ^= m_pbox[10];
261    
262        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
263    
264        // unrolled loop #12 (even)
265    
266        nRight ^= m_pbox[11];
267    
268        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
269    
270        // unrolled loop #13 (odd)
271    
272        nLeft ^= m_pbox[12];
273    
274        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
275    
276        // unrolled loop #14 (even)
277    
278        nRight ^= m_pbox[13];
279    
280        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
281    
282        // unrolled loop #15 (odd)
283    
284        nLeft ^= m_pbox[14];
285    
286        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
287    
288        // unrolled loop #16 (even)
289    
290        nRight ^= m_pbox[15];
291    
292        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
293    
294    
295    
296        // swap and finalize
297    
298        int nSwap = nRight;
299    
300        nRight = nLeft ^ m_pbox[16];
301    
302        nLeft = nSwap ^ m_pbox[17];
303    
304    
305    
306        // reassemble and return the block
307    
308        return BinConverter.makeLong(nRight, nLeft);
309    
310    
311    
312      }
313    
314    
315    
316    
317    
318    
319    
320      // internal routine to decrypt a 64bit block
321    
322      protected long decryptBlock(long lCipherBlock) {
323    
324    
325    
326        // split the block in two 32 bit halves
327    
328        int nLeft = BinConverter.longHi32(lCipherBlock);
329    
330        int nRight = BinConverter.longLo32(lCipherBlock);
331    
332    
333    
334        // decrypt the block, gain more speed by unrooling the loop
335    
336        // (we avoid swaping by using nLeft and nRight alternating
337    
338        //  at odd an even loop nubers)
339    
340    
341    
342        // unrolled loop #1 (odd)
343    
344        nLeft ^= m_pbox[17];
345    
346        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
347    
348        // unrolled loop #2 (even)
349    
350        nRight ^= m_pbox[16];
351    
352        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
353    
354        // unrolled loop #3 (odd)
355    
356        nLeft ^= m_pbox[15];
357    
358        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
359    
360        // unrolled loop #4 (even)
361    
362        nRight ^= m_pbox[14];
363    
364        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
365    
366        // unrolled loop #5 (odd)
367    
368        nLeft ^= m_pbox[13];
369    
370        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
371    
372        // unrolled loop #6 (even)
373    
374        nRight ^= m_pbox[12];
375    
376        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
377    
378        // unrolled loop #7 (odd)
379    
380        nLeft ^= m_pbox[11];
381    
382        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
383    
384        // unrolled loop #8 (even)
385    
386        nRight ^= m_pbox[10];
387    
388        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
389    
390        // unrolled loop #9 (odd)
391    
392        nLeft ^= m_pbox[9];
393    
394        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
395    
396        // unrolled loop #10 (even)
397    
398        nRight ^= m_pbox[8];
399    
400        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
401    
402        // unrolled loop #11 (odd)
403    
404        nLeft ^= m_pbox[7];
405    
406        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
407    
408        // unrolled loop #12 (even)
409    
410        nRight ^= m_pbox[6];
411    
412        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
413    
414        // unrolled loop #13 (odd)
415    
416        nLeft ^= m_pbox[5];
417    
418        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
419    
420        // unrolled loop #14 (even)
421    
422        nRight ^= m_pbox[4];
423    
424        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
425    
426        // unrolled loop #15 (odd)
427    
428        nLeft ^= m_pbox[3];
429    
430        nRight ^= ((m_sbox1[nLeft >>> 24] + m_sbox2[(nLeft >>> 16) & 0x0ff]) ^ m_sbox3[(nLeft >>> 8) & 0x0ff]) + m_sbox4[nLeft & 0x0ff];
431    
432        // unrolled loop #16 (even)
433    
434        nRight ^= m_pbox[2];
435    
436        nLeft ^= ((m_sbox1[nRight >>> 24] + m_sbox2[(nRight >>> 16) & 0x0ff]) ^ m_sbox3[(nRight >>> 8) & 0x0ff]) + m_sbox4[nRight & 0x0ff];
437    
438    
439    
440        // swap and finalize
441    
442        int nSwap = nRight;
443    
444        nRight = nLeft ^ m_pbox[1];
445    
446        nLeft  = nSwap ^ m_pbox[0];
447    
448    
449    
450        // reassemble and return the block
451    
452        return BinConverter.makeLong(nRight, nLeft);
453    
454      }
455    
456    
457    
458    
459    
460    
461    
462    
463    
464    
465    
466    
467    
468      /**
469    
470        * encrypts a byte buffer (should be aligned to an 8 byte border)
471    
472        * to another buffer (of the same size or bigger)
473    
474        * @param inbuffer buffer with plaintext data
475    
476        * @param outbuffer buffer to get the ciphertext data
477    
478        */
479    
480      public void encrypt(byte[] inbuffer,
481    
482                          byte[] outbuffer) {
483    
484    
485    
486        int nLen = inbuffer.length;
487    
488        long lTemp;
489    
490        for (int nI = 0; nI < nLen; nI +=8) {
491    
492    
493    
494          // encrypt a temporary 64bit block
495    
496          lTemp = BinConverter.byteArrayToLong(inbuffer, nI);
497    
498          lTemp = encryptBlock(lTemp);
499    
500          BinConverter.longToByteArray(lTemp, outbuffer, nI);
501    
502        };
503    
504      };
505    
506    
507    
508    
509    
510    
511    
512      /**
513    
514        * encrypts a byte buffer (should be aligned to an 8 byte border) to itself
515    
516        * @param buffer buffer to encrypt
517    
518        */
519    
520      public void encrypt(byte[] buffer) {
521    
522    
523    
524        int nLen = buffer.length;
525    
526        long lTemp;
527    
528        for (int nI = 0; nI < nLen; nI +=8) {
529    
530    
531    
532          // encrypt a temporary 64bit block
533    
534          lTemp = BinConverter.byteArrayToLong(buffer, nI);
535    
536          lTemp = encryptBlock(lTemp);
537    
538          BinConverter.longToByteArray(lTemp, buffer, nI);
539    
540        };
541    
542      };
543    
544    
545    
546    
547    
548    
549    
550    
551    
552      /**
553    
554        * encrypts an integer buffer (should be aligned to an
555    
556        * two integer border) to another int buffer (of the
557    
558        * same size or bigger)
559    
560        * @param inbuffer buffer with plaintext data
561    
562        * @param outBuffer buffer to get the ciphertext data
563    
564        */
565    
566      public void encrypt(int[] inbuffer,
567    
568                          int[] outbuffer) {
569    
570    
571    
572        int nLen = inbuffer.length;
573    
574        long lTemp;
575    
576        for (int nI = 0; nI < nLen; nI +=2) {
577    
578    
579    
580          // encrypt a temporary 64bit block
581    
582          lTemp = BinConverter.intArrayToLong(inbuffer, nI);
583    
584          lTemp = encryptBlock(lTemp);
585    
586          BinConverter.longToIntArray(lTemp, outbuffer, nI);
587    
588        };
589    
590      };
591    
592    
593    
594    
595    
596      /**
597    
598        * encrypts an int buffer (should be aligned to a
599    
600        * two integer border)
601    
602        * @param buffer buffer to encrypt
603    
604        */
605    
606      public void encrypt(int[] buffer) {
607    
608    
609    
610        int nLen = buffer.length;
611    
612        long lTemp;
613    
614        for (int nI = 0; nI < nLen; nI +=2) {
615    
616    
617    
618          // encrypt a temporary 64bit block
619    
620          lTemp = BinConverter.intArrayToLong(buffer, nI);
621    
622          lTemp = encryptBlock(lTemp);
623    
624          BinConverter.longToIntArray(lTemp, buffer, nI);
625    
626        };
627    
628      };
629    
630    
631    
632    
633    
634    
635    
636      /**
637    
638        * encrypts a long buffer to another long buffer (of the same size or bigger)
639    
640        * @param inbuffer buffer with plaintext data
641    
642        * @param outbuffer buffer to get the ciphertext data
643    
644        */
645    
646      public void encrypt(long[] inbuffer,
647    
648                          long[] outbuffer) {
649    
650    
651    
652        int nLen = inbuffer.length;
653    
654        for (int nI = 0; nI < nLen; nI++)
655    
656          outbuffer[nI] = encryptBlock(inbuffer[nI]);
657    
658      };
659    
660    
661    
662    
663    
664    
665    
666      /**
667    
668        * encrypts a long buffer to itself
669    
670        * @param buffer buffer to encrypt
671    
672        */
673    
674      public void encrypt(long[] buffer) {
675    
676    
677    
678        int nLen = buffer.length;
679    
680        for (int nI = 0; nI < nLen; nI++) {
681    
682          buffer[nI] = encryptBlock(buffer[nI]);
683    
684        };
685    
686      };
687    
688    
689    
690    
691    
692    
693    
694      /**
695    
696        * decrypts a byte buffer (should be aligned to an 8 byte border)
697    
698        * to another byte buffer (of the same size or bigger)
699    
700        * @param inbuffer buffer with ciphertext data
701    
702        * @param outBuffer buffer to get the plaintext data
703    
704        */
705    
706      public void decrypt(byte[] inbuffer,
707    
708                          byte[] outbuffer) {
709    
710    
711    
712        int nLen = inbuffer.length;
713    
714        long lTemp;
715    
716        for (int nI = 0; nI < nLen; nI +=8) {
717    
718    
719    
720          // decrypt a temporary 64bit block
721    
722          lTemp = BinConverter.byteArrayToLong(inbuffer, nI);
723    
724          lTemp = decryptBlock(lTemp);
725    
726          BinConverter.longToByteArray(lTemp, outbuffer, nI);
727    
728        };
729    
730      };
731    
732    
733    
734    
735    
736    
737    
738      /**
739    
740        * decrypts a byte buffer (should be aligned to an 8 byte border) to itself
741    
742        * @param buffer buffer to decrypt
743    
744        */
745    
746      public void decrypt(byte[] buffer) {
747    
748    
749    
750        int nLen = buffer.length;
751    
752        long lTemp;
753    
754        for (int nI = 0; nI < nLen; nI +=8) {
755    
756    
757    
758          // decrypt over a temporary 64bit block
759    
760          lTemp = BinConverter.byteArrayToLong(buffer, nI);
761    
762          lTemp = decryptBlock(lTemp);
763    
764          BinConverter.longToByteArray(lTemp, buffer, nI);
765    
766        };
767    
768      };
769    
770    
771    
772    
773    
774    
775    
776    
777    
778      /**
779    
780        * decrypts an integer buffer (should be aligned to an
781    
782        * two integer border) to another int buffer (of the same size or bigger)
783    
784        * @param inbuffer buffer with ciphertext data
785    
786        * @param outbuffer buffer to get the plaintext data
787    
788        */
789    
790      public void decrypt(int[] inbuffer,
791    
792                          int[] outbuffer) {
793    
794    
795    
796        int nLen = inbuffer.length;
797    
798        long lTemp;
799    
800        for (int nI = 0; nI < nLen; nI +=2) {
801    
802    
803    
804          // decrypt a temporary 64bit block
805    
806          lTemp = BinConverter.intArrayToLong(inbuffer, nI);
807    
808          lTemp = decryptBlock(lTemp);
809    
810          BinConverter.longToIntArray(lTemp, outbuffer, nI);
811    
812        };
813    
814      };
815    
816    
817    
818    
819    
820      /**
821    
822        * decrypts an int buffer (should be aligned to an
823    
824        * two integer border)
825    
826        * @param buffer buffer to decrypt
827    
828        */
829    
830      public void decrypt(int[] buffer) {
831    
832    
833    
834        int nLen = buffer.length;
835    
836        long lTemp;
837    
838        for (int nI = 0; nI < nLen; nI +=2) {
839    
840    
841    
842          // decrypt a temporary 64bit block
843    
844          lTemp = BinConverter.intArrayToLong(buffer, nI);
845    
846          lTemp = decryptBlock(lTemp);
847    
848          BinConverter.longToIntArray(lTemp, buffer, nI);
849    
850        };
851    
852      };
853    
854    
855    
856    
857    
858    
859    
860      /**
861    
862        * decrypts a long buffer to another long buffer (of the same size or bigger)
863    
864        * @param inbuffer buffer with ciphertext data
865    
866        * @param outbuffer buffer to get the plaintext data
867    
868        */
869    
870      public void decrypt(long[] inbuffer,
871    
872                          long[] outbuffer) {
873    
874    
875    
876        int nLen = inbuffer.length;
877    
878        for (int nI = 0; nI < nLen; nI++)
879    
880          outbuffer[nI] = decryptBlock(inbuffer[nI]);
881    
882      };
883    
884    
885    
886    
887    
888    
889    
890      /**
891    
892        * decrypts a long buffer to itself
893    
894        * @param buffer buffer to decrypt
895    
896        */
897    
898      public void decrypt(long[] buffer) {
899    
900    
901    
902        int nLen = buffer.length;
903    
904        for (int nI = 0; nI < nLen; nI++)
905    
906          buffer[nI] = decryptBlock(buffer[nI]);
907    
908      };
909    
910    
911    
912    
913    
914    
915    
916    
917    
918      // the boxes init. data,
919    
920      //  it might be better to create them at runtime to make the class
921    
922      //        file smaller, e.g. by calculating the hexdigits of pi (default)
923    
924      //        or just a fixed random sequence (out of the standard)
925    
926    
927    
928      final static int pbox_init[] = {
929    
930    
931    
932      0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
933    
934      0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
935    
936      0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b  };
937    
938    
939    
940      final static int sbox_init_1[] = {
941    
942    
943    
944      0xd1310ba6,   0x98dfb5ac,   0x2ffd72db,   0xd01adfb7,   0xb8e1afed,   0x6a267e96,
945    
946      0xba7c9045,   0xf12c7f99,   0x24a19947,   0xb3916cf7,   0x0801f2e2,   0x858efc16,
947    
948      0x636920d8,   0x71574e69,   0xa458fea3,   0xf4933d7e,   0x0d95748f,   0x728eb658,
949    
950      0x718bcd58,   0x82154aee,   0x7b54a41d,   0xc25a59b5,   0x9c30d539,   0x2af26013,
951    
952      0xc5d1b023,   0x286085f0,   0xca417918,   0xb8db38ef,   0x8e79dcb0,   0x603a180e,
953    
954      0x6c9e0e8b,   0xb01e8a3e,   0xd71577c1,   0xbd314b27,   0x78af2fda,   0x55605c60,
955    
956      0xe65525f3,   0xaa55ab94,   0x57489862,   0x63e81440,   0x55ca396a,   0x2aab10b6,
957    
958      0xb4cc5c34,   0x1141e8ce,   0xa15486af,   0x7c72e993,   0xb3ee1411,   0x636fbc2a,
959    
960      0x2ba9c55d,   0x741831f6,   0xce5c3e16,   0x9b87931e,   0xafd6ba33,   0x6c24cf5c,
961    
962      0x7a325381,   0x28958677,   0x3b8f4898,   0x6b4bb9af,   0xc4bfe81b,   0x66282193,
963    
964      0x61d809cc,   0xfb21a991,   0x487cac60,   0x5dec8032,   0xef845d5d,   0xe98575b1,
965    
966      0xdc262302,   0xeb651b88,   0x23893e81,   0xd396acc5,   0x0f6d6ff3,   0x83f44239,
967    
968      0x2e0b4482,   0xa4842004,   0x69c8f04a,   0x9e1f9b5e,   0x21c66842,   0xf6e96c9a,
969    
970      0x670c9c61,   0xabd388f0,   0x6a51a0d2,   0xd8542f68,   0x960fa728,   0xab5133a3,
971    
972      0x6eef0b6c,   0x137a3be4,   0xba3bf050,   0x7efb2a98,   0xa1f1651d,   0x39af0176,
973    
974      0x66ca593e,   0x82430e88,   0x8cee8619,   0x456f9fb4,   0x7d84a5c3,   0x3b8b5ebe,
975    
976      0xe06f75d8,   0x85c12073,   0x401a449f,   0x56c16aa6,   0x4ed3aa62,   0x363f7706,
977    
978      0x1bfedf72,   0x429b023d,   0x37d0d724,   0xd00a1248,   0xdb0fead3,   0x49f1c09b,
979    
980      0x075372c9,   0x80991b7b,   0x25d479d8,   0xf6e8def7,   0xe3fe501a,   0xb6794c3b,
981    
982      0x976ce0bd,   0x04c006ba,   0xc1a94fb6,   0x409f60c4,   0x5e5c9ec2,   0x196a2463,
983    
984      0x68fb6faf,   0x3e6c53b5,   0x1339b2eb,   0x3b52ec6f,   0x6dfc511f,   0x9b30952c,
985    
986      0xcc814544,   0xaf5ebd09,   0xbee3d004,   0xde334afd,   0x660f2807,   0x192e4bb3,
987    
988      0xc0cba857,   0x45c8740f,   0xd20b5f39,   0xb9d3fbdb,   0x5579c0bd,   0x1a60320a,
989    
990      0xd6a100c6,   0x402c7279,   0x679f25fe,   0xfb1fa3cc,   0x8ea5e9f8,   0xdb3222f8,
991    
992      0x3c7516df,   0xfd616b15,   0x2f501ec8,   0xad0552ab,   0x323db5fa,   0xfd238760,
993    
994      0x53317b48,   0x3e00df82,   0x9e5c57bb,   0xca6f8ca0,   0x1a87562e,   0xdf1769db,
995    
996      0xd542a8f6,   0x287effc3,   0xac6732c6,   0x8c4f5573,   0x695b27b0,   0xbbca58c8,
997    
998      0xe1ffa35d,   0xb8f011a0,   0x10fa3d98,   0xfd2183b8,   0x4afcb56c,   0x2dd1d35b,
999    
1000      0x9a53e479,   0xb6f84565,   0xd28e49bc,   0x4bfb9790,   0xe1ddf2da,   0xa4cb7e33,
1001    
1002      0x62fb1341,   0xcee4c6e8,   0xef20cada,   0x36774c01,   0xd07e9efe,   0x2bf11fb4,
1003    
1004      0x95dbda4d,   0xae909198,   0xeaad8e71,   0x6b93d5a0,   0xd08ed1d0,   0xafc725e0,
1005    
1006      0x8e3c5b2f,   0x8e7594b7,   0x8ff6e2fb,   0xf2122b64,   0x8888b812,   0x900df01c,
1007    
1008      0x4fad5ea0,   0x688fc31c,   0xd1cff191,   0xb3a8c1ad,   0x2f2f2218,   0xbe0e1777,
1009    
1010      0xea752dfe,   0x8b021fa1,   0xe5a0cc0f,   0xb56f74e8,   0x18acf3d6,   0xce89e299,
1011    
1012      0xb4a84fe0,   0xfd13e0b7,   0x7cc43b81,   0xd2ada8d9,   0x165fa266,   0x80957705,
1013    
1014      0x93cc7314,   0x211a1477,   0xe6ad2065,   0x77b5fa86,   0xc75442f5,   0xfb9d35cf,
1015    
1016      0xebcdaf0c,   0x7b3e89a0,   0xd6411bd3,   0xae1e7e49,   0x00250e2d,   0x2071b35e,
1017    
1018      0x226800bb,   0x57b8e0af,   0x2464369b,   0xf009b91e,   0x5563911d,   0x59dfa6aa,
1019    
1020      0x78c14389,   0xd95a537f,   0x207d5ba2,   0x02e5b9c5,   0x83260376,   0x6295cfa9,
1021    
1022      0x11c81968,   0x4e734a41,   0xb3472dca,   0x7b14a94a,   0x1b510052,   0x9a532915,
1023    
1024      0xd60f573f,   0xbc9bc6e4,   0x2b60a476,   0x81e67400,   0x08ba6fb5,   0x571be91f,
1025    
1026      0xf296ec6b,   0x2a0dd915,   0xb6636521,   0xe7b9f9b6,   0xff34052e,   0xc5855664,
1027    
1028      0x53b02d5d,   0xa99f8fa1,   0x08ba4799,   0x6e85076a };
1029    
1030    
1031    
1032    
1033    
1034      final static int sbox_init_2[] = {
1035    
1036    
1037    
1038      0x4b7a70e9,   0xb5b32944,
1039    
1040      0xdb75092e,   0xc4192623,   0xad6ea6b0,   0x49a7df7d,   0x9cee60b8,   0x8fedb266,
1041    
1042      0xecaa8c71,   0x699a17ff,   0x5664526c,   0xc2b19ee1,   0x193602a5,   0x75094c29,
1043    
1044      0xa0591340,   0xe4183a3e,   0x3f54989a,   0x5b429d65,   0x6b8fe4d6,   0x99f73fd6,
1045    
1046      0xa1d29c07,   0xefe830f5,   0x4d2d38e6,   0xf0255dc1,   0x4cdd2086,   0x8470eb26,
1047    
1048      0x6382e9c6,   0x021ecc5e,   0x09686b3f,   0x3ebaefc9,   0x3c971814,   0x6b6a70a1,
1049    
1050      0x687f3584,   0x52a0e286,   0xb79c5305,   0xaa500737,   0x3e07841c,   0x7fdeae5c,
1051    
1052      0x8e7d44ec,   0x5716f2b8,   0xb03ada37,   0xf0500c0d,   0xf01c1f04,   0x0200b3ff,
1053    
1054      0xae0cf51a,   0x3cb574b2,   0x25837a58,   0xdc0921bd,   0xd19113f9,   0x7ca92ff6,
1055    
1056      0x94324773,   0x22f54701,   0x3ae5e581,   0x37c2dadc,   0xc8b57634,   0x9af3dda7,
1057    
1058      0xa9446146,   0x0fd0030e,   0xecc8c73e,   0xa4751e41,   0xe238cd99,   0x3bea0e2f,
1059    
1060      0x3280bba1,   0x183eb331,   0x4e548b38,   0x4f6db908,   0x6f420d03,   0xf60a04bf,
1061    
1062      0x2cb81290,   0x24977c79,   0x5679b072,   0xbcaf89af,   0xde9a771f,   0xd9930810,
1063    
1064      0xb38bae12,   0xdccf3f2e,   0x5512721f,   0x2e6b7124,   0x501adde6,   0x9f84cd87,
1065    
1066      0x7a584718,   0x7408da17,   0xbc9f9abc,   0xe94b7d8c,   0xec7aec3a,   0xdb851dfa,
1067    
1068      0x63094366,   0xc464c3d2,   0xef1c1847,   0x3215d908,   0xdd433b37,   0x24c2ba16,
1069    
1070      0x12a14d43,   0x2a65c451,   0x50940002,   0x133ae4dd,   0x71dff89e,   0x10314e55,
1071    
1072      0x81ac77d6,   0x5f11199b,   0x043556f1,   0xd7a3c76b,   0x3c11183b,   0x5924a509,
1073    
1074      0xf28fe6ed,   0x97f1fbfa,   0x9ebabf2c,   0x1e153c6e,   0x86e34570,   0xeae96fb1,
1075    
1076      0x860e5e0a,   0x5a3e2ab3,   0x771fe71c,   0x4e3d06fa,   0x2965dcb9,   0x99e71d0f,
1077    
1078      0x803e89d6,   0x5266c825,   0x2e4cc978,   0x9c10b36a,   0xc6150eba,   0x94e2ea78,
1079    
1080      0xa5fc3c53,   0x1e0a2df4,   0xf2f74ea7,   0x361d2b3d,   0x1939260f,   0x19c27960,
1081    
1082      0x5223a708,   0xf71312b6,   0xebadfe6e,   0xeac31f66,   0xe3bc4595,   0xa67bc883,
1083    
1084      0xb17f37d1,   0x018cff28,   0xc332ddef,   0xbe6c5aa5,   0x65582185,   0x68ab9802,
1085    
1086      0xeecea50f,   0xdb2f953b,   0x2aef7dad,   0x5b6e2f84,   0x1521b628,   0x29076170,
1087    
1088      0xecdd4775,   0x619f1510,   0x13cca830,   0xeb61bd96,   0x0334fe1e,   0xaa0363cf,
1089    
1090      0xb5735c90,   0x4c70a239,   0xd59e9e0b,   0xcbaade14,   0xeecc86bc,   0x60622ca7,
1091    
1092      0x9cab5cab,   0xb2f3846e,   0x648b1eaf,   0x19bdf0ca,   0xa02369b9,   0x655abb50,
1093    
1094      0x40685a32,   0x3c2ab4b3,   0x319ee9d5,   0xc021b8f7,   0x9b540b19,   0x875fa099,
1095    
1096      0x95f7997e,   0x623d7da8,   0xf837889a,   0x97e32d77,   0x11ed935f,   0x16681281,
1097    
1098      0x0e358829,   0xc7e61fd6,   0x96dedfa1,   0x7858ba99,   0x57f584a5,   0x1b227263,
1099    
1100      0x9b83c3ff,   0x1ac24696,   0xcdb30aeb,   0x532e3054,   0x8fd948e4,   0x6dbc3128,
1101    
1102      0x58ebf2ef,   0x34c6ffea,   0xfe28ed61,   0xee7c3c73,   0x5d4a14d9,   0xe864b7e3,
1103    
1104      0x42105d14,   0x203e13e0,   0x45eee2b6,   0xa3aaabea,   0xdb6c4f15,   0xfacb4fd0,
1105    
1106      0xc742f442,   0xef6abbb5,   0x654f3b1d,   0x41cd2105,   0xd81e799e,   0x86854dc7,
1107    
1108      0xe44b476a,   0x3d816250,   0xcf62a1f2,   0x5b8d2646,   0xfc8883a0,   0xc1c7b6a3,
1109    
1110      0x7f1524c3,   0x69cb7492,   0x47848a0b,   0x5692b285,   0x095bbf00,   0xad19489d,
1111    
1112      0x1462b174,   0x23820e00,   0x58428d2a,   0x0c55f5ea,   0x1dadf43e,   0x233f7061,
1113    
1114      0x3372f092,   0x8d937e41,   0xd65fecf1,   0x6c223bdb,   0x7cde3759,   0xcbee7460,
1115    
1116      0x4085f2a7,   0xce77326e,   0xa6078084,   0x19f8509e,   0xe8efd855,   0x61d99735,
1117    
1118      0xa969a7aa,   0xc50c06c2,   0x5a04abfc,   0x800bcadc,   0x9e447a2e,   0xc3453484,
1119    
1120      0xfdd56705,   0x0e1e9ec9,   0xdb73dbd3,   0x105588cd,   0x675fda79,   0xe3674340,
1121    
1122      0xc5c43465,   0x713e38d8,   0x3d28f89e,   0xf16dff20,   0x153e21e7,   0x8fb03d4a,
1123    
1124      0xe6e39f2b,   0xdb83adf7 };
1125    
1126    
1127    
1128      final static int sbox_init_3[] = {
1129    
1130    
1131    
1132      0xe93d5a68,   0x948140f7,   0xf64c261c,   0x94692934,
1133    
1134      0x411520f7,   0x7602d4f7,   0xbcf46b2e,   0xd4a20068,   0xd4082471,   0x3320f46a,
1135    
1136      0x43b7d4b7,   0x500061af,   0x1e39f62e,   0x97244546,   0x14214f74,   0xbf8b8840,
1137    
1138      0x4d95fc1d,   0x96b591af,   0x70f4ddd3,   0x66a02f45,   0xbfbc09ec,   0x03bd9785,
1139    
1140      0x7fac6dd0,   0x31cb8504,   0x96eb27b3,   0x55fd3941,   0xda2547e6,   0xabca0a9a,
1141    
1142      0x28507825,   0x530429f4,   0x0a2c86da,   0xe9b66dfb,   0x68dc1462,   0xd7486900,
1143    
1144      0x680ec0a4,   0x27a18dee,   0x4f3ffea2,   0xe887ad8c,   0xb58ce006,   0x7af4d6b6,
1145    
1146      0xaace1e7c,   0xd3375fec,   0xce78a399,   0x406b2a42,   0x20fe9e35,   0xd9f385b9,
1147    
1148      0xee39d7ab,   0x3b124e8b,   0x1dc9faf7,   0x4b6d1856,   0x26a36631,   0xeae397b2,
1149    
1150      0x3a6efa74,   0xdd5b4332,   0x6841e7f7,   0xca7820fb,   0xfb0af54e,   0xd8feb397,
1151    
1152      0x454056ac,   0xba489527,   0x55533a3a,   0x20838d87,   0xfe6ba9b7,   0xd096954b,
1153    
1154      0x55a867bc,   0xa1159a58,   0xcca92963,   0x99e1db33,   0xa62a4a56,   0x3f3125f9,
1155    
1156      0x5ef47e1c,   0x9029317c,   0xfdf8e802,   0x04272f70,   0x80bb155c,   0x05282ce3,
1157    
1158      0x95c11548,   0xe4c66d22,   0x48c1133f,   0xc70f86dc,   0x07f9c9ee,   0x41041f0f,
1159    
1160      0x404779a4,   0x5d886e17,   0x325f51eb,   0xd59bc0d1,   0xf2bcc18f,   0x41113564,
1161    
1162      0x257b7834,   0x602a9c60,   0xdff8e8a3,   0x1f636c1b,   0x0e12b4c2,   0x02e1329e,
1163    
1164      0xaf664fd1,   0xcad18115,   0x6b2395e0,   0x333e92e1,   0x3b240b62,   0xeebeb922,
1165    
1166      0x85b2a20e,   0xe6ba0d99,   0xde720c8c,   0x2da2f728,   0xd0127845,   0x95b794fd,
1167    
1168      0x647d0862,   0xe7ccf5f0,   0x5449a36f,   0x877d48fa,   0xc39dfd27,   0xf33e8d1e,
1169    
1170      0x0a476341,   0x992eff74,   0x3a6f6eab,   0xf4f8fd37,   0xa812dc60,   0xa1ebddf8,
1171    
1172      0x991be14c,   0xdb6e6b0d,   0xc67b5510,   0x6d672c37,   0x2765d43b,   0xdcd0e804,
1173    
1174      0xf1290dc7,   0xcc00ffa3,   0xb5390f92,   0x690fed0b,   0x667b9ffb,   0xcedb7d9c,
1175    
1176      0xa091cf0b,   0xd9155ea3,   0xbb132f88,   0x515bad24,   0x7b9479bf,   0x763bd6eb,
1177    
1178      0x37392eb3,   0xcc115979,   0x8026e297,   0xf42e312d,   0x6842ada7,   0xc66a2b3b,
1179    
1180      0x12754ccc,   0x782ef11c,   0x6a124237,   0xb79251e7,   0x06a1bbe6,   0x4bfb6350,
1181    
1182      0x1a6b1018,   0x11caedfa,   0x3d25bdd8,   0xe2e1c3c9,   0x44421659,   0x0a121386,
1183    
1184      0xd90cec6e,   0xd5abea2a,   0x64af674e,   0xda86a85f,   0xbebfe988,   0x64e4c3fe,
1185    
1186      0x9dbc8057,   0xf0f7c086,   0x60787bf8,   0x6003604d,   0xd1fd8346,   0xf6381fb0,
1187    
1188      0x7745ae04,   0xd736fccc,   0x83426b33,   0xf01eab71,   0xb0804187,   0x3c005e5f,
1189    
1190      0x77a057be,   0xbde8ae24,   0x55464299,   0xbf582e61,   0x4e58f48f,   0xf2ddfda2,
1191    
1192      0xf474ef38,   0x8789bdc2,   0x5366f9c3,   0xc8b38e74,   0xb475f255,   0x46fcd9b9,
1193    
1194      0x7aeb2661,   0x8b1ddf84,   0x846a0e79,   0x915f95e2,   0x466e598e,   0x20b45770,
1195    
1196      0x8cd55591,   0xc902de4c,   0xb90bace1,   0xbb8205d0,   0x11a86248,   0x7574a99e,
1197    
1198      0xb77f19b6,   0xe0a9dc09,   0x662d09a1,   0xc4324633,   0xe85a1f02,   0x09f0be8c,
1199    
1200      0x4a99a025,   0x1d6efe10,   0x1ab93d1d,   0x0ba5a4df,   0xa186f20f,   0x2868f169,
1201    
1202      0xdcb7da83,   0x573906fe,   0xa1e2ce9b,   0x4fcd7f52,   0x50115e01,   0xa70683fa,
1203    
1204      0xa002b5c4,   0x0de6d027,   0x9af88c27,   0x773f8641,   0xc3604c06,   0x61a806b5,
1205    
1206      0xf0177a28,   0xc0f586e0,   0x006058aa,   0x30dc7d62,   0x11e69ed7,   0x2338ea63,
1207    
1208      0x53c2dd94,   0xc2c21634,   0xbbcbee56,   0x90bcb6de,   0xebfc7da1,   0xce591d76,
1209    
1210      0x6f05e409,   0x4b7c0188,   0x39720a3d,   0x7c927c24,   0x86e3725f,   0x724d9db9,
1211    
1212      0x1ac15bb4,   0xd39eb8fc,   0xed545578,   0x08fca5b5,   0xd83d7cd3,   0x4dad0fc4,
1213    
1214      0x1e50ef5e,   0xb161e6f8,   0xa28514d9,   0x6c51133c,   0x6fd5c7e7,   0x56e14ec4,
1215    
1216      0x362abfce,   0xddc6c837,   0xd79a3234,   0x92638212,   0x670efa8e,   0x406000e0 };
1217    
1218    
1219    
1220    
1221    
1222      final static int sbox_init_4[] = {
1223    
1224    
1225    
1226      0x3a39ce37,   0xd3faf5cf,   0xabc27737,   0x5ac52d1b,   0x5cb0679e,   0x4fa33742,
1227    
1228      0xd3822740,   0x99bc9bbe,   0xd5118e9d,   0xbf0f7315,   0xd62d1c7e,   0xc700c47b,
1229    
1230      0xb78c1b6b,   0x21a19045,   0xb26eb1be,   0x6a366eb4,   0x5748ab2f,   0xbc946e79,
1231    
1232      0xc6a376d2,   0x6549c2c8,   0x530ff8ee,   0x468dde7d,   0xd5730a1d,   0x4cd04dc6,
1233    
1234      0x2939bbdb,   0xa9ba4650,   0xac9526e8,   0xbe5ee304,   0xa1fad5f0,   0x6a2d519a,
1235    
1236      0x63ef8ce2,   0x9a86ee22,   0xc089c2b8,   0x43242ef6,   0xa51e03aa,   0x9cf2d0a4,
1237    
1238      0x83c061ba,   0x9be96a4d,   0x8fe51550,   0xba645bd6,   0x2826a2f9,   0xa73a3ae1,
1239    
1240      0x4ba99586,   0xef5562e9,   0xc72fefd3,   0xf752f7da,   0x3f046f69,   0x77fa0a59,
1241    
1242      0x80e4a915,   0x87b08601,   0x9b09e6ad,   0x3b3ee593,   0xe990fd5a,   0x9e34d797,
1243    
1244      0x2cf0b7d9,   0x022b8b51,   0x96d5ac3a,   0x017da67d,   0xd1cf3ed6,   0x7c7d2d28,
1245    
1246      0x1f9f25cf,   0xadf2b89b,   0x5ad6b472,   0x5a88f54c,   0xe029ac71,   0xe019a5e6,
1247    
1248      0x47b0acfd,   0xed93fa9b,   0xe8d3c48d,   0x283b57cc,   0xf8d56629,   0x79132e28,
1249    
1250      0x785f0191,   0xed756055,   0xf7960e44,   0xe3d35e8c,   0x15056dd4,   0x88f46dba,
1251    
1252      0x03a16125,   0x0564f0bd,   0xc3eb9e15,   0x3c9057a2,   0x97271aec,   0xa93a072a,
1253    
1254      0x1b3f6d9b,   0x1e6321f5,   0xf59c66fb,   0x26dcf319,   0x7533d928,   0xb155fdf5,
1255    
1256      0x03563482,   0x8aba3cbb,   0x28517711,   0xc20ad9f8,   0xabcc5167,   0xccad925f,
1257    
1258      0x4de81751,   0x3830dc8e,   0x379d5862,   0x9320f991,   0xea7a90c2,   0xfb3e7bce,
1259    
1260      0x5121ce64,   0x774fbe32,   0xa8b6e37e,   0xc3293d46,   0x48de5369,   0x6413e680,
1261    
1262      0xa2ae0810,   0xdd6db224,   0x69852dfd,   0x09072166,   0xb39a460a,   0x6445c0dd,
1263    
1264      0x586cdecf,   0x1c20c8ae,   0x5bbef7dd,   0x1b588d40,   0xccd2017f,   0x6bb4e3bb,
1265    
1266      0xdda26a7e,   0x3a59ff45,   0x3e350a44,   0xbcb4cdd5,   0x72eacea8,   0xfa6484bb,
1267    
1268      0x8d6612ae,   0xbf3c6f47,   0xd29be463,   0x542f5d9e,   0xaec2771b,   0xf64e6370,
1269    
1270      0x740e0d8d,   0xe75b1357,   0xf8721671,   0xaf537d5d,   0x4040cb08,   0x4eb4e2cc,
1271    
1272      0x34d2466a,   0x0115af84,   0xe1b00428,   0x95983a1d,   0x06b89fb4,   0xce6ea048,
1273    
1274      0x6f3f3b82,   0x3520ab82,   0x011a1d4b,   0x277227f8,   0x611560b1,   0xe7933fdc,
1275    
1276      0xbb3a792b,   0x344525bd,   0xa08839e1,   0x51ce794b,   0x2f32c9b7,   0xa01fbac9,
1277    
1278      0xe01cc87e,   0xbcc7d1f6,   0xcf0111c3,   0xa1e8aac7,   0x1a908749,   0xd44fbd9a,
1279    
1280      0xd0dadecb,   0xd50ada38,   0x0339c32a,   0xc6913667,   0x8df9317c,   0xe0b12b4f,
1281    
1282      0xf79e59b7,   0x43f5bb3a,   0xf2d519ff,   0x27d9459c,   0xbf97222c,   0x15e6fc2a,
1283    
1284      0x0f91fc71,   0x9b941525,   0xfae59361,   0xceb69ceb,   0xc2a86459,   0x12baa8d1,
1285    
1286      0xb6c1075e,   0xe3056a0c,   0x10d25065,   0xcb03a442,   0xe0ec6e0e,   0x1698db3b,
1287    
1288      0x4c98a0be,   0x3278e964,   0x9f1f9532,   0xe0d392df,   0xd3a0342b,   0x8971f21e,
1289    
1290      0x1b0a7441,   0x4ba3348c,   0xc5be7120,   0xc37632d8,   0xdf359f8d,   0x9b992f2e,
1291    
1292      0xe60b6f47,   0x0fe3f11d,   0xe54cda54,   0x1edad891,   0xce6279cf,   0xcd3e7e6f,
1293    
1294      0x1618b166,   0xfd2c1d05,   0x848fd2c5,   0xf6fb2299,   0xf523f357,   0xa6327623,
1295    
1296      0x93a83531,   0x56cccd02,   0xacf08162,   0x5a75ebb5,   0x6e163697,   0x88d273cc,
1297    
1298      0xde966292,   0x81b949d0,   0x4c50901b,   0x71c65614,   0xe6c6c7bd,   0x327a140a,
1299    
1300      0x45e1d006,   0xc3f27b9a,   0xc9aa53fd,   0x62a80f00,   0xbb25bfe2,   0x35bdd2f6,
1301    
1302      0x71126905,   0xb2040222,   0xb6cbcf7c,   0xcd769c2b,   0x53113ec0,   0x1640e3d3,
1303    
1304      0x38abbd60,   0x2547adf0,   0xba38209c,   0xf746ce76,   0x77afa1c5,   0x20756060,
1305    
1306      0x85cbfe4e,   0x8ae88dd8,   0x7aaaf9b0,   0x4cf9aa7e,   0x1948c25c,   0x02fb8a8c,
1307    
1308      0x01c36ae4,   0xd6ebe1f9,   0x90d4f869,   0xa65cdea0,   0x3f09252d,   0xc208e69f,
1309    
1310      0xb74e6132,   0xce77e25b,   0x578fdfe3,   0x3ac372e6 };
1311    
1312    
1313    
1314    
1315    
1316    
1317    
1318    };