소스 거덩요..
갈무리 해서 컴팔해보셔요~
지금까진 잘 동작하내요..
리눅스랑 윈도그랑 둘다 잘 돌아가더군요.
리눅스에서 암호화 해서 윈도그에서 복호화 되구...
근대 소스가 넘 지저분해요..
 혹시 이상한 부분 있음 지적해주시구요
 저의 생각이지만 최소한 1원 이상의 가치는 있다고.. ^^
해해~~~~~~
  소스----------------------------------------------------------
/**************************************************************
 *   작성자 : Seok-jun Bae
 *   날  자 : 2001. 4. 28.
 *   내  용 : DES 암호화 복호화 프로그램 
 *   E-mail : qprk at qprk.pe.kr  * 
 *   이 소스코드에 대한 어떠한 보증도 없습니다.
 *   이 소스를 수정 배포할수 있지만 다른곳에 배포할 경우
 *   이 문장이 포함되어야 합니다.
 **************************************************************/
 #include <stdio.h>
#include <stdlib.h>
//#include <conio.h>
#include <string.h>
  #define P2C 1			/* 평문을 암호로 */
#define C2P 2			/* 암호를 평문으로 */
#define BUFFSIZE 20500		/* 20KByte */
#define RWSIZE   20000
//#define DISP_char2binary
//#define DISP_char2binary_strlen
//#define DISP_keyGenerate_binary2char
//#define DISP_keyGenerate_leftShift
//#define DISP_keyGenerate_final
//#define DISP_desMain_C2P_Key
//#define DISP_desMain_fileState
//#define DISP_startDes_textBuff
//#define DISP_startDes_tgtData
//#define DISP_desRound_sboxValue
//#define DISP_desRound_xor
#define for_windog		/* linux에서는 필요없으니 주석처리.. */
  void keyGenerate(char *);
