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};