开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
css-auth.c
资源名称：cssdvd.zip　[点击查看]
上传用户：lsh121205
上传日期：2007-01-08
资源大小：25k
文件大小：14k
源码类别：

DVD

开发平台：

C/C++

css-auth.c：源码内容
  1. /*
  2.  * Copyright (C) 1999 Derek Fawcus <derek@spider.com>
  3.  *
  4.  * This code may be used under the terms of Version 2 of the GPL,
  5.  * read the file COPYING for details.
  6.  *
  7.  */
  9. /*
  10.  * These routines do some reordering of the supplied data before
  11.  * calling engine() to do the main work.
  12.  *
  13.  * The reordering seems similar to that done by the initial stages of
  14.  * the DES algorithm, in that it looks like it's just been done to
  15.  * try and make software decoding slower.  I'm not sure that it
  16.  * actually adds anything to the security.
  17.  *
  18.  * The nature of the shuffling is that the bits of the supplied
  19.  * parameter 'varient' are reorganised (and some inverted),  and
  20.  * the bytes of the parameter 'challenge' are reorganised.
  21.  *
  22.  * The reorganisation in each routine is different,  and the first
  23.  * (CryptKey1) does not bother of play with the 'varient' parameter.
  24.  *
  25.  * Since this code is only run once per disk change,  I've made the
  26.  * code table driven in order to improve readability.
  27.  *
  28.  * Since these routines are so similar to each other,  one could even
  29.  * abstract them all to one routine supplied a parameter determining
  30.  * the nature of the reordering it has to do.
  31.  */
  33. #include "css-auth.h"
  35. typedef unsigned long u32;
  37. static void engine(int varient, byte const *input, struct block *output);
  39. void CryptKey1(int varient, byte const *challenge, struct block *key)
  40. {
  41. static byte perm_challenge[] = {1,3,0,7,5, 2,9,6,4,8};
  43. byte scratch[10];
  44. int i;
  46. for (i = 9; i >= 0; --i)
  47. scratch[i] = challenge[perm_challenge[i]];
  49. engine(varient, scratch, key);
  50. }
  52. /* This shuffles the bits in varient to make perm_varient such that
  53.  *                4 -> !3
  54.  *                3 ->  4
  55.  * varient bits:  2 ->  0  perm_varient bits
  56.  *                1 ->  2
  57.  *                0 -> !1
  58.  */
  59. void CryptKey2(int varient, byte const *challenge, struct block *key)
  60. {
  61. static byte perm_challenge[] = {6,1,9,3,8, 5,7,4,0,2};
  63. static byte perm_varient[] = {
  64. 0x0a, 0x08, 0x0e, 0x0c, 0x0b, 0x09, 0x0f, 0x0d,
  65. 0x1a, 0x18, 0x1e, 0x1c, 0x1b, 0x19, 0x1f, 0x1d,
  66. 0x02, 0x00, 0x06, 0x04, 0x03, 0x01, 0x07, 0x05,
  67. 0x12, 0x10, 0x16, 0x14, 0x13, 0x11, 0x17, 0x15};
  69. byte scratch[10];
  70. int i;
  72. for (i = 9; i >= 0; --i)
  73. scratch[i] = challenge[perm_challenge[i]];
  75. engine(perm_varient[varient], scratch, key);
  76. }
  78. /* This shuffles the bits in varient to make perm_varient such that
  79.  *                4 ->  0
  80.  *                3 -> !1
  81.  * varient bits:  2 -> !4  perm_varient bits
  82.  *                1 ->  2
  83.  *                0 ->  3
  84.  */
  85. void CryptBusKey(int varient, byte const *challenge, struct block *key)
  86. {
  87. static byte perm_challenge[] = {4,0,3,5,7, 2,8,6,1,9};
  88. static byte perm_varient[] = {
  89. 0x12, 0x1a, 0x16, 0x1e, 0x02, 0x0a, 0x06, 0x0e,
  90. 0x10, 0x18, 0x14, 0x1c, 0x00, 0x08, 0x04, 0x0c,
  91. 0x13, 0x1b, 0x17, 0x1f, 0x03, 0x0b, 0x07, 0x0f,
  92. 0x11, 0x19, 0x15, 0x1d, 0x01, 0x09, 0x05, 0x0d};
  94. byte scratch[10];
  95. int i;
  97. for (i = 9; i >= 0; --i)
  98. scratch[i] = challenge[perm_challenge[i]];
  100. engine(perm_varient[varient], scratch, key);
  101. }
  103. /*
  104.  * We use two LFSR's (seeded from some of the input data bytes) to
  105.  * generate two streams of pseudo-random bits.  These two bit streams
  106.  * are then combined by simply adding with carry to generate a final
  107.  * sequence of pseudo-random bits which is stored in the buffer that
  108.  * 'output' points to the end of - len is the size of this buffer.
  109.  *
  110.  * The first LFSR is of degree 25,  and has a polynomial of:
  111.  * x^13 + x^5 + x^4 + x^1 + 1
  112.  *
  113.  * The second LSFR is of degree 17,  and has a (primitive) polynomial of:
  114.  * x^15 + x^1 + 1
  115.  *
  116.  * I don't know if these polynomials are primitive modulo 2,  and thus
  117.  * represent maximal-period LFSR's.
  118.  *
  119.  *
  120.  * Note that we take the output of each LFSR from the new shifted in
  121.  * bit,  not the old shifted out bit.  Thus for ease of use the LFSR's
  122.  * are implemented in bit reversed order.
  123.  *
  124.  */
  125. static void generate_bits(byte *output, int len, struct block const *s)
  126. {
  127. u32 lfsr0, lfsr1;
  128. byte carry;
  130. /* In order to ensure that the LFSR works we need to ensure that the
  131.  * initial values are non-zero.  Thus when we initialise them from
  132.  * the seed,  we ensure that a bit is set.
  133.  */
  134. lfsr0 = (s->b[0] << 17) | (s->b[1] << 9) | ((s->b[2] & ~7) << 1) | 8 | (s->b[2] & 7);
  135. lfsr1 = (s->b[3] << 9) | 0x100 | s->b[4];
  137. ++output;
  139. carry = 0;
  140. do {
  141. int bit;
  142. byte val;
  144. for (bit = 0, val = 0; bit < 8; ++bit) {
  145. byte o_lfsr0, o_lfsr1; /* Actually only 1 bit each */
  146. byte combined;
  148. o_lfsr0 = ((lfsr0 >> 24) ^ (lfsr0 >> 21) ^ (lfsr0 >> 20) ^ (lfsr0 >> 12)) & 1;
  149.   lfsr0 = (lfsr0 << 1) | o_lfsr0;
  151. o_lfsr1 = ((lfsr1 >> 16) ^ (lfsr1 >> 2)) & 1;
  152.   lfsr1 = (lfsr1 << 1) | o_lfsr1;
  154. #define  BIT0(x) ((x) & 1)
  155. #define  BIT1(x) (((x) >> 1) & 1)
  157. combined = !o_lfsr1 + carry + !o_lfsr0;
  158. carry = BIT1(combined);
  159. val |= BIT0(combined) << bit;
  160. }
  162. *--output = val;
  163. } while (--len > 0);
  164. }
  166. static byte Secret[];
  167. static byte Varients[];
  168. static byte Table0[];
  169. static byte Table1[];
  170. static byte Table2[];
  171. static byte Table3[];
  173. /*
  174.  * This encryption engine implements one of 32 variations
  175.  * one the same theme depending upon the choice in the
  176.  * varient parameter (0 - 31).
  177.  *
  178.  * The algorithm itself manipulates a 40 bit input into
  179.  * a 40 bit output.
  180.  * The parameter 'input' is 80 bits.  It consists of
  181.  * the 40 bit input value that is to be encrypted followed
  182.  * by a 40 bit seed value for the pseudo random number
  183.  * generators.
  184.  */
  185. static void engine(int varient, byte const *input, struct block *output)
  186. {
  187. byte cse, term, index;
  188. struct block temp1;
  189. struct block temp2;
  190. byte bits[30];
  192. int i;
  194. /* Feed the secret into the input values such that
  195.  * we alter the seed to the LFSR's used above,  then
  196.  * generate the bits to play with.
  197.  */
  198. for (i = 5; --i >= 0; )
  199. temp1.b[i] = input[5 + i] ^ Secret[i] ^ Table2[i];
  201. generate_bits(&bits[29], sizeof bits, &temp1);
  203. /* This term is used throughout the following to
  204.  * select one of 32 different variations on the
  205.  * algorithm.
  206.  */
  207. cse = Varients[varient] ^ Table2[varient];
  209. /* Now the actual blocks doing the encryption.  Each
  210.  * of these works on 40 bits at a time and are quite
  211.  * similar.
  212.  */
  213. for (i = 5, term = 0; --i >= 0; term = input[i]) {
  214. index = bits[25 + i] ^ input[i];
  215. index = Table1[index] ^ ~Table2[index] ^ cse;
  217. temp1.b[i] = Table2[index] ^ Table3[index] ^ term;
  218. }
  219. temp1.b[4] ^= temp1.b[0];
  221. for (i = 5, term = 0; --i >= 0; term = temp1.b[i]) {
  222. index = bits[20 + i] ^ temp1.b[i];
  223. index = Table1[index] ^ ~Table2[index] ^ cse;
  225. temp2.b[i] = Table2[index] ^ Table3[index] ^ term;
  226. }
  227. temp2.b[4] ^= temp2.b[0];
  229. for (i = 5, term = 0; --i >= 0; term = temp2.b[i]) {
  230. index = bits[15 + i] ^ temp2.b[i];
  231. index = Table1[index] ^ ~Table2[index] ^ cse;
  232. index = Table2[index] ^ Table3[index] ^ term;
  234. temp1.b[i] = Table0[index] ^ Table2[index];
  235. }
  236. temp1.b[4] ^= temp1.b[0];
  238. for (i = 5, term = 0; --i >= 0; term = temp1.b[i]) {
  239. index = bits[10 + i] ^ temp1.b[i];
  240. index = Table1[index] ^ ~Table2[index] ^ cse;
  242. index = Table2[index] ^ Table3[index] ^ term;
  244. temp2.b[i] = Table0[index] ^ Table2[index];
  245. }
  246. temp2.b[4] ^= temp2.b[0];
  248. for (i = 5, term = 0; --i >= 0; term = temp2.b[i]) {
  249. index = bits[5 + i] ^ temp2.b[i];
  250. index = Table1[index] ^ ~Table2[index] ^ cse;
  252. temp1.b[i] = Table2[index] ^ Table3[index] ^ term;
  253. }
  254. temp1.b[4] ^= temp1.b[0];
  256. for (i = 5, term = 0; --i >= 0; term = temp1.b[i]) {
  257. index = bits[i] ^ temp1.b[i];
  258. index = Table1[index] ^ ~Table2[index] ^ cse;
  260. output->b[i] = Table2[index] ^ Table3[index] ^ term;
  261. }
  262. }
  264. static byte Varients[] = {
  265. 0xB7, 0x74, 0x85, 0xD0, 0xCC, 0xDB, 0xCA, 0x73,
  266. 0x03, 0xFE, 0x31, 0x03, 0x52, 0xE0, 0xB7, 0x42,
  267. 0x63, 0x16, 0xF2, 0x2A, 0x79, 0x52, 0xFF, 0x1B,
  268. 0x7A, 0x11, 0xCA, 0x1A, 0x9B, 0x40, 0xAD, 0x01};
  270. static byte Secret[] = {0x55, 0xD6, 0xC4, 0xC5, 0x28};
  272. static byte Table0[] = {
  273. 0xB7, 0xF4, 0x82, 0x57, 0xDA, 0x4D, 0xDB, 0xE2,
  274. 0x2F, 0x52, 0x1A, 0xA8, 0x68, 0x5A, 0x8A, 0xFF,
  275. 0xFB, 0x0E, 0x6D, 0x35, 0xF7, 0x5C, 0x76, 0x12,
  276. 0xCE, 0x25, 0x79, 0x29, 0x39, 0x62, 0x08, 0x24,
  277. 0xA5, 0x85, 0x7B, 0x56, 0x01, 0x23, 0x68, 0xCF,
  278. 0x0A, 0xE2, 0x5A, 0xED, 0x3D, 0x59, 0xB0, 0xA9,
  279. 0xB0, 0x2C, 0xF2, 0xB8, 0xEF, 0x32, 0xA9, 0x40,
  280. 0x80, 0x71, 0xAF, 0x1E, 0xDE, 0x8F, 0x58, 0x88,
  281. 0xB8, 0x3A, 0xD0, 0xFC, 0xC4, 0x1E, 0xB5, 0xA0,
  282. 0xBB, 0x3B, 0x0F, 0x01, 0x7E, 0x1F, 0x9F, 0xD9,
  283. 0xAA, 0xB8, 0x3D, 0x9D, 0x74, 0x1E, 0x25, 0xDB,
  284. 0x37, 0x56, 0x8F, 0x16, 0xBA, 0x49, 0x2B, 0xAC,
  285. 0xD0, 0xBD, 0x95, 0x20, 0xBE, 0x7A, 0x28, 0xD0,
  286. 0x51, 0x64, 0x63, 0x1C, 0x7F, 0x66, 0x10, 0xBB,
  287. 0xC4, 0x56, 0x1A, 0x04, 0x6E, 0x0A, 0xEC, 0x9C,
  288. 0xD6, 0xE8, 0x9A, 0x7A, 0xCF, 0x8C, 0xDB, 0xB1,
  289. 0xEF, 0x71, 0xDE, 0x31, 0xFF, 0x54, 0x3E, 0x5E,
  290. 0x07, 0x69, 0x96, 0xB0, 0xCF, 0xDD, 0x9E, 0x47,
  291. 0xC7, 0x96, 0x8F, 0xE4, 0x2B, 0x59, 0xC6, 0xEE,
  292. 0xB9, 0x86, 0x9A, 0x64, 0x84, 0x72, 0xE2, 0x5B,
  293. 0xA2, 0x96, 0x58, 0x99, 0x50, 0x03, 0xF5, 0x38,
  294. 0x4D, 0x02, 0x7D, 0xE7, 0x7D, 0x75, 0xA7, 0xB8,
  295. 0x67, 0x87, 0x84, 0x3F, 0x1D, 0x11, 0xE5, 0xFC,
  296. 0x1E, 0xD3, 0x83, 0x16, 0xA5, 0x29, 0xF6, 0xC7,
  297. 0x15, 0x61, 0x29, 0x1A, 0x43, 0x4F, 0x9B, 0xAF,
  298. 0xC5, 0x87, 0x34, 0x6C, 0x0F, 0x3B, 0xA8, 0x1D,
  299. 0x45, 0x58, 0x25, 0xDC, 0xA8, 0xA3, 0x3B, 0xD1,
  300. 0x79, 0x1B, 0x48, 0xF2, 0xE9, 0x93, 0x1F, 0xFC,
  301. 0xDB, 0x2A, 0x90, 0xA9, 0x8A, 0x3D, 0x39, 0x18,
  302. 0xA3, 0x8E, 0x58, 0x6C, 0xE0, 0x12, 0xBB, 0x25,
  303. 0xCD, 0x71, 0x22, 0xA2, 0x64, 0xC6, 0xE7, 0xFB,
  304. 0xAD, 0x94, 0x77, 0x04, 0x9A, 0x39, 0xCF, 0x7C};
  306. static byte Table1[] = {
  307. 0x8C, 0x47, 0xB0, 0xE1, 0xEB, 0xFC, 0xEB, 0x56,
  308. 0x10, 0xE5, 0x2C, 0x1A, 0x5D, 0xEF, 0xBE, 0x4F,
  309. 0x08, 0x75, 0x97, 0x4B, 0x0E, 0x25, 0x8E, 0x6E,
  310. 0x39, 0x5A, 0x87, 0x53, 0xC4, 0x1F, 0xF4, 0x5C,
  311. 0x4E, 0xE6, 0x99, 0x30, 0xE0, 0x42, 0x88, 0xAB,
  312. 0xE5, 0x85, 0xBC, 0x8F, 0xD8, 0x3C, 0x54, 0xC9,
  313. 0x53, 0x47, 0x18, 0xD6, 0x06, 0x5B, 0x41, 0x2C,
  314. 0x67, 0x1E, 0x41, 0x74, 0x33, 0xE2, 0xB4, 0xE0,
  315. 0x23, 0x29, 0x42, 0xEA, 0x55, 0x0F, 0x25, 0xB4,
  316. 0x24, 0x2C, 0x99, 0x13, 0xEB, 0x0A, 0x0B, 0xC9,
  317. 0xF9, 0x63, 0x67, 0x43, 0x2D, 0xC7, 0x7D, 0x07,
  318. 0x60, 0x89, 0xD1, 0xCC, 0xE7, 0x94, 0x77, 0x74,
  319. 0x9B, 0x7E, 0xD7, 0xE6, 0xFF, 0xBB, 0x68, 0x14,
  320. 0x1E, 0xA3, 0x25, 0xDE, 0x3A, 0xA3, 0x54, 0x7B,
  321. 0x87, 0x9D, 0x50, 0xCA, 0x27, 0xC3, 0xA4, 0x50,
  322. 0x91, 0x27, 0xD4, 0xB0, 0x82, 0x41, 0x97, 0x79,
  323. 0x94, 0x82, 0xAC, 0xC7, 0x8E, 0xA5, 0x4E, 0xAA,
  324. 0x78, 0x9E, 0xE0, 0x42, 0xBA, 0x28, 0xEA, 0xB7,
  325. 0x74, 0xAD, 0x35, 0xDA, 0x92, 0x60, 0x7E, 0xD2,
  326. 0x0E, 0xB9, 0x24, 0x5E, 0x39, 0x4F, 0x5E, 0x63,
  327. 0x09, 0xB5, 0xFA, 0xBF, 0xF1, 0x22, 0x55, 0x1C,
  328. 0xE2, 0x25, 0xDB, 0xC5, 0xD8, 0x50, 0x03, 0x98,
  329. 0xC4, 0xAC, 0x2E, 0x11, 0xB4, 0x38, 0x4D, 0xD0,
  330. 0xB9, 0xFC, 0x2D, 0x3C, 0x08, 0x04, 0x5A, 0xEF,
  331. 0xCE, 0x32, 0xFB, 0x4C, 0x92, 0x1E, 0x4B, 0xFB,
  332. 0x1A, 0xD0, 0xE2, 0x3E, 0xDA, 0x6E, 0x7C, 0x4D,
  333. 0x56, 0xC3, 0x3F, 0x42, 0xB1, 0x3A, 0x23, 0x4D,
  334. 0x6E, 0x84, 0x56, 0x68, 0xF4, 0x0E, 0x03, 0x64,
  335. 0xD0, 0xA9, 0x92, 0x2F, 0x8B, 0xBC, 0x39, 0x9C,
  336. 0xAC, 0x09, 0x5E, 0xEE, 0xE5, 0x97, 0xBF, 0xA5,
  337. 0xCE, 0xFA, 0x28, 0x2C, 0x6D, 0x4F, 0xEF, 0x77,
  338. 0xAA, 0x1B, 0x79, 0x8E, 0x97, 0xB4, 0xC3, 0xF4};
  340. static byte Table2[] = {
  341. 0xB7, 0x75, 0x81, 0xD5, 0xDC, 0xCA, 0xDE, 0x66,
  342. 0x23, 0xDF, 0x15, 0x26, 0x62, 0xD1, 0x83, 0x77,
  343. 0xE3, 0x97, 0x76, 0xAF, 0xE9, 0xC3, 0x6B, 0x8E,
  344. 0xDA, 0xB0, 0x6E, 0xBF, 0x2B, 0xF1, 0x19, 0xB4,
  345. 0x95, 0x34, 0x48, 0xE4, 0x37, 0x94, 0x5D, 0x7B,
  346. 0x36, 0x5F, 0x65, 0x53, 0x07, 0xE2, 0x89, 0x11,
  347. 0x98, 0x85, 0xD9, 0x12, 0xC1, 0x9D, 0x84, 0xEC,
  348. 0xA4, 0xD4, 0x88, 0xB8, 0xFC, 0x2C, 0x79, 0x28,
  349. 0xD8, 0xDB, 0xB3, 0x1E, 0xA2, 0xF9, 0xD0, 0x44,
  350. 0xD7, 0xD6, 0x60, 0xEF, 0x14, 0xF4, 0xF6, 0x31,
  351. 0xD2, 0x41, 0x46, 0x67, 0x0A, 0xE1, 0x58, 0x27,
  352. 0x43, 0xA3, 0xF8, 0xE0, 0xC8, 0xBA, 0x5A, 0x5C,
  353. 0x80, 0x6C, 0xC6, 0xF2, 0xE8, 0xAD, 0x7D, 0x04,
  354. 0x0D, 0xB9, 0x3C, 0xC2, 0x25, 0xBD, 0x49, 0x63,
  355. 0x8C, 0x9F, 0x51, 0xCE, 0x20, 0xC5, 0xA1, 0x50,
  356. 0x92, 0x2D, 0xDD, 0xBC, 0x8D, 0x4F, 0x9A, 0x71,
  357. 0x2F, 0x30, 0x1D, 0x73, 0x39, 0x13, 0xFB, 0x1A,
  358. 0xCB, 0x24, 0x59, 0xFE, 0x05, 0x96, 0x57, 0x0F,
  359. 0x1F, 0xCF, 0x54, 0xBE, 0xF5, 0x06, 0x1B, 0xB2,
  360. 0x6D, 0xD3, 0x4D, 0x32, 0x56, 0x21, 0x33, 0x0B,
  361. 0x52, 0xE7, 0xAB, 0xEB, 0xA6, 0x74, 0x00, 0x4C,
  362. 0xB1, 0x7F, 0x82, 0x99, 0x87, 0x0E, 0x5E, 0xC0,
  363. 0x8F, 0xEE, 0x6F, 0x55, 0xF3, 0x7E, 0x08, 0x90,
  364. 0xFA, 0xB6, 0x64, 0x70, 0x47, 0x4A, 0x17, 0xA7,
  365. 0xB5, 0x40, 0x8A, 0x38, 0xE5, 0x68, 0x3E, 0x8B,
  366. 0x69, 0xAA, 0x9B, 0x42, 0xA5, 0x10, 0x01, 0x35,
  367. 0xFD, 0x61, 0x9E, 0xE6, 0x16, 0x9C, 0x86, 0xED,
  368. 0xCD, 0x2E, 0xFF, 0xC4, 0x5B, 0xA0, 0xAE, 0xCC,
  369. 0x4B, 0x3B, 0x03, 0xBB, 0x1C, 0x2A, 0xAC, 0x0C,
  370. 0x3F, 0x93, 0xC7, 0x72, 0x7A, 0x09, 0x22, 0x3D,
  371. 0x45, 0x78, 0xA9, 0xA8, 0xEA, 0xC9, 0x6A, 0xF7,
  372. 0x29, 0x91, 0xF0, 0x02, 0x18, 0x3A, 0x4E, 0x7C};
  374. static byte Table3[] = {
  375. 0x73, 0x51, 0x95, 0xE1, 0x12, 0xE4, 0xC0, 0x58,
  376. 0xEE, 0xF2, 0x08, 0x1B, 0xA9, 0xFA, 0x98, 0x4C,
  377. 0xA7, 0x33, 0xE2, 0x1B, 0xA7, 0x6D, 0xF5, 0x30,
  378. 0x97, 0x1D, 0xF3, 0x02, 0x60, 0x5A, 0x82, 0x0F,
  379. 0x91, 0xD0, 0x9C, 0x10, 0x39, 0x7A, 0x83, 0x85,
  380. 0x3B, 0xB2, 0xB8, 0xAE, 0x0C, 0x09, 0x52, 0xEA,
  381. 0x1C, 0xE1, 0x8D, 0x66, 0x4F, 0xF3, 0xDA, 0x92,
  382. 0x29, 0xB9, 0xD5, 0xC5, 0x77, 0x47, 0x22, 0x53,
  383. 0x14, 0xF7, 0xAF, 0x22, 0x64, 0xDF, 0xC6, 0x72,
  384. 0x12, 0xF3, 0x75, 0xDA, 0xD7, 0xD7, 0xE5, 0x02,
  385. 0x9E, 0xED, 0xDA, 0xDB, 0x4C, 0x47, 0xCE, 0x91,
  386. 0x06, 0x06, 0x6D, 0x55, 0x8B, 0x19, 0xC9, 0xEF,
  387. 0x8C, 0x80, 0x1A, 0x0E, 0xEE, 0x4B, 0xAB, 0xF2,
  388. 0x08, 0x5C, 0xE9, 0x37, 0x26, 0x5E, 0x9A, 0x90,
  389. 0x00, 0xF3, 0x0D, 0xB2, 0xA6, 0xA3, 0xF7, 0x26,
  390. 0x17, 0x48, 0x88, 0xC9, 0x0E, 0x2C, 0xC9, 0x02,
  391. 0xE7, 0x18, 0x05, 0x4B, 0xF3, 0x39, 0xE1, 0x20,
  392. 0x02, 0x0D, 0x40, 0xC7, 0xCA, 0xB9, 0x48, 0x30,
  393. 0x57, 0x67, 0xCC, 0x06, 0xBF, 0xAC, 0x81, 0x08,
  394. 0x24, 0x7A, 0xD4, 0x8B, 0x19, 0x8E, 0xAC, 0xB4,
  395. 0x5A, 0x0F, 0x73, 0x13, 0xAC, 0x9E, 0xDA, 0xB6,
  396. 0xB8, 0x96, 0x5B, 0x60, 0x88, 0xE1, 0x81, 0x3F,
  397. 0x07, 0x86, 0x37, 0x2D, 0x79, 0x14, 0x52, 0xEA,
  398. 0x73, 0xDF, 0x3D, 0x09, 0xC8, 0x25, 0x48, 0xD8,
  399. 0x75, 0x60, 0x9A, 0x08, 0x27, 0x4A, 0x2C, 0xB9,
  400. 0xA8, 0x8B, 0x8A, 0x73, 0x62, 0x37, 0x16, 0x02,
  401. 0xBD, 0xC1, 0x0E, 0x56, 0x54, 0x3E, 0x14, 0x5F,
  402. 0x8C, 0x8F, 0x6E, 0x75, 0x1C, 0x07, 0x39, 0x7B,
  403. 0x4B, 0xDB, 0xD3, 0x4B, 0x1E, 0xC8, 0x7E, 0xFE,
  404. 0x3E, 0x72, 0x16, 0x83, 0x7D, 0xEE, 0xF5, 0xCA,
  405. 0xC5, 0x18, 0xF9, 0xD8, 0x68, 0xAB, 0x38, 0x85,
  406. 0xA8, 0xF0, 0xA1, 0x73, 0x9F, 0x5D, 0x19, 0x0B,
  407. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  408. 0x33, 0x72, 0x39, 0x25, 0x67, 0x26, 0x6D, 0x71,
  409. 0x36, 0x77, 0x3C, 0x20, 0x62, 0x23, 0x68, 0x74,
  410. 0xC3, 0x82, 0xC9, 0x15, 0x57, 0x16, 0x5D, 0x81};