void desMain(int, char *, char *);
void startDes(int, int, char *, char *);
void desRound(int *, int *);
void char2binary(int *, char *, int);
char binary2char(int *);
void swap32bit(int *, int *, int *);
void helpText();
 void keyProc(char *keySrc);
   int MAT_IP[64]={58, 50, 42, 34, 26 ,18 ,10, 2,
		60, 52, 44, 36, 28, 20, 12, 4,
		62, 54, 46, 38, 30, 22, 14, 6,
		64, 56, 48, 40, 32, 24, 16, 8,
		57, 49, 41, 33, 25, 17, 9, 1,
		59, 51, 43, 35, 27, 19, 11, 3,
		61, 53, 45, 37, 29, 21, 13, 5,
		63, 55, 47, 39, 31, 23, 15, 7};
 int MAT_IP_1[64]={40, 8, 48, 16, 56, 24, 64, 32,
		  39, 7, 47, 15, 55, 23, 63, 31,
		  38, 6, 46, 14, 54, 22, 62, 30,
		  37, 5, 45, 13, 53, 21, 61, 29,
		  36, 4, 44, 12, 52, 20, 60, 28,
		  35, 3, 43, 11, 51, 19, 59, 27,
		  34, 2, 42, 10, 50, 18, 58, 26,
		  33, 1, 41, 9, 49, 17, 57, 25};
 int MAT_EXP[48]={32, 1, 2, 3, 4, 5,
		 4, 5, 6, 7, 8, 9,
		 8, 9, 10, 11, 12, 13,
		 12, 13, 14, 15, 16, 17,
		 16, 17, 18, 19, 20, 21,
		 20, 21, 22, 23, 24, 25,
		 24, 25, 26, 27, 28, 29,
		 28, 29, 30, 31, 32, 1};
 int MAT_PERMU[32]={16, 7, 20, 21, 29, 12, 28, 17,
		   1, 15, 23, 26, 5, 18, 31, 10,
		   2, 8, 24, 14, 32, 27, 3, 9,
		   19, 13, 30, 6, 22, 11, 4, 25};
 int MAT_SBOX[8][4][16]={{{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5,
9, 0, 7},
			 {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12,
11, 9, 5, 3, 8},
			 {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7,
3, 10, 5, 0},
			 {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 2, 14,
10, 0, 6, 13}},
 
			{{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13,
12, 0, 5, 10},
			 {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10,
6, 9, 11, 5},
			 {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6,
9, 3, 2, 15},
			 {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12,
0, 5, 14, 9}},
 			{{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7,
11, 4, 2, 8},
			 {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14,
12, 11, 15, 1},
			 {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12,
5, 10, 14, 7},
			 {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3,
11, 5, 2, 12}},
 			{{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5,
11, 12, 4, 15},
			 {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12,
1, 10, 14, 9},
			 {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3,
14, 5, 2, 8, 4},
			 {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11,
12, 7, 2, 14}},
	   
			{{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15,
13, 0, 14, 9},
			 {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15,
10, 3, 9, 8, 6},
			 {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5,
6, 3, 0, 14},
			 {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9,
10, 4, 5, 3}},
 			{{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7,
5, 10, 6, 1},
			 {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12,
2, 15, 8, 6},
			 {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6,
8, 0, 5, 9, 2},
			 {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15,
14, 2, 3, 12}},
 			{{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4,
14, 7, 5, 11},
			 {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14,
0, 11, 3, 8},
			 {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10,
1, 13, 11, 6},
			 {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7,
6, 0, 8, 13}},
 			{{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14,
5, 0, 12, 7},
			 {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11,
0, 14, 9, 2},
			 {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13,
15, 3, 5, 8},
			 {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0,
3, 5, 6, 11}}};
 int MAT_PC_1[56]={57, 49, 41, 33, 25, 17, 9,
		  1, 58, 50, 42, 34, 26, 18,
		  10, 2, 59, 51, 43, 35, 27,
		  19, 11, 3, 60, 52, 44, 36,
		  63, 55, 47, 39, 31, 23, 15,
		  7, 62, 54, 46, 38, 30, 22,
		  14, 6, 61, 53, 45, 37, 29,
		  21, 13, 5, 28, 20, 12, 4};
 int MAT_PC_2[48]={14, 17, 11, 24, 1, 5, 3, 28,
		  15, 6, 21, 10, 23, 19, 12, 4,
		  26, 8, 16, 7, 27, 20, 13, 2,
		  41, 52, 31, 37, 47, 55, 30, 40,
		  51, 45, 33, 48, 44, 49, 39, 56,
		  34, 53, 46, 42, 50, 36, 29, 32};
 int KEY[16][48];
  /**************************************************************
 *  main
 *
 **************************************************************/
main(int argc, char **argv)
{
   if(argc != 4)
    helpText();
 
  if(!(strcmp(argv[1],"-c")))
    desMain( P2C, argv[2], argv[3]);
  else if(!(strcmp(argv[1],"-p")))
    desMain( C2P, argv[2], argv[3]);
  else
    helpText();
  }   
 /**************************************************************
 * DES 암호화 및 복호화
 * jobType  : P2C(0)일경우 암호화, C2P(1)일경우 복호화
 * passWord : 입력된 key
 * fileName : 암호화 및 복호화 할 file이름
 **************************************************************/
