https://www.goldcar.es/mygoldcar/js/jsencryption.js

1/**
2 * @class Blowfish
3 * @description
4 * Шифратор/дешифратор. Алгоритм Blowfish
5 *
6 * в режиме ecb: исходная строка разбивается на 8-байтные блоки, каждый блок
7 *   шифруется. Если размер блока менее 8 байт, то дополняем его до 8 байт нулями.
8 * в режиме cbc: первый блок открытого текста, из 8 байт, перед шифрованием побитово
9 *   складывается по модулю 2 (операция XOR) с вектором инициализации;
10 *   последующие блоки открытого текста побитового складываются (XOR) с предыдущим результатом
11 *   шифрования после этого зашифровываются.
12 *
13 * Подробнее о режимах шифрования:
14 * http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F
15 *
16 * @example
17 * // Пример 1: режим ECB, по умолчанию
18 * var bf = new Blowfish("secret key");
19 * var encrypted = bf.encrypt("конфиденциальное сообщение");
20 * var decrypted = bf.decrypt(encrypted);
21 *
22 * // Пример 2: режим CBC (лучше подходит для шифрования длинных сообщений, более 1kb):
23 * var bf = new Blowfish("key", "cbc");
24 * var encrypted = bf.encrypt("secret message", "cbcvecto");
25 * var decrypted = bf.decrypt(encrypted, "cbcvecto");
26 *
27 * //В режиме CBC вектор иницаилазиации iv это дополнительный пароль.
28 *
29 * // Пример 3:
30 * // После шифрования получается бинарная строка. Чтобы передать
31 * // зашифрованное сообщение в эл.письме нужно закодировать бинарную
32 * // строку в base64
33 * var bf = new Blowfish("key");
34 *
35 * // Для удобства включил, в этот класс методы base64Encode и base64Decode
36 *
37 * // Шифрование
38 * var encrypted = bf.base64Encode(bf.encrypt("secret message"));
39 *
40 * // Расшифрование
41 * var encrypted = bf.base64Decode(encrypted);
42 * var decrypted = bf.decrypt(encrypted);
43 *
44 * @param {string} key    пароль (может быть длинной до 56 байт)
45 * @param {string} [mode] режим шифрования
46 * @author Alexandr Gorlov <[email protected]>
47 */
48var Blowfish = function(key, mode) {
49
50  // инициализация пароля
51  this.key = key;
52
53  // инициализация режима шифрования
54  if (mode === "ecb" || mode === "cbc") {
55    this.mode = mode;
56  }
57
58  // инициализация массивов с кодами символов (правда ведь?)
59  this.sBox0  = Blowfish.sBox0.slice();
60  this.sBox1  = Blowfish.sBox1.slice();
61  this.sBox2  = Blowfish.sBox2.slice();
62  this.sBox3  = Blowfish.sBox3.slice();
63  this.pArray = Blowfish.pArray.slice();
64
65  // инициализация шифра
66  this.generateSubkeys(key);
67};
68
69Blowfish.prototype = {
70
71  /**
72   * @type {Array}
73   */
74  sBox0: null,
75
76  /**
77   * @type {Array}
78   */
79  sBox1: null,
80
81  /**
82   * @type {Array}
83   */
84  sBox2: null,
85
86  /**
87   * @type {Array}
88   */
89  sBox3: null,
90
91  /**
92   * @type {Array}
93   */
94  pArray: null,
95
96  /**
97   * Пароль
98   * @type {string}
99   */
100  key: null,
101
102  /**
103   * Режим шифрования: ecb|cbc; по умолчанию: ecb
104   * @type {string}
105   */
106  mode: "ecb",
107
108  /**
109   * Вектор инициализации для режима cbc
110   * @type {string}
111   */
112  iv:  "abc12345",
113
114  /**
115   * Набор символов для base64
116   * @type {string}
117   */
118  keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
119
120  /**
121   * Шифрует строку
122   * @param {string} string шифруемая строка
123   * @param {string} iv произвольная 8байтная строка - вектор инициализации;
124   *                    используется только в режиме CBC
125   * @throws {Error} кидает исключение при неизвестном режиме шифрования
126   * @return {string} зашифрованная строка
127   */
128  encrypt: function(string, iv) {
129    if (this.mode === "ecb") {
130      return this.encryptECB(string);
131    }
132
133    if (this.mode === "cbc") {
134      return this.encryptCBC(string, iv);
135    }
136
137    throw new Error("Неизвестный режим шифрования.");
138  },
139
140  /**
141   * Расшифровывает строку
142   * @param {string} string зашифрованная строка
143   * @param {string} iv произвольная 8байтная строка - вектор инициализации
144   *                    (должен быть тотже, что и при шифровании) используется
145   *                    только в режиме CBC
146   * @throws {Error} кидает исключение при неизвестном режиме шифрования
147   * @return {string} расшифрованная строка
148   */
149  decrypt: function(string, iv) {
150    if (this.mode === "ecb") {
151      return this.decryptECB(string);
152    }
153
154    if (this.mode === "cbc") {
155      return this.decryptCBC(string, iv);
156    }
157
158    throw new Error("Неизвестный режим шифрования.");
159  },
160
161  /**
162   * Шифрует в режиме ECB
163   * (приватный метод)
164   * @param {string} string шифруемая строка
165   * @return {string} зашифрованная строка
166   */
167  encryptECB: function(string) {
168    string = this.utf8Decode(string);
169    var blocks = Math.ceil(string.length/8);
170
171    //1. разбить строку на 8-байтные блок-и
172    //2. разбить 8байтные блоки на 32-битные пары xL, xR
173    //3. зашифровать все блоки
174    //4. преобразовать результат в строку
175
176    var encryptedString = "";
177    for (var i = 0; i < blocks; i++) {
178      var block = string.substr(i * 8, 8);
179      if (block.length < 8) {
180        var count = 8 - block.length;
181        while (0 < count--) {
182          block += "\0";
183        }
184      }
185
186      var xL, xR;
187      //[xL, xR] = this.split64by32(block); не работает в IE, Chrome
188      var xLxR  = this.split64by32(block);
189      xL = xLxR[0];
190      xR = xLxR[1];
191
192      //[xL, xR] = this.encipher(xL, xR); не работает в IE, Chrome
193      xLxR = this.encipher(xL, xR);
194      xL = xLxR[0];
195      xR = xLxR[1];
196      encryptedString += this.num2block32(xL) + this.num2block32(xR);
197    }
198
199    return encryptedString;
200  },
201
202  /**
203   * Шифрует в режиме CBC
204   * (приватный метод)
205   * @param {string} string шифруемая строка
206   * @param {string} iv 8-байтная строка - вектор инициализации
207   * @return {string} зашифрованная строка
208   */
209  encryptCBC: function(string, iv) {
210    string = this.utf8Decode(string);
211    var blocks = Math.ceil(string.length/8);
212
213    //1. разбить строку на 8-байтные блок-и
214    //2. разбить 8байтные блоки на 32-битные пары xL, xR
215    //3. зашифровать все блоки
216    //4. преобразовать результат в строку
217
218    var ivL, ivR, ivLivR;
219    //[ivL, ivR] = this.split64by32(iv);

220    ivLivR = this.split64by32(iv);
221    ivL = ivLivR[0];
222    ivR = ivLivR[1];
223
224    var encryptedString = "";
225    for (var i = 0; i < blocks; i++) {
226      var block = string.substr(i * 8, 8);
227      if (block.length < 8) {
228        var count = 8 - block.length;
229        while (0 < count--) {
230          block += "\0";
231        }
232      }
233
234      var xL, xR, xLxR;
235      xLxR = this.split64by32(block);
236      xL = xLxR[0];
237      xR = xLxR[1];
238
239      xL = this.xor(xL, ivL);
240      xR = this.xor(xR, ivR);
241
242      xLxR = this.encipher(xL, xR);
243      xL = xLxR[0];
244      xR = xLxR[1];
245//      ivL = xL; - не используется
246//      ivR = xR; - не используется
247      //[ivL, ivR] = [xL, xR];
248      encryptedString += this.num2block32(xL) + this.num2block32(xR);
249    }
250
251    return encryptedString;
252  },
253
254  /**
255   * Расшифровать в режиме ECB
256   * (приватный метод)
257   * @param {string} string шифруемая строка
258   * @throws {Error} кидает исключение если зашифрованная строка повреждена
259   * @return {string} зашифрованная строка
260   */
261  decryptECB: function(string) {
262    var blocks = Math.ceil(string.length/8);
263
264    var decryptedString = "";
265    for (var i = 0; i < blocks; i++) {
266      var block = string.substr(i * 8, 8);
267      if (block.length < 8) {
268        throw new Error("Зашифрованная строка повреждена: длинна зашифрованной строки должна быть кратна 8 баыйтам.");
269      }
270      var xL, xR, xLxR;
271
272      xLxR = this.split64by32(block);
273      xL = xLxR[0];
274      xR = xLxR[1];
275
276      xLxR = this.decipher(xL, xR);
277      xL = xLxR[0];
278      xR = xLxR[1];
279
280      decryptedString += this.num2block32(xL) + this.num2block32(xR);
281    }
282
283    decryptedString = this.utf8Encode(decryptedString);
284    return decryptedString;
285  },
286
287  /**
288   * Шифрует в режиме CBC
289   * (приватный метод)
290   * @param {string} string зашифрованная строка
291   * @param {string} iv 8-байтная строка - вектор инициализации
292   * @throws {Error} кидает исключение если зашифрованная строка повреждена
293   * @return {string} расшифрованая строка
294   */
295  decryptCBC: function(string, iv) {
296
297    var blocks = Math.ceil(string.length/8);
298
299    var ivL, ivR, ivLtmp, ivRtmp, ivLivR;
300
301    ivLivR = this.split64by32(iv);
302    ivL = ivLivR[0];
303    ivR = ivLivR[1];
304
305    var decryptedString = "";
306    for (var i = 0; i < blocks; i++) {
307      var block = string.substr(i * 8, 8);
308      if (block.length < 8) {
309        throw new Error("Зашифрованная строка повреждена: длинна зашифрованной строки должна быть кратна 8 байтам.");
310      }
311      var xL, xR, xLxR;
312      xLxR = this.split64by32(block);
313      xL = xLxR[0];
314      xR = xLxR[1];
315
316      ivLtmp = xL;
317      ivRtmp = xR;
318
319      xLxR = this.decipher(xL, xR);
320      xL = xLxR[0];
321      xR = xLxR[1];
322
323      xL = this.xor(xL, ivL);
324      xR = this.xor(xR, ivR);
325
326      ivL = ivLtmp;
327      ivR = ivRtmp;
328      decryptedString += this.num2block32(xL) + this.num2block32(xR);
329    }
330
331    decryptedString = this.utf8Encode(decryptedString);
332    return decryptedString;
333  },
334
335  /**
336   * Функция F
337   * Function F looks like this:
338   * Divide xL into four eight-bit quarters: a, b, c, and d.
339   * Then, F(xL) = ((S1,a + S2,b mod 232) XOR S3,c) + S4,d mod 232.
340   * F(0xFFFFFF)
341   * ((S1[255] + S2[255]) XOR S3[255]) + S4[255]
342   * ((0x6e85076a + 0xdb83adf7) ^ 0x406000e0) + 0x3ac372e6
343   * @param {int32} xL 32битное значение
344   */
345  F: function(xL) {
346    var a = xL >>> 24;
347    var b = xL << 8 >>> 24;
348    var c = xL << 16 >>> 24;
349    var d = xL << 24 >>> 24;
350
351    var res = this.addMod32(this.sBox0[a], this.sBox1[b]);
352    res = this.xor(res, this.sBox2[c]);
353    res = this.addMod32(res, this.sBox3[d]);
354    return res;
355  },
356
357  /**
358   * Шифрует строку из 8 байт (один блок)
359   * Encryption and Decryption:
360   * Blowfish has 16 rounds. The input is a 64-bit data element, x.
361   * Divide x into two 32-bit halves: xL, xR. Then, for i = 1 to 16:
362   * xL = xL XOR Pi
363   * xR = F(xL) XOR xR
364   * Swap xL and xR
365   * After the sixteenth round, swap xL and xR again to undo the last swap.
366   * Then, xR = xR XOR P17 and xL = xL XOR P18. Finally, recombine xL and xR
367   * to get the ciphertext.
368   * Function F looks like this:
369   * Divide xL into four eight-bit quarters: a, b, c, and d.
370   * Then, F(xL) = ((S1,a + S2,b mod 232) XOR S3,c) + S4,d mod 232.
371   * Decryption is exactly the same as encryption, except that P1, P2,..., P18
372   * are used in the reverse order.
373   * @param {int32} xL первые 4 символа в виде числа 32битного беззнакового
374   * @param {int32} xR оставшиеся 4 символа в виде числа 32битного беззнакового
375   * @return {Array} зашифрованный 8-байтный блок в виде пары 32битных чисел [xL, xR]
376   */
377  encipher: function(xL, xR) {
378    var tmp;
379    for (var i = 0; i < 16; i++) {
380      xL = this.xor(xL, this.pArray[i]);
381      xR = this.xor(this.F(xL), xR);
382      tmp = xL;
383      xL = xR;
384      xR = tmp;
385    }
386
387    tmp = xL;
388    xL = xR;
389    xR = tmp;
390
391    xR = this.xor(xR, this.pArray[16]);
392    xL = this.xor(xL, this.pArray[17]);
393
394    return [xL, xR];
395  },
396
397  /**
398   * ??
399   * @param {int32} xL
400   * @param {int32} xR
401   * @return {Array}
402   */
403  decipher: function(xL, xR) {
404    var tmp;
405
406    xL = this.xor(xL, this.pArray[17]);
407    xR = this.xor(xR, this.pArray[16]);
408
409    tmp = xL;
410    xL = xR;
411    xR = tmp;
412
413    for (var i = 15; i >= 0; i--) {
414      tmp = xL;
415      xL = xR;
416      xR = tmp;
417      xR = this.xor(this.F(xL), xR);
418      xL = this.xor(xL, this.pArray[i]);
419    }
420
421    return [xL, xR];
422  },
423
424  /**
425   * Генерация ключей (subkeys)
426   * Generating the Subkeys:
427   * The subkeys are calculated using the Blowfish algorithm:
428   * 1. Initialize first the P-array and then the four S-boxes, in order,
429   *    with a fixed string. This string consists of the hexadecimal digits
430   *    of pi (less the initial 3): P1 = 0x243f6a88, P2 = 0x85a308d3,
431   *    P3 = 0x13198a2e, P4 = 0x03707344, etc.
432   * 2. XOR P1 with the first 32 bits of the key, XOR P2 with the second 32-bits
433   *    of the key, and so on for all bits of the key (possibly up to P14).
434   *    Repeatedly cycle through the key bits until the entire P-array has
435   *    been XORed with key bits. (For every short key, there is at least one
436   *    equivalent longer key; for example, if A is a 64-bit key, then AA,
437   *    AAA, etc., are equivalent keys.)
438   * 3. Encrypt the all-zero string with the Blowfish algorithm, using the

439   *    subkeys described in steps (1) and (2).
440   * 4. Replace P1 and P2 with the output of step (3).
441   * 5. Encrypt the output of step (3) using the Blowfish algorithm with the
442   *    modified subkeys.
443   * 6. Replace P3 and P4 with the output of step (5).
444   * 7. Continue the process, replacing all entries of the P array, and then all
445   *    four S-boxes in order, with the output of the continuously changing
446   *    Blowfish algorithm.
447   * In total, 521 iterations are required to generate all required subkeys.
448   * Applications can store the subkeys rather than execute this derivation
449   * process multiple times.
450   *
451   * Долго пытался понять правильную последовательность генерации ключей,
452   * в итоге посмотрел как сделано в PHP реализации Crypt_Blowfish (PEAR)
453   * и разобрался.
454   * @param {string} key ключ
455   */
456  generateSubkeys: function(key) {
457    var data = 0;
458    var k = 0;
459    var i, j;
460
461    for (i = 0; i < 18; i++) {
462      for (j = 4; j > 0; j--) {

463        data = this.fixNegative(data << 8 | key.charCodeAt(k));
464        k = (k + 1) % key.length;
465      }
466      this.pArray[i] = this.xor(this.pArray[i], data);
467      data = 0;
468    }
469
470    //var block64 = num2block32(0) + num2block32(0);
471    var block64 = [0, 0];
472    for (i = 0; i < 18; i += 2) {
473      block64 = this.encipher(block64[0], block64[1]);
474      this.pArray[i] = block64[0];
475      this.pArray[i + 1] = block64[1];
476    }
477
478    for (i = 0; i < 256; i += 2) {
479      block64 = this.encipher(block64[0], block64[1]);
480      this.sBox0[i] = block64[0];
481      this.sBox0[i + 1] = block64[1];
482    }
483
484    for (i = 0; i < 256; i += 2) {
485      block64 = this.encipher(block64[0], block64[1]);
486      this.sBox1[i] = block64[0];
487      this.sBox1[i + 1] = block64[1];
488    }
489
490    for (i = 0; i < 256; i += 2) {
491      block64 = this.encipher(block64[0], block64[1]);
492      this.sBox2[i] = block64[0];
493      this.sBox2[i + 1] = block64[1];
494    }
495
496    for (i = 0; i < 256; i += 2) {
497      block64 = this.encipher(block64[0], block64[1]);
498      this.sBox3[i] = block64[0];
499      this.sBox3[i + 1] = block64[1];
500    }
501
502  },
503
504  /**
505   * Преобразует 4х байтную строку, в 32битное целое число
506   * @param {string} block32
507   * @return {int}
508   */
509  block32toNum: function(block32) {
510    return this.fixNegative(
511      block32.charCodeAt(0) << 24 |
512      block32.charCodeAt(1) << 16 |
513      block32.charCodeAt(2) << 8 |
514      block32.charCodeAt(3)
515      );
516  },
517
518  /**
519   * Преобразует 32битное число в строку (4 байта)
520   * @param {int} num 32 битное число
521   * @return {string} 4х-байтная строка
522   */
523  num2block32: function(num) {
524    return String.fromCharCode(num >>> 24) +
525    String.fromCharCode(num << 8 >>> 24) +
526    String.fromCharCode(num << 16 >>> 24) +
527    String.fromCharCode(num << 24 >>> 24);
528  },
529
530  /**
531   * Операция XOR
532   * @param {int} a
533   * @param {int} b
534   * @return {int}
535   */
536  xor: function(a, b) {
537    return this.fixNegative(a ^ b);
538  },
539
540  /**
541   * Сложение по модулю 2^32
542   * Складываем 2 числа и отрбрасываем все разряды больше 32
543   * @param {int} a
544   * @param {int} b
545   * @return {int}
546   */
547  addMod32: function(a, b) {
548    return this.fixNegative((a + b) | 0);  // | 0 приводит к 32битному значению
549  },
550
551  /**
552   * Преобразование signed int в unsigned int
553   * после побитовых операций javascript возвращает знаковое число
554   * However, for octet-data processing (eg, network stream, etc), usually
555   * want the "unsigned int" representation. This can be accomplished by
556   * adding a ">>> 0" (zero-fill right-shift) operator which internally tells
557   * Javascript to treat this as unsigned.
558   * @param {int} number целое число со знаком
559   * @return {int} целое число без знака
560   */
561  fixNegative: function(number) {
562    return number >>> 0;
563  },
564
565  /**
566   * Разделим 64 битный блок на два 32-битных
567   * @param {string} block64 блок, состоящий из 64 бит (8 байт)
568   * @return {Array} [xL, xR]
569   */
570  split64by32: function (block64) {
571    var xL = block64.substring(0, 4);
572    var xR = block64.substring(4, 8);
573
574    return [this.block32toNum(xL) , this.block32toNum(xR)];
575  },
576
577  /**
578   * Преобразует строку в последовательность байтов utf8
579   * на один символ может приходится больше одного байта
580   * Взял этот метод из библиотеки base64:
581   * http://www.webtoolkit.info/javascript-base64.html
582   */
583  utf8Decode: function(string) {
584    var utftext = "";
585    for (var n = 0; n < string.length; n++) {
586      var c = string.charCodeAt(n);
587      if (c < 128) {
588        utftext += String.fromCharCode(c);
589      } else if (c > 127 && c < 2048) {
590        utftext += String.fromCharCode(c >> 6 | 192);
591        utftext += String.fromCharCode(c & 63 | 128);
592      } else {
593        utftext += String.fromCharCode(c >> 12 | 224);
594        utftext += String.fromCharCode(c >> 6 & 63 | 128);
595        utftext += String.fromCharCode(c & 63 | 128);
596      }
597    }
598    return utftext;
599  },
600
601  /**
602   * Преобразует байтовую-строку utf8 в строку javascript
603   */
604  utf8Encode: function (utftext) {
605    var string = "";
606    var i = 0;
607    var c = 0;
608    var c1 = 0;
609    var c2 = 0;
610
611    while ( i < utftext.length ) {
612
613      c = utftext.charCodeAt(i);
614
615      if (c < 128) {

616        string += String.fromCharCode(c);
617        i++;
618      } else if((c > 191) && (c < 224)) {
619        c1 = utftext.charCodeAt(i+1);
620        string += String.fromCharCode(((c & 31) << 6) | (c1 & 63));
621        i += 2;
622      } else {
623        c1 = utftext.charCodeAt(i+1);
624        c2 = utftext.charCodeAt(i+2);
625        string += String.fromCharCode(((c & 15) << 12) | ((c1 & 63) << 6) | (c2 & 63));
626        i += 3;
627      }
628
629    }
630
631    return string;
632  },
633
634  /**
635   * Кодирует строку в base64
636   * @param {string} input
637   * @return {string}
638   */
639  base64Encode : function (input) {
640    var output = "";
641    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
642    var i = 0;
643
644    //input = this.utf8Encode(input);
645
646    while (i < input.length) {
647      chr1 = input.charCodeAt(i++);
648      chr2 = input.charCodeAt(i++);
649      chr3 = input.charCodeAt(i++);
650
651      enc1 = chr1 >> 2;
652      enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
653      enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
654      enc4 = chr3 & 63;
655
656      if (isNaN(chr2)) {
657        enc3 = enc4 = 64;
658      } else if (isNaN(chr3)) {
659        enc4 = 64;
660      }
661
662      output = output +
663        this.keyStr.charAt(enc1) + this.keyStr.charAt(enc2) +
664        this.keyStr.charAt(enc3) + this.keyStr.charAt(enc4);
665    }
666
667    return output;
668  },
669
670  /**
671   * Раскодирует строку из base64
672   * @param {string} input
673   * @return {string}
674   */
675  base64Decode : function (input) {
676    var output = "";
677    var chr1, chr2, chr3;
678    var enc1, enc2, enc3, enc4;
679    var i = 0;
680
681    input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
682
683    while (i < input.length) {
684
685      enc1 = this.keyStr.indexOf(input.charAt(i++));
686      enc2 = this.keyStr.indexOf(input.charAt(i++));
687      enc3 = this.keyStr.indexOf(input.charAt(i++));
688      enc4 = this.keyStr.indexOf(input.charAt(i++));
689
690      chr1 = (enc1 << 2) | (enc2 >> 4);
691      chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
692      chr3 = ((enc3 & 3) << 6) | enc4;
693
694      output = output + String.fromCharCode(chr1);
695
696      if (enc3 != 64) {
697        output = output + String.fromCharCode(chr2);
698      }
699      if (enc4 != 64) {
700        output = output + String.fromCharCode(chr3);
701      }
702
703    }
704
705    //output = this.utf8Decode(output);
706
707    return output;
708  },
709
710  /**
711   * Удаляет символы \0 в конце строки
712   * @param {string} input
713   * @return {string}
714   */
715  trimZeros: function(input) {
716    return input.replace(/\0+$/g, "");
717  }
718}
719
720/**
721 * @static
722 * @type {Array}
723 */
724Blowfish.pArray = [
725  0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
726  0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
727  0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b
728];
729
730/**
731 * @static
732 * @type {Array}
733 */
734Blowfish.sBox0 = [
735  0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
736  0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
737  0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658,
738  0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
739  0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e,
740  0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
741  0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6,
742  0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
743  0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c,
744  0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
745  0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1,
746  0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
747  0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a,
748  0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
749  0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176,
750  0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
751  0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706,
752  0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
753  0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b,
754  0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
755  0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c,
756  0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
757  0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a,

758  0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
759  0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760,
760  0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
761  0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8,
762  0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
763  0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33,
764  0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
765  0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0,
766  0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
767  0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777,
768  0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
769  0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705,
770  0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
771  0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e,
772  0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
773  0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9,
774  0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
775  0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f,
776  0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
777  0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
778];
779
780/**
781 * @static
782 * @type {Array}
783 */
784Blowfish.sBox1 = [
785  0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d,
786  0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
787  0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65,
788  0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
789  0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9,
790  0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
791  0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d,
792  0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
793  0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc,
794  0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
795  0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908,
796  0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
797  0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124,
798  0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
799  0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908,
800  0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
801  0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b,
802  0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
803  0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa,
804  0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
805  0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d,
806  0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
807  0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5,
808  0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
809  0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96,
810  0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
811  0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca,
812  0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
813  0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77,
814  0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
815  0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054,
816  0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
817  0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea,
818  0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
819  0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646,
820  0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
821  0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea,
822  0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
823  0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e,
824  0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
825  0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd,
826  0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
827  0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
828];
829
830/**
831 * @static
832 * @type {Array}
833 */
834Blowfish.sBox2 = [
835  0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7,
836  0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,

837  0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af,
838  0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
839  0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4,
840  0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
841  0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec,
842  0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
843  0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332,
844  0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
845  0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58,
846  0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
847  0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22,
848  0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
849  0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60,
850  0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
851  0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99,
852  0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
853  0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74,
854  0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
855  0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3,
856  0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
857  0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
858  0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
859  0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa,
860  0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
861  0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086,
862  0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
863  0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24,
864  0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
865  0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84,
866  0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
867  0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
868  0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
869  0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe,
870  0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
871  0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0,
872  0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
873  0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188,
874  0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
875  0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8,
876  0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
877  0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
878];
879
880/**
881 * @static
882 * @type {Array}
883 */
884Blowfish.sBox3 = [

884
885  0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742,
886  0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
887  0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79,
888  0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
889  0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a,
890  0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
891  0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1,
892  0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
893  0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797,
894  0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
895  0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6,
896  0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
897  0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba,
898  0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
899  0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5,
900  0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
901  0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce,
902  0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
903  0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd,
904  0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
905  0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb,
906  0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
907  0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc,
908  0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
909  0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc,
910  0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
911  0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a,
912  0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
913  0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a,
914  0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
915  0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b,
916  0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
917  0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e,
918  0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
919  0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623,
920  0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
921  0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a,
922  0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
923  0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3,
924  0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
925  0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c,
926  0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
927  0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6

927
928];