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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rijndael-api-fst.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：14k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

rijndael-api-fst.c：源码内容
  1. /*
  2.  * rijndael-api-fst.c   v2.4   April '2000
  3.  *
  4.  * Optimised ANSI C code
  5.  *
  6.  * authors: v1.0: Antoon Bosselaers
  7.  *          v2.0: Vincent Rijmen
  8.  *          v2.1: Vincent Rijmen
  9.  *          v2.2: Vincent Rijmen
  10.  *          v2.3: Paulo Barreto
  11.  *          v2.4: Vincent Rijmen
  12.  *
  13.  * This code is placed in the public domain.
  14.  */
  16. #include <assert.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  20. #include "rijndael-alg-fst.h"
  21. #include "rijndael-api-fst.h"
  23. int makeKey(keyInstance *key, BYTE direction, int keyLen, char *keyMaterial) {
  24. word8 k[MAXKC][4];
  25. int i;
  26. char *keyMat;
  28. if (key == NULL) {
  29. return BAD_KEY_INSTANCE;
  30. }
  32. if ((direction == DIR_ENCRYPT) || (direction == DIR_DECRYPT)) {
  33. key->direction = direction;
  34. } else {
  35. return BAD_KEY_DIR;
  36. }
  38. if ((keyLen == 128) || (keyLen == 192) || (keyLen == 256)) { 
  39. key->keyLen = keyLen;
  40. } else {
  41. return BAD_KEY_MAT;
  42. }
  44. if (keyMaterial != NULL) {
  45. strncpy(key->keyMaterial, keyMaterial, keyLen/4);
  46. }
  48. key->ROUNDS = keyLen/32 + 6;
  50. /* initialize key schedule: */
  51. keyMat = key->keyMaterial;
  52. #ifndef BINARY_KEY_MATERIAL
  53.   for (i = 0; i < key->keyLen/8; i++) {
  54. int t, j;
  56. t = *keyMat++;
  57. if ((t >= '0') && (t <= '9')) j = (t - '0') << 4;
  58. else if ((t >= 'a') && (t <= 'f')) j = (t - 'a' + 10) << 4; 
  59. else if ((t >= 'A') && (t <= 'F')) j = (t - 'A' + 10) << 4; 
  60. else return BAD_KEY_MAT;
  62. t = *keyMat++;
  63. if ((t >= '0') && (t <= '9')) j ^= (t - '0');
  64. else if ((t >= 'a') && (t <= 'f')) j ^= (t - 'a' + 10); 
  65. else if ((t >= 'A') && (t <= 'F')) j ^= (t - 'A' + 10); 
  66. else return BAD_KEY_MAT;
  68. k[i >> 2][i & 3] = (word8)j; 
  69. }
  70. #else
  71. for (i = 0; i < key->keyLen/8; i++) {
  72. k[i >> 2][i & 3] = (word8)keyMat[i]; 
  73. }
  74. #endif /* ?BINARY_KEY_MATERIAL */
  75. rijndaelKeySched(k, key->keySched, key->ROUNDS);
  76. if (direction == DIR_DECRYPT) {
  77. rijndaelKeyEncToDec(key->keySched, key->ROUNDS);
  78. }
  80. return TRUE;
  81. }
  83. int cipherInit(cipherInstance *cipher, BYTE mode, char *IV) {
  84. if ((mode == MODE_ECB) || (mode == MODE_CBC) || (mode == MODE_CFB1)) {
  85. cipher->mode = mode;
  86. } else {
  87. return BAD_CIPHER_MODE;
  88. }
  89. if (IV != NULL) {
  90. #ifndef BINARY_KEY_MATERIAL
  91. int i;
  92.   for (i = 0; i < MAX_IV_SIZE; i++) {
  93. int t, j;
  95. t = IV[2*i];
  96. if ((t >= '0') && (t <= '9')) j = (t - '0') << 4;
  97. else if ((t >= 'a') && (t <= 'f')) j = (t - 'a' + 10) << 4; 
  98. else if ((t >= 'A') && (t <= 'F')) j = (t - 'A' + 10) << 4; 
  99. else return BAD_CIPHER_INSTANCE;
  101. t = IV[2*i+1];
  102. if ((t >= '0') && (t <= '9')) j ^= (t - '0');
  103. else if ((t >= 'a') && (t <= 'f')) j ^= (t - 'a' + 10); 
  104. else if ((t >= 'A') && (t <= 'F')) j ^= (t - 'A' + 10); 
  105. else return BAD_CIPHER_INSTANCE;
  107. cipher->IV[i] = (word8)j;
  108. }
  109. #else
  110. memcpy(cipher->IV, IV, MAX_IV_SIZE);
  111. #endif /* ?BINARY_KEY_MATERIAL */
  112. } else {
  113. memset(cipher->IV, 0, MAX_IV_SIZE);
  114. }
  115. return TRUE;
  116. }
  118. int blockEncrypt(cipherInstance *cipher, keyInstance *key,
  119. BYTE *input, int inputLen, BYTE *outBuffer) {
  120. int i, k, numBlocks;
  121. word8 block[16], iv[4][4];
  123. if (cipher == NULL ||
  124. key == NULL ||
  125. key->direction == DIR_DECRYPT) {
  126. return BAD_CIPHER_STATE;
  127. }
  128. if (input == NULL || inputLen <= 0) {
  129. return 0; /* nothing to do */
  130. }
  132. numBlocks = inputLen/128;
  134. switch (cipher->mode) {
  135. case MODE_ECB: 
  136. for (i = numBlocks; i > 0; i--) {
  137. rijndaelEncrypt(input, outBuffer, key->keySched, key->ROUNDS);
  138. input += 16;
  139. outBuffer += 16;
  140. }
  141. break;
  143. case MODE_CBC:
  144. ((word32*)block)[0] = ((word32*)cipher->IV)[0] ^ ((word32*)input)[0];
  145. ((word32*)block)[1] = ((word32*)cipher->IV)[1] ^ ((word32*)input)[1];
  146. ((word32*)block)[2] = ((word32*)cipher->IV)[2] ^ ((word32*)input)[2];
  147. ((word32*)block)[3] = ((word32*)cipher->IV)[3] ^ ((word32*)input)[3];
  148. rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
  149. input += 16;
  150. for (i = numBlocks - 1; i > 0; i--) {
  151. ((word32*)block)[0] = ((word32*)outBuffer)[0] ^ ((word32*)input)[0];
  152. ((word32*)block)[1] = ((word32*)outBuffer)[1] ^ ((word32*)input)[1];
  153. ((word32*)block)[2] = ((word32*)outBuffer)[2] ^ ((word32*)input)[2];
  154. ((word32*)block)[3] = ((word32*)outBuffer)[3] ^ ((word32*)input)[3];
  155. outBuffer += 16;
  156. rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
  157. input += 16;
  158. }
  159. break;
  161. case MODE_CFB1:
  162. #if STRICT_ALIGN 
  163. memcpy(iv, cipher->IV, 16); 
  164. #else  /* !STRICT_ALIGN */
  165. *((word32*)iv[0]) = *((word32*)(cipher->IV   ));
  166. *((word32*)iv[1]) = *((word32*)(cipher->IV+ 4));
  167. *((word32*)iv[2]) = *((word32*)(cipher->IV+ 8));
  168. *((word32*)iv[3]) = *((word32*)(cipher->IV+12));
  169. #endif /* ?STRICT_ALIGN */
  170. for (i = numBlocks; i > 0; i--) {
  171. for (k = 0; k < 128; k++) {
  172. *((word32*) block    ) = *((word32*)iv[0]);
  173. *((word32*)(block+ 4)) = *((word32*)iv[1]);
  174. *((word32*)(block+ 8)) = *((word32*)iv[2]);
  175. *((word32*)(block+12)) = *((word32*)iv[3]);
  176. rijndaelEncrypt(block, block, key->keySched, key->ROUNDS);
  177. outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7);
  178. iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7);
  179. iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7);
  180. iv[0][2] = (iv[0][2] << 1) | (iv[0][3] >> 7);
  181. iv[0][3] = (iv[0][3] << 1) | (iv[1][0] >> 7);
  182. iv[1][0] = (iv[1][0] << 1) | (iv[1][1] >> 7);
  183. iv[1][1] = (iv[1][1] << 1) | (iv[1][2] >> 7);
  184. iv[1][2] = (iv[1][2] << 1) | (iv[1][3] >> 7);
  185. iv[1][3] = (iv[1][3] << 1) | (iv[2][0] >> 7);
  186. iv[2][0] = (iv[2][0] << 1) | (iv[2][1] >> 7);
  187. iv[2][1] = (iv[2][1] << 1) | (iv[2][2] >> 7);
  188. iv[2][2] = (iv[2][2] << 1) | (iv[2][3] >> 7);
  189. iv[2][3] = (iv[2][3] << 1) | (iv[3][0] >> 7);
  190. iv[3][0] = (iv[3][0] << 1) | (iv[3][1] >> 7);
  191. iv[3][1] = (iv[3][1] << 1) | (iv[3][2] >> 7);
  192. iv[3][2] = (iv[3][2] << 1) | (iv[3][3] >> 7);
  193. iv[3][3] = (iv[3][3] << 1) | ((outBuffer[k/8] >> (7-(k&7))) & 1);
  194. }
  195. }
  196. break;
  198. default:
  199. return BAD_CIPHER_STATE;
  200. }
  202. return 128*numBlocks;
  203. }
  205. /**
  206.  * Encrypt data partitioned in octets, using RFC 2040-like padding.
  207.  *
  208.  * @param   input           data to be encrypted (octet sequence)
  209.  * @param   inputOctets input length in octets (not bits)
  210.  * @param   outBuffer       encrypted output data
  211.  *
  212.  * @return length in octets (not bits) of the encrypted output buffer.
  213.  */
  214. int padEncrypt(cipherInstance *cipher, keyInstance *key,
  215. BYTE *input, int inputOctets, BYTE *outBuffer) {
  216. int i, numBlocks, padLen;
  217. word8 block[16], *iv;
  219. if (cipher == NULL ||
  220. key == NULL ||
  221. key->direction == DIR_DECRYPT) {
  222. return BAD_CIPHER_STATE;
  223. }
  224. if (input == NULL || inputOctets <= 0) {
  225. return 0; /* nothing to do */
  226. }
  228. numBlocks = inputOctets/16;
  230. switch (cipher->mode) {
  231. case MODE_ECB: 
  232. for (i = numBlocks; i > 0; i--) {
  233. rijndaelEncrypt(input, outBuffer, key->keySched, key->ROUNDS);
  234. input += 16;
  235. outBuffer += 16;
  236. }
  237. padLen = 16 - (inputOctets - 16*numBlocks);
  238. assert(padLen > 0 && padLen <= 16);
  239. memcpy(block, input, 16 - padLen);
  240. memset(block + 16 - padLen, padLen, padLen);
  241. rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
  242. break;
  244. case MODE_CBC:
  245. iv = cipher->IV;
  246. for (i = numBlocks; i > 0; i--) {
  247. ((word32*)block)[0] = ((word32*)input)[0] ^ ((word32*)iv)[0];
  248. ((word32*)block)[1] = ((word32*)input)[1] ^ ((word32*)iv)[1];
  249. ((word32*)block)[2] = ((word32*)input)[2] ^ ((word32*)iv)[2];
  250. ((word32*)block)[3] = ((word32*)input)[3] ^ ((word32*)iv)[3];
  251. rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
  252. iv = outBuffer;
  253. input += 16;
  254. outBuffer += 16;
  255. }
  256. padLen = 16 - (inputOctets - 16*numBlocks);
  257. assert(padLen > 0 && padLen <= 16);
  258. for (i = 0; i < 16 - padLen; i++) {
  259. block[i] = input[i] ^ iv[i];
  260. }
  261. for (i = 16 - padLen; i < 16; i++) {
  262. block[i] = (BYTE)padLen ^ iv[i];
  263. }
  264. rijndaelEncrypt(block, outBuffer, key->keySched, key->ROUNDS);
  265. break;
  267. default:
  268. return BAD_CIPHER_STATE;
  269. }
  271. return 16*(numBlocks + 1);
  272. }
  274. int blockDecrypt(cipherInstance *cipher, keyInstance *key,
  275. BYTE *input, int inputLen, BYTE *outBuffer) {
  276. int i, k, numBlocks;
  277. word8 block[16], iv[4][4];
  279. if (cipher == NULL ||
  280. key == NULL ||
  281. (cipher->mode != MODE_CFB1 && key->direction == DIR_ENCRYPT)) {
  282. return BAD_CIPHER_STATE;
  283. }
  284. if (input == NULL || inputLen <= 0) {
  285. return 0; /* nothing to do */
  286. }
  288. numBlocks = inputLen/128;
  290. switch (cipher->mode) {
  291. case MODE_ECB: 
  292. for (i = numBlocks; i > 0; i--) { 
  293. rijndaelDecrypt(input, outBuffer, key->keySched, key->ROUNDS);
  294. input += 16;
  295. outBuffer += 16;
  296. }
  297. break;
  299. case MODE_CBC:
  300. #if STRICT_ALIGN 
  301. memcpy(iv, cipher->IV, 16); 
  302. #else
  303. *((word32*)iv[0]) = *((word32*)(cipher->IV   ));
  304. *((word32*)iv[1]) = *((word32*)(cipher->IV+ 4));
  305. *((word32*)iv[2]) = *((word32*)(cipher->IV+ 8));
  306. *((word32*)iv[3]) = *((word32*)(cipher->IV+12));
  307. #endif
  308. for (i = numBlocks; i > 0; i--) {
  309. rijndaelDecrypt(input, block, key->keySched, key->ROUNDS);
  310. ((word32*)block)[0] ^= *((word32*)iv[0]);
  311. ((word32*)block)[1] ^= *((word32*)iv[1]);
  312. ((word32*)block)[2] ^= *((word32*)iv[2]);
  313. ((word32*)block)[3] ^= *((word32*)iv[3]);
  314. #if STRICT_ALIGN
  315. memcpy(iv, input, 16);
  316. memcpy(outBuf, block, 16);
  317. #else
  318. *((word32*)iv[0]) = ((word32*)input)[0]; ((word32*)outBuffer)[0] = ((word32*)block)[0];
  319. *((word32*)iv[1]) = ((word32*)input)[1]; ((word32*)outBuffer)[1] = ((word32*)block)[1];
  320. *((word32*)iv[2]) = ((word32*)input)[2]; ((word32*)outBuffer)[2] = ((word32*)block)[2];
  321. *((word32*)iv[3]) = ((word32*)input)[3]; ((word32*)outBuffer)[3] = ((word32*)block)[3];
  322. #endif
  323. input += 16;
  324. outBuffer += 16;
  325. }
  326. break;
  328. case MODE_CFB1:
  329. #if STRICT_ALIGN 
  330. memcpy(iv, cipher->IV, 16); 
  331. #else
  332. *((word32*)iv[0]) = *((word32*)(cipher->IV));
  333. *((word32*)iv[1]) = *((word32*)(cipher->IV+ 4));
  334. *((word32*)iv[2]) = *((word32*)(cipher->IV+ 8));
  335. *((word32*)iv[3]) = *((word32*)(cipher->IV+12));
  336. #endif
  337. for (i = numBlocks; i > 0; i--) {
  338. for (k = 0; k < 128; k++) {
  339. *((word32*) block    ) = *((word32*)iv[0]);
  340. *((word32*)(block+ 4)) = *((word32*)iv[1]);
  341. *((word32*)(block+ 8)) = *((word32*)iv[2]);
  342. *((word32*)(block+12)) = *((word32*)iv[3]);
  343. rijndaelEncrypt(block, block, key->keySched, key->ROUNDS);
  344. iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7);
  345. iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7);
  346. iv[0][2] = (iv[0][2] << 1) | (iv[0][3] >> 7);
  347. iv[0][3] = (iv[0][3] << 1) | (iv[1][0] >> 7);
  348. iv[1][0] = (iv[1][0] << 1) | (iv[1][1] >> 7);
  349. iv[1][1] = (iv[1][1] << 1) | (iv[1][2] >> 7);
  350. iv[1][2] = (iv[1][2] << 1) | (iv[1][3] >> 7);
  351. iv[1][3] = (iv[1][3] << 1) | (iv[2][0] >> 7);
  352. iv[2][0] = (iv[2][0] << 1) | (iv[2][1] >> 7);
  353. iv[2][1] = (iv[2][1] << 1) | (iv[2][2] >> 7);
  354. iv[2][2] = (iv[2][2] << 1) | (iv[2][3] >> 7);
  355. iv[2][3] = (iv[2][3] << 1) | (iv[3][0] >> 7);
  356. iv[3][0] = (iv[3][0] << 1) | (iv[3][1] >> 7);
  357. iv[3][1] = (iv[3][1] << 1) | (iv[3][2] >> 7);
  358. iv[3][2] = (iv[3][2] << 1) | (iv[3][3] >> 7);
  359. iv[3][3] = (iv[3][3] << 1) | ((input[k/8] >> (7-(k&7))) & 1);
  360. outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7);
  361. }
  362. }
  363. break;
  365. default:
  366. return BAD_CIPHER_STATE;
  367. }
  369. return 128*numBlocks;
  370. }
  372. int padDecrypt(cipherInstance *cipher, keyInstance *key,
  373. BYTE *input, int inputOctets, BYTE *outBuffer) {
  374. int i, numBlocks, padLen;
  375. word8 block[16];
  376. word32 iv[4];
  378. if (cipher == NULL ||
  379. key == NULL ||
  380. key->direction == DIR_ENCRYPT) {
  381. return BAD_CIPHER_STATE;
  382. }
  383. if (input == NULL || inputOctets <= 0) {
  384. return 0; /* nothing to do */
  385. }
  386. if (inputOctets % 16 != 0) {
  387. return BAD_DATA;
  388. }
  390. numBlocks = inputOctets/16;
  392. switch (cipher->mode) {
  393. case MODE_ECB:
  394. /* all blocks but last */
  395. for (i = numBlocks - 1; i > 0; i--) { 
  396. rijndaelDecrypt(input, outBuffer, key->keySched, key->ROUNDS);
  397. input += 16;
  398. outBuffer += 16;
  399. }
  400. /* last block */
  401. rijndaelDecrypt(input, block, key->keySched, key->ROUNDS);
  402. padLen = block[15];
  403. if (padLen >= 16) {
  404. return BAD_DATA;
  405. }
  406. for (i = 16 - padLen; i < 16; i++) {
  407. if (block[i] != padLen) {
  408. return BAD_DATA;
  409. }
  410. }
  411. memcpy(outBuffer, block, 16 - padLen);
  412. break;
  414. case MODE_CBC:
  415. memcpy(iv, cipher->IV, 16);
  416. /* all blocks but last */
  417. for (i = numBlocks - 1; i > 0; i--) {
  418. rijndaelDecrypt(input, block, key->keySched, key->ROUNDS);
  419. ((word32*)block)[0] ^= iv[0];
  420. ((word32*)block)[1] ^= iv[1];
  421. ((word32*)block)[2] ^= iv[2];
  422. ((word32*)block)[3] ^= iv[3];
  423. memcpy(iv, input, 16);
  424. memcpy(outBuffer, block, 16);
  425. input += 16;
  426. outBuffer += 16;
  427. }
  428. /* last block */
  429. rijndaelDecrypt(input, block, key->keySched, key->ROUNDS);
  430. ((word32*)block)[0] ^= iv[0];
  431. ((word32*)block)[1] ^= iv[1];
  432. ((word32*)block)[2] ^= iv[2];
  433. ((word32*)block)[3] ^= iv[3];
  434. padLen = block[15];
  435. if (padLen <= 0 || padLen > 16) {
  436. return BAD_DATA;
  437. }
  438. for (i = 16 - padLen; i < 16; i++) {
  439. if (block[i] != padLen) {
  440. return BAD_DATA;
  441. }
  442. }
  443. memcpy(outBuffer, block, 16 - padLen);
  444. break;
  446. default:
  447. return BAD_CIPHER_STATE;
  448. }
  450. return 16*numBlocks - padLen;
  451. }
  453. #ifdef INTERMEDIATE_VALUE_KAT
  454. /**
  455.  * cipherUpdateRounds:
  456.  *
  457.  * Encrypts/Decrypts exactly one full block a specified number of rounds.
  458.  * Only used in the Intermediate Value Known Answer Test.
  459.  *
  460.  * Returns:
  461.  * TRUE - on success
  462.  * BAD_CIPHER_STATE - cipher in bad state (e.g., not initialized)
  463.  */
  464. int cipherUpdateRounds(cipherInstance *cipher, keyInstance *key,
  465. BYTE *input, int inputLen, BYTE *outBuffer, int rounds) {
  466. int j;
  467. word8 block[4][4];
  469. if (cipher == NULL || key == NULL) {
  470. return BAD_CIPHER_STATE;
  471. }
  473. for (j = 3; j >= 0; j--) {
  474. /* parse input stream into rectangular array */
  475.    *((word32*)block[j]) = *((word32*)(input+4*j));
  476. }
  478. switch (key->direction) {
  479. case DIR_ENCRYPT:
  480. rijndaelEncryptRound(block, key->keySched, key->ROUNDS, rounds);
  481. break;
  483. case DIR_DECRYPT:
  484. rijndaelDecryptRound(block, key->keySched, key->ROUNDS, rounds);
  485. break;
  487. default:
  488. return BAD_KEY_DIR;
  489. } 
  491. for (j = 3; j >= 0; j--) {
  492. /* parse rectangular array into output ciphertext bytes */
  493. *((word32*)(outBuffer+4*j)) = *((word32*)block[j]);
  494. }
  496. return TRUE;
  497. }
  498. #endif /* INTERMEDIATE_VALUE_KAT */