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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
DES.C
资源名称：一个类似QQ的软件源码.rar　[点击查看]
上传用户：zslianheng
上传日期：2013-04-03
资源大小：946k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Visual C++

DES.C：源码内容
  1. /* Sofware DES functions
  2.  * written 12 Dec 1986 by Phil Karn, KA9Q; large sections adapted from
  3.  * the 1977 public-domain program by Jim Gillogly
  4.  */
  5. #define NULL 0
  7. #if defined(_M_I86) || defined(WIN32)
  8. #define LITTLE_ENDIAN
  9. #include <stdlib.h> 
  10. #endif
  12. #ifdef WIN32
  13. #define CONSTANT_DATA
  14. #else
  15. #define CONSTANT_DATA __based(__segname("_CODE"))
  16. #endif
  18. //#define register
  19. //#define int short
  20. //#define PERMUTATION
  22. /* Tables defined in the Data Encryption Standard documents */
  24. #ifdef PERMUTATION
  25. /* initial permutation IP */
  26. static char CONSTANT_DATA ip[] = {
  27. 58, 50, 42, 34, 26, 18, 10,  2,
  28. 60, 52, 44, 36, 28, 20, 12,  4,
  29. 62, 54, 46, 38, 30, 22, 14,  6,
  30. 64, 56, 48, 40, 32, 24, 16,  8,
  31. 57, 49, 41, 33, 25, 17,  9,  1,
  32. 59, 51, 43, 35, 27, 19, 11,  3,
  33. 61, 53, 45, 37, 29, 21, 13,  5,
  34. 63, 55, 47, 39, 31, 23, 15,  7
  35. };
  37. /* final permutation IP^-1 */
  38. static char CONSTANT_DATA fp[] = {
  39. 40,  8, 48, 16, 56, 24, 64, 32,
  40. 39,  7, 47, 15, 55, 23, 63, 31,
  41. 38,  6, 46, 14, 54, 22, 62, 30,
  42. 37,  5, 45, 13, 53, 21, 61, 29,
  43. 36,  4, 44, 12, 52, 20, 60, 28,
  44. 35,  3, 43, 11, 51, 19, 59, 27,
  45. 34,  2, 42, 10, 50, 18, 58, 26,
  46. 33,  1, 41,  9, 49, 17, 57, 25
  47. };
  48. #endif
  50. /* expansion operation matrix
  51.  * This is for reference only; it is unused in the code
  52.  * as the f() function performs it implicitly for speed
  53.  */
  54. #ifdef notdef
  55. static char ei[] = {
  56. 32,  1,  2,  3,  4,  5,
  57.  4,  5,  6,  7,  8,  9,
  58.  8,  9, 10, 11, 12, 13,
  59. 12, 13, 14, 15, 16, 17,
  60. 16, 17, 18, 19, 20, 21,
  61. 20, 21, 22, 23, 24, 25,
  62. 24, 25, 26, 27, 28, 29,
  63. 28, 29, 30, 31, 32,  1 
  64. };
  65. #endif
  67. /* permuted choice table (key) */
  68. static char CONSTANT_DATA pc1[] = {
  69. 57, 49, 41, 33, 25, 17,  9,
  70.  1, 58, 50, 42, 34, 26, 18,
  71. 10,  2, 59, 51, 43, 35, 27,
  72. 19, 11,  3, 60, 52, 44, 36,
  74. 63, 55, 47, 39, 31, 23, 15,
  75.  7, 62, 54, 46, 38, 30, 22,
  76. 14,  6, 61, 53, 45, 37, 29,
  77. 21, 13,  5, 28, 20, 12,  4
  78. };
  80. /* number left rotations of pc1 */
  81. static char CONSTANT_DATA totrot[] = {
  82. 1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28
  83. };
  85. /* permuted choice key (table) */
  86. static char CONSTANT_DATA pc2[] = {
  87. 14, 17, 11, 24,  1,  5,
  88.  3, 28, 15,  6, 21, 10,
  89. 23, 19, 12,  4, 26,  8,
  90. 16,  7, 27, 20, 13,  2,
  91. 41, 52, 31, 37, 47, 55,
  92. 30, 40, 51, 45, 33, 48,
  93. 44, 49, 39, 56, 34, 53,
  94. 46, 42, 50, 36, 29, 32
  95. };
  97. /* The (in)famous S-boxes */
  98. static char CONSTANT_DATA si[8][64] = {
  99. /* S1 */
  100. 14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
  101.  0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
  102.  4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
  103. 15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13,
  105. /* S2 */
  106. 15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
  107.  3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
  108.  0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
  109. 13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9,
  111. /* S3 */
  112. 10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
  113. 13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
  114. 13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
  115.  1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12,
  117. /* S4 */
  118.  7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
  119. 13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
  120. 10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
  121.  3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14,
  123. /* S5 */
  124.  2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
  125. 14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
  126.  4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
  127. 11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3,
  129. /* S6 */
  130. 12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
  131. 10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
  132.  9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
  133.  4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13,
  135. /* S7 */
  136.  4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
  137. 13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
  138.  1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
  139.  6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12,
  141. /* S8 */
  142. 13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
  143.  1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
  144.  7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
  145.  2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
  146. };
  148. /* 32-bit permutation function P used on the output of the S-boxes */
  149. static char CONSTANT_DATA p32i[] = {
  150. 16,  7, 20, 21,
  151. 29, 12, 28, 17,
  152.  1, 15, 23, 26,
  153.  5, 18, 31, 10,
  154.  2,  8, 24, 14,
  155. 32, 27,  3,  9,
  156. 19, 13, 30,  6,
  157. 22, 11,  4, 25
  158. };
  159. /* End of DES-defined tables */
  161. /* Lookup tables initialized once only at startup by desinit() */
  162. static long (*sp_)[64];  /* Combined S and P boxes */
  164. #ifdef PERMUTATION
  165. static char CONSTANT_DATA (*iperm)[16][8]; /* Initial and final permutations */
  166. static char (*fperm)[16][8];
  167. #else
  168. #define iperm 0
  169. #define fperm 0
  170. #endif
  172. /* 8 6-bit subkeys for each of 16 rounds, initialized by setkey() */
  173. static unsigned char (*kn)[8];
  175. /* bit 0 is left-most in byte */
  176. static int CONSTANT_DATA bytebit[] = {
  177. 0200,0100,040,020,010,04,02,01
  178. };
  180. static int CONSTANT_DATA nibblebit[] = {
  181.  010,04,02,01
  182. };
  183. static int desmode;
  185. #ifdef LITTLE_ENDIAN 
  187. /* Byte swap a long */
  189. static
  190. unsigned long
  191. byteswap(unsigned long x)
  192. {
  193. register char *cp,tmp;
  195. cp = (char *)&x;
  196. tmp = cp[3];
  197. cp[3] = cp[0];
  198. cp[0] = tmp;
  200. tmp = cp[2];
  201. cp[2] = cp[1];
  202. cp[1] = tmp;
  204. return x;
  205. }
  206. #endif
  208. #ifdef PERMUTATION
  209. /* initialize a perm array */
  210. static
  211. void perminit(perm,p)
  212. char perm[16][16][8]; /* 64-bit, either init or final */
  213. char p[64];
  214. {
  215. register int l, j, k;
  216. int i,m;
  218. /* Clear the permutation array */
  219. for (i=0; i<16; i++)
  220. for (j=0; j<16; j++)
  221. for (k=0; k<8; k++)
  222. perm[i][j][k]=0;
  224. for (i=0; i<16; i++) /* each input nibble position */
  225. for (j = 0; j < 16; j++)/* each possible input nibble */
  226. for (k = 0; k < 64; k++)/* each output bit position */
  227. {   l = p[k] - 1; /* where does this bit come from*/
  228. if ((l >> 2) != i)  /* does it come from input posn?*/
  229. continue; /* if not, bit k is 0  */
  230. if (!(j & nibblebit[l & 3]))
  231. continue; /* any such bit in input? */
  232. m = k & 07; /* which bit is this in the byte*/
  233. perm[i][j][k>>3] |= bytebit[m];
  234. }
  235. }
  236. #endif
  238. /* Initialize the lookup table for the combined S and P boxes */
  239. static void
  240. spinit()
  241. {
  242. char pbox[32];
  243. int p,i,s,j,rowcol;
  244. long val;
  246. /* Compute pbox, the inverse of p32i.
  247.  * This is easier to work with
  248.  */
  249. for(p=0;p<32;p++){
  250. for(i=0;i<32;i++){
  251. if(p32i[i]-1 == p){
  252. pbox[p] = i;
  253. break;
  254. }
  255. }
  256. }
  257. for(s = 0; s < 8; s++){  /* For each S-box */
  258. for(i=0; i<64; i++){ /* For each possible input */
  259. val = 0;
  260. /* The row number is formed from the first and last
  261.  * bits; the column number is from the middle 4
  262.  */
  263. rowcol = (i & 32) | ((i & 1) ? 16 : 0) | ((i >> 1) & 0xf);
  264. for(j=0;j<4;j++){ /* For each output bit */
  265. if(si[s][rowcol] & (8 >> j)){
  266.  val |= 1L << (31 - pbox[4*s + j]);
  267. }
  268. }
  269. sp_[s][i] = val;
  271. #ifdef DEBUG
  272.                         printf("sp_[%d][%2d] = %08lxn",s,i,sp_[s][i]);
  273. #endif
  274. }
  275. }
  276. }
  279. /* Allocate space and initialize DES lookup arrays
  280.  * mode == 0: standard Data Encryption Algorithm
  281.  * mode == 1: DEA without initial and final permutations for speed
  282.  * mode == 2: DEA without permutations and with 128-byte key (completely
  283.  *       independent subkeys for each round)
  284.  */
  285. int desinit(int mode)
  286. {
  287. if(sp_ != NULL){
  288. /* Already initialized */
  289. return 0;
  290. }
  291. desmode = mode;
  293. if((sp_ = (long (*)[64])malloc(sizeof(long) * 8 * 64)) == NULL){
  294. return -1;
  295. }
  296. spinit();
  297. kn = (unsigned char (*)[8])malloc(sizeof(char) * 8 * 16);
  298. if(kn == NULL){
  299. free((char *)sp_);
  300. return -1;
  301. }
  302. if(mode == 1 || mode == 2) /* No permutations */
  303. return 0;
  305. #ifdef PERMUTATION
  306. iperm = (char (*)[16][8])malloc(sizeof(char) * 16 * 16 * 8);
  307. if(iperm == NULL){
  308. free((char *)sp_);
  309. free((char *)kn);
  310. return -1;
  311. }
  312. perminit(iperm,ip);
  314. fperm = (char (*)[16][8])malloc(sizeof(char) * 16 * 16 * 8);
  315. if(fperm == NULL){
  316. free((char *)sp_);
  317. free((char *)kn);
  318. free((char *)iperm);
  319. return -1;
  320. }
  321. perminit(fperm,fp);
  322. #endif
  324. return 0;
  325. }
  326. /* Free up storage used by DES */
  327. void desdone(void)
  328. {
  329. if(sp_ == NULL)
  330. return; /* Already done */
  332. free((char *)sp_);
  333. free((char *)kn);
  334. #ifdef PERMUTATION
  335. if(iperm != NULL)
  336. free((char *)iperm);
  337. if(fperm != NULL)
  338. free((char *)fperm);
  339. iperm = NULL;
  340. fperm = NULL;
  341. #endif
  343. sp_ = NULL;
  344. kn = NULL;
  345. }
  346. /* Set key (initialize key schedule array) */
  348. void setkey(char *key)
  349. {
  350. char pc1m[56]; /* place to modify pc1 into */
  351. char pcr[56]; /* place to rotate pc1 into */
  352. register int i,j,l;
  353. int m;
  355. /* In mode 2, the 128 bytes of subkey are set directly from the
  356.          * user's key, allowing him to use completely independent
  357.  * subkeys for each round. Note that the user MUST specify a
  358.  * full 128 bytes.
  359.  *
  360.  * I would like to think that this technique gives the NSA a real
  361.          * headache, but I'm not THAT naive.
  362.  */
  363. if(desmode == 2){
  364. for(i=0;i<16;i++)
  365. for(j=0;j<8;j++)
  366. kn[i][j] = *key++;
  367. return;
  368. }
  369. /* Clear key schedule */
  370. for (i=0; i<16; i++)
  371. for (j=0; j<8; j++)
  372. kn[i][j]=0;
  374. for (j=0; j<56; j++) { /* convert pc1 to bits of key */
  375. l=pc1[j]-1; /* integer bit location  */
  376. m = l & 07; /* find bit  */
  377. pc1m[j]=(key[l>>3] & /* find which key byte l is in */
  378. bytebit[m]) /* and which bit of that byte */
  379. ? 1 : 0; /* and store 1-bit result */
  380. }
  381. for (i=0; i<16; i++) { /* key chunk for each iteration */
  382. for (j=0; j<56; j++) /* rotate pc1 the right amount */
  383. pcr[j] = pc1m[(l=j+totrot[i])<(j<28? 28 : 56) ? l: l-28];
  384. /* rotate left and right halves independently */
  385. for (j=0; j<48; j++){ /* select bits individually */
  386. /* check bit that goes to kn[j] */
  387. if (pcr[pc2[j]-1]){
  388.                                 /* mask it in if it's there */
  389. l= j % 6;
  390. kn[i][j/6] |= bytebit[l] >> 2;
  391. }
  392. }
  393. }
  394. }
  397. /* Permute inblock with perm */
  398. static void
  399. permute(inblock,perm,outblock)
  400. char *inblock, *outblock; /* result into outblock,64 bits */
  401. char perm[16][16][8]; /* 2K bytes defining perm. */
  402. {
  403. register int i,j;
  404. register char *ib, *ob;  /* ptr to input or output block */
  405. register char *p, *q;
  407. if(perm == NULL){
  408. /* No permutation, just copy */
  409. for(i=8; i!=0; i--)
  410. *outblock++ = *inblock++;
  411. return;
  412. }
  413. /* Clear output block  */
  414. for (i=8, ob = outblock; i != 0; i--)
  415. *ob++ = 0;
  417. ib = inblock;
  418. for (j = 0; j < 16; j += 2, ib++) { /* for each input nibble */
  419. ob = outblock;
  420. p = perm[j][(*ib >> 4) & 017];
  421. q = perm[j + 1][*ib & 017];
  422. for (i = 8; i != 0; i--){   /* and each output byte */
  423. *ob++ |= *p++ | *q++; /* OR the masks together*/
  424. }
  425. }
  426. }
  427. /* The nonlinear function f(r,k), the heart of DES */
  428. static
  429. long
  430. f(r,subkey)
  431. unsigned long r; /* 32 bits */
  432. unsigned char subkey[8]; /* 48-bit key for this round */
  433. {
  434. register unsigned long rval,rt;
  435. #ifdef TRACE
  436. unsigned char *cp;
  437. int i;
  439.         printf("f(%08lx, %02x %02x %02x %02x %02x %02x %02x %02x) = ",
  440. r,
  441. subkey[0], subkey[1], subkey[2],
  442. subkey[3], subkey[4], subkey[5],
  443. subkey[6], subkey[7]);
  444. #endif
  445. /* Run E(R) ^ K through the combined S & P boxes
  446.  * This code takes advantage of a convenient regularity in
  447.  * E, namely that each group of 6 bits in E(R) feeding
  448.  * a single S-box is a contiguous segment of R.
  449.  */
  450. rt = (r >> 1) | ((r & 1) ? 0x80000000 : 0);
  451. rval = 0;
  452. rval |= sp_[0][((rt >> 26) ^ *subkey++) & 0x3f];
  453. rval |= sp_[1][((rt >> 22) ^ *subkey++) & 0x3f];
  454. rval |= sp_[2][((rt >> 18) ^ *subkey++) & 0x3f];
  455. rval |= sp_[3][((rt >> 14) ^ *subkey++) & 0x3f];
  456. rval |= sp_[4][((rt >> 10) ^ *subkey++) & 0x3f];
  457. rval |= sp_[5][((rt >> 6) ^ *subkey++) & 0x3f];
  458. rval |= sp_[6][((rt >> 2) ^ *subkey++) & 0x3f];
  459. rt = (r << 1) | ((r & 0x80000000) ? 1 : 0);
  460. rval |= sp_[7][(rt ^ *subkey) & 0x3f];
  461. #ifdef TRACE
  462.         printf(" %08lxn",rval);
  463. #endif
  464. return rval;
  465. }
  467. /* Do one DES cipher round */
  468. static void
  469. round(num,block)
  470. int num; /* i.e. the num-th one  */
  471. unsigned long *block;
  472. {
  473. long f();
  475. /* The rounds are numbered from 0 to 15. On even rounds
  476.  * the right half is fed to f() and the result exclusive-ORs
  477.  * the left half; on odd rounds the reverse is done.
  478.  */
  479. if(num & 1){
  480. block[1] ^= f(block[0],kn[num]);
  481. } else {
  482. block[0] ^= f(block[1],kn[num]);
  483. }
  484. }          
  486. /* In-place encryption of 64-bit block */
  488. void endes(char *block)
  489. {
  490. register int i;
  491. unsigned long work[2]; /* Working data storage */
  492. long tmp;
  494. permute(block,iperm,(char *)work); /* Initial Permutation */
  495. #ifdef LITTLE_ENDIAN
  496. work[0] = byteswap(work[0]);
  497. work[1] = byteswap(work[1]);
  498. #endif
  500. /* Do the 16 rounds */
  501. for (i=0; i<16; i++)
  502. round(i,work);
  504. /* Left/right half swap */
  505. tmp = work[0];
  506. work[0] = work[1];
  507. work[1] = tmp;
  509. #ifdef LITTLE_ENDIAN
  510. work[0] = byteswap(work[0]);
  511. work[1] = byteswap(work[1]);
  512. #endif
  513. permute((char *)work,fperm,block); /* Inverse initial permutation */
  514. }
  515. /* In-place decryption of 64-bit block */
  516. void dedes(char *block)
  517. {
  518. register int i;
  519. unsigned long work[2]; /* Working data storage */
  520. long tmp;
  522. permute(block,iperm,(char *)work); /* Initial permutation */
  524. #ifdef LITTLE_ENDIAN
  525. work[0] = byteswap(work[0]);
  526. work[1] = byteswap(work[1]);
  527. #endif
  529. /* Left/right half swap */
  530. tmp = work[0];
  531. work[0] = work[1];
  532. work[1] = tmp;
  534. /* Do the 16 rounds in reverse order */
  535. for (i=15; i >= 0; i--)
  536. round(i,work);
  538. #ifdef LITTLE_ENDIAN
  539. work[0] = byteswap(work[0]);
  540. work[1] = byteswap(work[1]);
  541. #endif
  543. permute((char *)work,fperm,block); /* Inverse initial permutation */
  544. }