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