void desMain(int jobType, char *passWord, char *fileName)
{
  FILE *srcFile, *targetFile;
  int tempKey[16][48];
  long int dataSize;
  long int readSize, writeSize;
  char *fileSrcBuff, *fileTgtBuff;
  char nameTemp[100]={0,};
  char qprkDes[100]={0,};
  int i,j;
   //////////////////////////////////////////////////////////
  keyGenerate(passWord);	/* DES에 사용할 Key 생성 */
  ////////////////////////////////////////////////////////
  if(jobType == C2P){			/* C2P일경우 key를 역순으
로 나열 */
    for(i=0; i<16; i++)
      for(j=0; j<48; j++)
	tempKey[15-i][j] = KEY[i][j];
    for(i=0; i<16; i++)
      for(j=0; j<48; j++)
	KEY[i][j] = tempKey[i][j];
#ifdef DISP_desMain_C2P_Key	/* C2P 역순 Key 확인 */
    printf("C2P key");
    for(i=0; i<16; i++){
      for(j=0; j<48; j++)
	printf("%d", KEY[i][j]);
       printf("");
    }//  for(i=0; i<16; i++){
#endif
  }//  if(jobType){
   strcpy(nameTemp,fileName);
  if(jobType == C2P){		/* target file 이름 결정 */
    if( (strcmp(".des", fileName+(strlen(fileName)-4)))){ /* 복호화할
filename 검사 */
      printf("%s is not qprkDES!!",fileName);
      helpText();
    }//  if( !(strcmp(".des", filename+(strlen(fileName)-4)))){
    nameTemp[ strlen(fileName)-4 ] = ''; /* file name의 .des를 제거 
*/
  } else {			/* jobType 이 P2C인경우
 */
    nameTemp[ strlen(fileName)-4 ] = ''; /* file name의 .des를 제거 
*/
    sprintf(qprkDes,"%s.des",nameTe
mp);
  }//  else {
   if( (srcFile = fopen( fileName, "r+b" )) == NULL ){ /* source file을 
연다 */
    printf("
Source file can not open!!!! -%s- ", fileName);
    exit(0);
  }//  if( (srcFile=(fileName, "r"))==NULL ){
   fseek
(srcFile, 0, SEEK_END);	/* srcFile의 크기를 알아보고 */
  readSize = ftell(srcFile);	/* 그 크기만큼 버퍼
를 잡고 srcFile
을 */
  fseek(srcFile, 0, SEEK_SET);	/* buff에 복사하고  srcFile을 닫는
다*/
  dataSize 
= readSize / 8;
 #ifdef DISP_desMain_fileState
  printf("원래 file크기:%ld  나누기8결과:%d  ", readSize, dat
aSize);
#endif
  dataSize++;  /* 기존의 file크기보다 버퍼를 크게 잡기 위해 */
   ////////////////////
/////////////////////////////////////////////////
////////////////////
#ifdef for_windog
  if(readSize > RWSIZE){	/* fi
le크기가 20K 이상이면 따로 돌림. 리눅
스에서 필요없음*/
    // 25000 은 RWSIZE를 8로 나눈 값

    //#define BUFFSIZE 200200	
    //#define RWSIZE   200000
     if(jobType == C2P){		/* C2P일경우 저장된
 file size를 읽
어옴 */
      fread(&writeSize, sizeof(long int), 1, srcFile);
      fgets(qprkDes, 100, srcFi
le);  /* 원래 file명을 읽어옴 */
      qprkDes[ strlen(qprkDes) -1] = '';  /*  제거 */
      strcpy(n
ameTemp, qprkDes);
      readSize -= sizeof(long int);
#ifdef DISP_desMain_fileState
      printf("write size : %l
d",writeSize);
#endif
    }//  if(jobType == C2P){    
     if( (targetFile = fopen( qprkDes, "w+b" )) == NULL ){
 /* target 
file을 연다 */
      printf("Target file open error!!!! -%s- ", qprkDes);
      exit(0);
    }//
  if( (targetFile = fopen( nameTemp, "w" )) == NULL ){ 
       if(jobType == P2C){
	fwrite(&readSize, sizeof(long in
t), 1, targetFile); /* file 
size를 저장 */
	fprintf(targetFile,"%s",fileName);
      } 
     fileSrcBuff = (cha
r *)malloc(sizeof(char) * BUFFSIZE); /* Buff의 
memory할당 */
    fileTgtBuff = (char *)malloc(sizeof(char) * BUFFS
IZE);
     for(i=0; i< ((readSize/RWSIZE) + 1); i++){ /* 200000Byte 씩 잘라서 
암호, 복호화 */
      memse
t(fileSrcBuff, 0, sizeof(char) * BUFFSIZE);	/* 할당된 공간
을 로 초기화 */
      memset(fileTgtBuff, 0, si
zeof(char) * BUFFSIZE);
      
      fread(fileSrcBuff, RWSIZE, 1, srcFile); /* file내용을 buff에 복
사 */
#
ifdef DISP_desMain_fileState
      printf("file에서 읽어온 내용%s", fileSrcBuff);
#endif
     //////////////
/////////////////////////////////////////////////////
///////////////
      startDes(jobType, RWSIZE/8, fileSrcBuff, 
fileTgtBuff); /* 암호화 
복호화를 시작 */
    ///////////////////////////////////////////////////////////////
////
/////////////
 #ifdef DISP_desMain_fileState
      printf("job type : %d", jobType);
      printf("target fil
e name: %s",qprkDes); /* test */
#endif
       if(jobType == P2C){
	fwrite(fileTgtBuff, RWSIZE, 1, targetFile); /* bu
ff의 내용을 
file에 저장 */
      } else {
	if(writeSize <= RWSIZE){
	fwrite(fileTgtBuff, writeSize, 1, target
File); /* buff의 내용
을 file에 저장 */
	break;
	} else {
	fwrite(fileTgtBuff, RWSIZE, 1, targetFile); /* buff의
 내용을 
file에 저장 */
	}
      }//  else {
      
      writeSize -= RWSIZE;
    }//  for(i=0; i< (
(readSize/200000) + 1); i++){
     
    fclose(srcFile);
    fclose(targetFile);
    free(fileSrcBuff);
    fr
ee(fileTgtBuff);
     return;
  }//  if(readSize > RWSIZE){
#endif
  //////////////////////////////////////////////
///////////////////////
////////////////////
 #ifdef DISP_desMain_fileState
  printf("malloc할 크기:%ld ", dataSize*
8);
#endif
  fileSrcBuff = (char *)malloc(dataSize*8); /* Buff의 memory할당 및 초
기화 */
  fileTgtBuff = (char
 *)malloc(dataSize*8);
   memset(fileSrcBuff, 0, dataSize*8);	/* 할당된 공간을 로 초
기화 */
  memset(fileT
gtBuff, 0, dataSize*8);
   if(jobType == C2P){		/* C2P일경우 저장된 file size를 읽
어옴 */
    fread(&write
Size, sizeof(long int), 1, srcFile);
    fgets(qprkDes, 100, srcFile);  /* 원래 file명을 읽어옴 */
    qprkD
es[ strlen(qprkDes) -1] = '';  /*  제거 */
    strcpy(nameTemp, qprkDes);
    readSize -= sizeof(long int);
#if
def DISP_desMain_fileState
    printf("write size : %ld",writeSize);
#endif
  }//  if(jobType == C2P){    
   
 
 fread(fileSrcBuff, readSize, 1, srcFile); /* file내용을 buff에 복사 
*/
#ifdef DISP_desMain_fileState
  printf("
file에서 읽어온 내용%s", fileSrcBuff);
#endif
  fclose(srcFile);
   ///////////////////////////////////////////
//////////////////////////
/////////////
  startDes(jobType, dataSize, fileSrcBuff, fileTgtBuff); /* 암호화 복호

화를 시작 */
  /////////////////////////////////////////////////////////////////////
///////////
 #ifdef DISP_desMa
in_fileState
  printf("job type : %d", jobType);
  printf("target file name: %s",qprkDes); /* test */
#endif
   if( (
targetFile = fopen( qprkDes, "w+b" )) == NULL ){ /* target file
을 연다 */
    printf("Target file open error!!!! -
%s- ", qprkDes);
    exit(0);
  }//  if( (targetFile = fopen( nameTemp, "w" )) == NULL ){ 
   if(jobType == P2C){

    fwrite(&readSize, sizeof(long int), 1, targetFile); /* file size를 
저장 */
    fprintf(targetFile,"%s",fileN
ame);
    fwrite(fileTgtBuff, dataSize*8, 1, targetFile); /* buff의 내용을 
file에 저장 */
  } else {
    fw
rite(fileTgtBuff, writeSize, 1, targetFile); /* buff의 내용을 
file에 저장 */
  }//  else {
   fclose(targetFi
le);
  free(fileSrcBuff);
  free(fileTgtBuff);
  
}
  /**************************************************************

 * des 암호화, 복호화를 한다
 * jobType  : P2C 암호화, C2P 복호화
 * dataSize : srcData의 크기 / 
8 + 1
 * srcData 가 암호화,복호화되어 tgtData에 저장된다
 **********************************************
****************/
void startDes(int jobType, int dataSize, char *srcData, char *tgtData )
{
  int srcBinary[64]={0,}, t
gtBinary[64]={0,}, binaryBuff[64]={0,};
  int leftData[32]={0,}, rightData[32]={0,}, swapBuff[32]={0,};
  int tgtIndex
=0;
  char textBuff[9]={'',};
  int i, j, k;
   for(i=0, tgtIndex=0; i<dataSize; i++){ /* Data의 끝까지 가면
서 암호
화, 복호화 한다 */
    memset(textBuff, 0, 9);
    memcpy(textBuff, (srcData + tgtIndex), 8);	/* sr
cData에서 8
자씩 textBuff로복사 */
 #ifdef DISP_startDes_textBuff	/* 복사된 textbuff의 내용을 표시 
*/

    printf("text buff : %s", textBuff);
#endif
     char2binary(binaryBuff, textBuff, 8); /* textBuff를 binary로 
  */
     for(j=0; j<64; j++)		/* Initial Permutation */
      srcBinary[j] = binaryBuff[ MAT_IP[j]-1 ];
     if(
jobType == P2C) 
      for(j=0; j<32; j++){	/* 하나의 64bit를 둘의 left, right data 로 
나눈다*/
	leftData[
j] = srcBinary[j];
	rightData[j] = srcBinary[j+32];
      }//  for(j=0; j<32; j++){
    else		/* 복호화 할경
우 left data와 right data의 위치를 바
꾼다 */
      for(j=0; j<32; j++){	/* 하나의 64bit를 둘의 left, 
right data 로 
나눈다*/
	rightData[j] = srcBinary[j];
	leftData[j] = srcBinary[j+32];
      }//  for(j=0; j<32; 
j++){
     ///////////////////////////////////////////////////////////////////
///////
    desRound(leftData, rightD
ata);
    ///////////////////////////////////////////////////////////////////
///////
     if(jobType == P2C) 
   
   swap32bit(leftData, rightData, swapBuff);	/* 32bit swap */
     for(j=0; j<32; j++){	/* 둘의 left, right data 
를 하나의 64bit로 
합한다 */
      binaryBuff[j] = rightData[j]; /* 또한 32bit swap을 한다 */
      b
inaryBuff[j+32] = leftData[j];
    }//  for(j=0; j<32; j++){
     for(j=0; j<64; j++)		/* Inverse Initial Permutati
on */
      tgtBinary[j] = binaryBuff[ MAT_IP_1[j]-1 ];
     memset(textBuff, 0, 9);
    for(j=0,k=0; j<64; j+=8,
 k++) /* tgtBinary를 ascii로 변형후 
textBuff에 저장 */
      textBuff[k] = binary2char(&tgtBinary[j]);
   
  memcpy((tgtData + tgtIndex), textBuff, 8);	/* textBuff의 내
용을 tgtData로 복사 */
 #ifdef DISP_startDes_tgtDa
ta	/* 복사된 textbuff의 내용을 표시 
*/
    printf("tgtData : %s", (tgtData + tgtIndex));
#endif
 				/* strn
cpy는 없어질수 있지 않나? 
*/
    tgtIndex += 8;
  }//  for(i=0; i<dataSize; i++){
 }
  /******************
********************************************
 * Round
 **************************************************************/

void desRound(int *leftData, int *rightData)
{
  int sboxOut[32]={0,}, leftFinal[32]={0,}, permuOut[32]={0,};
  int e
Buff[48]={0,}, eBuffOut[48]={0,};
  int sboxRow, sboxCol, sboxValue;
  int i, j, k, keyIndex;
   for(keyIndex=0; keyI
ndex<16; keyIndex++){	/* 16번의 round를 거친다 
*/
     for(i=0; i<32; i++)		/* 써먹을때가 있다 */
    
  leftFinal[i] = *(rightData+i);
     for(i=0; i<48; i++){		/* E table 적용 */
      eBuff[i] = *(rightData + (M
AT_EXP[i] -1));
#ifdef DISP_desRound_xor	/* xor상황 확인 */
      printf("eBuff[i] = *(rightData + (MAT_EXP[i] -1
)) ----> %d = %d 
+ %d"
	     , eBuff[i] , *(rightData + (MAT_EXP[i] -1)), MAT_EXP
[i] -1);
#endif
    }//  for(i=0
; i<48; i++){
     
    for(i=0; i<48; i++){		/* eBuff xor key */
      eBuffOut[i] = eBuff[i] ^ KEY[keyIndex][i]
;
#ifdef DISP_desRound_xor	/* xor상황 확인 */
      printf("keyIndes :%d, i:%d,      ", keyIndex, i);
     
 printf("eBuff xor key (eBuffOut = eBuff ^ key)->");
      printf("%d = %d ^ %d",eBuffOut[i], eBuff[i], KEY[keyIndex]
[i]);
#endif
    }//  for(i=0; i<48; i++){
  
    for(i=0, j=0, k=0; i<8; i++){	/* sBox 적용 */
      sboxRow
 = (eBuffOut[j+0] * 2) + eBuffOut[j+5];
      sboxCol = (eBuffOut[j+1] * 8) + (eBuffOut[j+2] * 4) + (eBuffOut
[j+3] *
 2) + eBuffOut[j+4];
      sboxValue = MAT_SBOX[i][sboxRow][sboxCol];
      sboxOut[k]   = ((sboxValue & 8)  ? 1
:0 );
      sboxOut[k+1] = ((sboxValue & 4)  ? 1:0 );
      sboxOut[k+2] = ((sboxValue & 2)  ? 1:0 );
      s
boxOut[k+3] = sboxValue & 1;	
#ifdef DISP_desRound_sboxValue	/* xbox의 선택된 값을 찍어보자 */
      printf
("sboxRow :%d, sboxCol :%2d, sbox value %d : %
2d",sboxRow, sboxCol, i, sboxValue);
      printf("sboxOut : %d %d %d 
%d",sboxOut[k], sboxOut[k+1], 
sboxOut[k+2], sboxOut[k+3]);
#endif
      j += 6;
      k += 4;
    }//  for(i=0
, k=0; i<8; i++){
     for(i=0; i<32; i++)		/* sboxOut 에 p table적용 */
      permuOut[i] = sboxOut[ MAT_PERMU[
i]-1 ];  
  
    for(i=0; i<32; i++){		/* permuOut xor leftData 를 
rightData에 저장*/
      *(rightData+i) =
 *(leftData+i) ^ permuOut[i];
#ifdef DISP_desRound_xor	/* xor상황 확인 */
      printf("left xor permu (rightData
 = leftData ^ permuOut)->");
      printf("%d = %d ^ %d", *(rightData+i), *(leftData+i), permuOut
[i]);
#endif
    
}//  for(i=0; i<32; i++){
  
    for(i=0; i<32; i++)		/* 첨에 복사한 leftFinal을 
leftData에 복사 */
    
  *(leftData+i) = leftFinal[i];
   }//  for(keyIndex=0; keyIndex<16; keyIndex++){
 }
  /*****************************
*********************************
 * 32bit swap
 **************************************************************/
void 
swap32bit(int *leftBit, int *rightBit, int *buffBit)
{
  int i;
  
  for(i=0; i<32; i++)
    buffBit[i] = leftBit[i
];
   for(i=0; i<32; i++)
    leftBit[i] = rightBit[i];
   for(i=0; i<32; i++)
    rightBit[i] = buffBit[i];
 }
  
/**************************************************************
 * 16개 키 만들기
 * key의 입력 재한은 없
지만 내부적으로 8Byte만 사용한다.
 **************************************************************/
void key
Generate(char *keySrc)
{
  int keySchedule[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
  int binaryKey[64] = {0,};
  int
 pc1[56]={0,};
  char tempKey[9];
  int i, j, k, l, tmp1, tmp2, srcLen;
   if( (strlen(keySrc))>8 )	/* 입력된 암
호의 길이가 8자 이상이면 */
    keyProc(keySrc);
   strncpy(tempKey, keySrc, 8);
  tempKey[8] = '';
  sr
cLen = strlen( tempKey);
  char2binary(binaryKey, tempKey, srcLen);
  memset(tempKey, 0, 8);
  
#ifdef DISP_keyGenera
te_binary2char /* 그냥 찍어본거 */
  printf("keyGenerate_binary2char");
  for(i=0, k=0;i<8;i++){
    for(j=0;j
<8;j++){
      printf("%d ",binaryKey[k]);
      k++;
    }
    printf("");
  }
  printf("");
  printf("");

   printf("binary2char=:");
  for(i=0; i<64; i += 8){
    printf("%c",binary2char(&binaryKey[i]));
  }//  for(i=0
; i<56; i += 8){
  printf("");
#endif
   for(i=0; i<56; i++)		/* 64bit를 56bit로 줄이는거 */
    pc1[i] = bina
ryKey[ MAT_PC_1[i]-1 ];
 #ifdef DISP_keyGenerate_leftShift /* left shift 상황 확인 */
  printf(" left shift");
#en
dif
   for(i=0; i<16; i++){
    for(j=0; j<keySchedule[i]; j++){ /* left shift */
      tmp1 = pc1[0];
      tm
p2 = pc1[28];
      for(k=1; k<28; k++){
	pc1[k-1] = pc1[k];
	pc1[k+27] = pc1[k+28];
      }//  for(k=1; k<28; k+
+){
      pc1[27] = tmp1;
      pc1[55] = tmp2;
    }//  for(j=0; j<keySchedule[i]; j++){
 #ifdef DISP_keyGener
ate_leftShift /* left shift 상황 확인 */
    for(l=0; l<56; l++){
      if(l==28)
	printf("  ");	      
  
    printf("%d", pc1[l]);
    }//  for(i=0; i<16; i++){
    printf("");
#endif
     for(j=0; j<48; j++)		/* 56b
it 를 48bit로 줄여서 저장 - 
최종 key */
      KEY[i][j] = pc1[ MAT_PC_2[j]-1 ];
  }//  for(i=0; i<16; i++
){
 #ifdef DISP_keyGenerate_final	/* 최종 key 16개 확인 */
  printf("final key");
  for(i=0; i<16; i++){
    fo
r(j=0; j<48; j++)
      printf("%d", KEY[i][j]);
    printf("");
  }//  for(i=0; i<16; i++){
#endif
 }
 /********
******************************************************
 * 길이가 긴 key를 8char로 줄이기
 * 12345678에서 12
34는 keySrc의 문자열에서 마지막부터 뒤로저장
 * 5678은 keySrc의 첫번째부터 저장
 * 저장 방
법은 keySrc의 문자 수를 4로 나눈 몫만큼 
 * 앞이나 뒤로 이동
 ************************************
**************************/
void keyProc(char *keySrc)
{
  char *temp;
  int srcLen=0, dev4;
  int i,j;
  
    srcL
en = strlen(keySrc);
  temp = (char *)malloc(srcLen+1);
  memset(temp, 0, srcLen +1);
  strcpy(temp, keySrc);
  mems
et(keySrc, 0, srcLen);
  
  dev4 = srcLen / 4;
  
  srcLen-- ;
   for(i=0,j=0;i<4;i++,j+=dev4){
    *(keySrc+i) 
  = *(temp+srcLen-j);
    *(keySrc+i+4) = *(temp+j);
    //    printf("keyProc--->%c", *(temp+srcLen-j));
  }// 
 for(i=0;i<4;i++){
   //  printf("keyProc--->%s",keySrc);
}
 /********************************************************
******
 * char를 2진수 코드로 만들기
 * target : 2진수 코드가 저장될 배열
 * char   : 2진수로 
만들 문자열
 * srcLen : 2진수로 만들 문자열의 길이
 **************************************************
************/
void char2binary(int *target, char *src, int srcLen)
{
  int targetIndex=0, i, j;
  char oneChar,temp1, 
temp2;
 #ifdef DISP_char2binary		/* char가 binary되는 상황 보기 */
  printf("orgkey      :%s",src);
#endif
 #
ifdef DISP_char2binary_strlen		/* char가 binary되는 상
황 보기 */
  printf("%d ",strlen(src));
#endif
   for(i=
0 ; i<srcLen; i++){
    oneChar=*(src+i);
    for(j=7; j>=0; j--){
      temp1 = oneChar >> j;
      temp2 = t
emp1 & 0x0001;
      *(target+targetIndex) = (temp2 == 1 ? 1:0);
      targetIndex++;
    }//  for(j=0;j<=8;j++
){
  }//  for(i=0,srcLen;i<=srcLen;i++){
 #ifdef DISP_char2binary		/* char가 binary되는 상황 보기 */
  printf(
"first display of char2binary");
  for(i=0,targetIndex=0; i<srcLen; i++){
    for(j=0; j<8; j++){
      printf("%d
 ", *(target+targetIndex));
      targetIndex++;
    }//  for(j=0; j<8; j++){
    printf("");
  }//  for(i=0; 
i<srcLen; i++){
#endif
 }
  /**************************************************************
 * 8개의 2진수를 하
나의 char로 만들기
 * src : 8개의 2진 코드
 * return : 만들어진 하나의 char
 **********************
****************************************/
char binary2char(int *src)
{
  char temp;
  int i,j,inTemp=1, chTemp=0;
   
for(i=0; i<8; i++){
    inTemp=1;
    if( *(src+i)) {
      for(j=7; j>i; j--)
	inTemp *= 2;
      chTemp += i
nTemp;
    }//  if( *(src+i)) {
  }//  for(i=0;i<8;i++){
  temp=chTemp;
  return temp;
}
 /**********************
****************************************
 * hele text
 **************************************************************/

void helpText()
{
  printf("사용법 : des [OPTION] [password] [file]");
  printf("Option......");
  printf("-c  
  : 암호화");
  printf("-h    : 도움밀");
  printf("-p    : 복호화");
  printf("password.....");
  pri
ntf("password의 문자열중 공백이 있을경우 "로 묶을것");
  printf("Example : "pass word"");
  printf("fi
le......");
  printf("file의 이름은 암호화시 .des를 file name 뒤에 붙임");
  printf("복호화시 file끝
의 .des를 제거 원래 file name을 출력");
  printf("버그 리포트 qprk at qprk.pe.kr");
  exit(0);
}