티스토리시작

    ① 키 스케줄을 하기 전에 쉬프트 횟수를 정의하는데 1, 2, 9, 16번째는 1번, 
     나머지는 2번씩이다.  이것으로 총 28번의 쉬프트가 이루어진다.

    ② 먼저 키는 PC1박스를 거치게 된다.  PC1박스를 거친 후엔 두 부분(각각 28비트)으로 나뉘게 된다.

    ③ 이제 각각의 두 부분은 위에서 정의한 데로 1번째에는 1번의 왼쪽 쉬프트를, 두 번째에는 1번의 왼쪽 쉬프트를, 세 번째에는 2번의 왼쪽 쉬프트를 .....16번째에는 1번의 왼쪽 쉬프트를 하게 된다.

    ④ 첫 번째 키는 1번째 쉬프트를 했을 때 두 부분을 합쳐서 PC2박스를 통과시켜 나오는 48비트 이다.

    ⑤ 두 번째 키는 2번째 쉬프트를 한 후 첫 번째와 같이 두 부분을 합쳐 PC2박스를 통과시켜 나오는 48비트이다.

    ⑥ 이런 식으로 16번째까지 모두 16개의 키가 생성되게 된다.

   2. 다중 DES

      - Double DES

DES 알고리즘 자체는 변형시키지 않고 DES의 안전성을 증대시키기 위한 방법 중의 하나로

2개의 다른키로 2번 암호화를 수행한다.

2개의 서로 다른 키가 적용되어졌기 때문에 2중 DES의 유효한 키는 56 ×112비트이다.

이 경우의 모든 가능한 키를 시도해보는 횟수는 2¹¹² 번 작업이 소요된다.
관측된  한 쌍의 평문과 암호문(m,c)가 주어졌을 때

m에 2개의 모든 가능한 k₁을 적용하여 암호화시킨 x값을 정렬하여 보관한다.다음에는 역시 2⁵⁶ 개의 모든 가능한 k₂를 c에 적용하여 복호화한다. 
복호화되는 가각의 값을 저장된 테이블에 있는 값과 비교하여 일치하는 항목에 대한 k₁과 k₂를 선정하여 이것을 하나의 평문과 암호문의 쌍에 적용시켜 검증한다. 

이 암호분석에 소용되는 작업량은 암호화와 복호화에 2·2⁵⁶ 그리고 n개의 값을 정렬하는데

- Triple DES

             "중간충돌" 공격을 방지할 수 있다.

   3. DES 운영방식

       1) ECB(Electronic CodeBook)

         ECB 모드는 DES 암호 방식의 사용 방식 중 가장 간단한 방식으로 평문을 
        64비트씩 나누어 암호화하는 방식이다. 평문을 64비트씩 나눌 때 마지막 블록이
        64비트가 되지 않을 때는 임의의 약속된 비트 모양을 패딩(padding)하게 된다. 
       64비트 블록의 평문을 그림 4.6과 같이 암호화한다.

이 방식은 동일한 평문 블록 모양에 따라 항상 동일한 암호문이 출력되므로 암호 해독자들

의 해독 가능성을 높게 만든다. 즉, 문서의 종류에 따라 동일한 문서 모양을 갖고 있으므로 암호문 단독 공격의 가능성을 높게 해준다. 따라서 64비트 길이의 평문 암호화에 유용하게 사용될 수 있으므로 DES 암호 방식의 키 암호화에 사용할 수 있다.

       2) CBC(Cipher Block Chaining)

DES 암호 방식의 CBC 모드는 출력 암호문이 다음 평문 블록에 영향을 미치게 하여 각 암호문 블록이 전단의 암호문의 영향을 받도록 만든 방식으로 ECB에서 발생하는 동일한 평문에 의한 동일한 암호문이 발생하지 않도록 구성한 동작 모드이다. CBC 모드 동작은 아래 그림과 같이 처음 입력된 평문 블록은 초기 벡터 (initial vector)와EX-OR되어 DES 암호기에 입력된다. 암호기 출력 암호문 은 다음 단 평문 블록 와 EX-OR되어 DES 암호기에 입력된다.

CBC 모드 동작 중 발생하는 비트 손실이나 오류에 대한 영향을 검토해보자. 전송 중에 암호문 블럭 c_i 에서 발생하는 한 비트의 오류는 복호화된 해당 평문 블럭 m_i 에서는 여러 비트의 영향을 주게되며 다음 단의 복호화된 평문 블럭 m_{i +1} 에는 한 비트의 오류를 유발하게 된다.

물론 그 다음 단의 복호화된 평문 블럭 m_i+2 에는 영향을 주지 않는다. CBC 방식의 특징은 현 단계에서 생성되는 암호문이 그 다음으로 생성되는 암호문 블럭에 영향을 미치기 때문에 특정 암호문 블럭이 전달되는 과정에서 발생되는 채널상의 잡음에 의한 오류는 해당 암호문 뿐만아니라 그 다음 암호문에도 그 효과가 연장된다.

한편 CBC 모드의 평문 블럭 m_i 에서의 오류 발생시 암호문 분석에 미치는 영향을 살펴보자.

평문 블럭 m_i 에서의 한 비트 오류는 그 다음에 출력되는 모든 암호문 블럭 c_i  , c_i+1 , c_i+2…에 영향을 미치게 된다. 이러한 특징은 메시지 인증에 유용하게 사용될 수 있다. 구체적으로 말하면 이러한 특징은 문서 인증 부호 MAC(message authentication code)에 사용될  수 있다.

       3) CFB(Cipher FeedBack)

CFB 모드는 블록 암호가 스트림 암호처럼 동작하도록 한다. CBC처럼, 이 모드도 초기벡터를 이용하지만, 내부 처리가 조금 더 필요하다. CFB 모드에서 블록 암호는 블록 크기보다 작은 데이터의 조각을 암호화할 수 있다. 실제로, CFB는 하나의 비트에서부터 블록까지 어떠한 크기의 데이터도 암호화할 수 있다. 일반적으로, CFB는 동시에 한 바이트(8비트)를 암호화하거나 복호화하는 데 사용하며 이것을 CFB8이라고 한다. 

아래 그림은 CFB8을 이용한 한 바이트의 암호화를 보여준다.

『 암호화 (p→c) 』
    ① 블록 암호를 이용하여 기본적 암호의 블록 크기만큼 버퍼를 암호화.
         초기에 버퍼는 IV로 채워진다.

     ② 암호화된 버퍼의 최좌단 비트 수와 평문은 XOR로 연산됨. 그 결과 암호문이 출력됨.
         암호화된 버퍼의 나머지는 폐기됨.
         CFB8에서, 암호화된 버퍼의 최좌단 바이트는 평문과 XOR 

     ③ CFB8에서, 버퍼는 한 바이트 왼쪽으로 이동.
          암호문은 버퍼의 오른쪽편에 있는 빈 공간을 채우는 데 사용된다.
          이 버퍼는 다음 암호화에서 다시 사용될 것이다.
          이 과정이 계속되면, 버퍼는 전부 암호문으로 채우는 데 사용될 것이다.

『 복호화 (c→p) 』
   ① 버퍼는 블록 암호를 이용하여 암호화한다. 
        암호문 바이트를 복호화할 지라도, 여전히 버퍼를 암호화 하기 위해 블록 암호를 이용
        한다.

    ② 암호화된 버퍼의 최좌단 비트는 평문 출력을 처리하는 암호문과 XOR로 연산된다.
         다시, 암호화된 버퍼의 나머지는 폐기된다.

    ③ 원래 버퍼는 왼쪽으로 이동하고, 암호문으로 채워진다. 
        이 버퍼는 다음 복호화에서 다시 사용될 것이다.

       4) OFB(Output FeedBack)

OFB 모드는 내부 버퍼가 갱신되는 것을 제외하고 CFB모드처럼 동작한다.

내부 버퍼가 왼쪽으로 이동될 때, 오른쪽의 공간은 암호화된 버퍼의 가장 왼쪽 비트로 채워

진다. 이론적으로, OFB는 암호의 블록 크기보다 작거나 같은 어떠한 비트 크기로도 사용될 

수 있다. 그러나 피드백 크기가 기본적 암호의 블록 크기보다 작을 때 OFB의 성능은 떨어진

다. 단지 피드백 크기가 암호 블록 크기와 같을 때에만 사용하는 것이 좋다.



<DES.h 파일>
[CODE]
/************************************************************************/
/* DES Algorithm!
/* Jinsik, Park
/************************************************************************/
#ifndef DECLARE_DES
#define DECLARE_DES

#include "stdafx.h"
#include <string>
using namespace std;

#ifndef DLLEXPORT
#define DLLEXPORT __declspec( dllexport )
#endif

#ifndef DLLIMPORT
#define DLLIMPORT __declspec( dllimport )
#endif

#ifdef DESIMPORT
class DLLIMPORT CDES
#else
class DLLEXPORT CDES
#endif
{
public:
 CDES()
 {}
 //암호하고, 파일 이름을 넘겨 받는다.
 int DESEncrypt( char * pFileName, char * pDesFileName, char * pPassword,  int nLength );

 
 //암호하고, 저장할 파일 이름을 넘겨 받는다.
 int DESDecrypt( char * pFileName, char * pDesFileName, char * pPassword  , int nLength  );

protected :
 void DESKeyGenerate( char * pKeySource );
 //8 byte가 넘는 key를 8 byte로 줄이기
 void DESKeyTruncate( char * pKeySource );
 //Char를 2진수 코드로 만들기 
 void DESChar2Binary( int * piTarget, char * pSource, int iSourceLen );
 //8개의 2진수를 하나의 Char로 만들기
 char DESBinary2Char( int * iSource );
 void DESSwap32Bit( int * piLeftBit, int * piRightBit, int * piBufferBit );
 void DESRound( int * piLeftData, int * piRightData );
 void DESStart( int iJobType, int iDataSize, char * pSrcData, char * ptgtData );
 int DESOperation(int iJogType, char * pInput, char * pOutput, char * pKey, int nLength);
};

#endif
 [/CODE]

<DES.cpp파일>
[CODE]
#include "Stdafx.h"
#include "Define.h"   //define 
#include "DES.h"
/************************************************************************/
/* DESStart( int iJobType, int iDataSize, char * pSrcData, char * ptgtData )
/************************************************************************/
void CDES::DESStart( int iJobType, int iDataSize, char * pSrcData, char * ptgtData )
{
 int srcBinary[64] = { 0, }, tgtBinary[64] = { 0, }, binaryBuff[64] = { 0, };
 int leftData[32] = { 0, }, rightData[32] = { 0, }, swapBuff[32] = { 0, };
 int tgtIndex=0;
 char textBuff[9] = { '\0', };
 int i, j, k;

 // Data의 끝까지 가면서 암호화, 복호화 한다 
 for( i = 0, tgtIndex = 0; i < iDataSize; i++ ) 
 { 
  memset( textBuff, 0, 9 );
  // srcData에서 8자씩 textBuff로복사 
  memcpy( textBuff, ( pSrcData + tgtIndex ), 8 ); 

  // textBuff를 binary로  
  DESChar2Binary( binaryBuff, textBuff, 8 ); 

  // Initial Permutation 
  for( j = 0; j < 64; j++ )  
   srcBinary[j] = binaryBuff[ MAT_IP[j]-1 ];

  //Encryption일 경우
  if( iJobType == ENCRYPT ) 
  {
   // 하나의 64bit를 둘의 left, right data 로 나눈다
   for(j=0; j<32; j++)
   { 
    leftData[j] = srcBinary[j];
    rightData[j] = srcBinary[j+32];
   }
  }
  // 복호화 할경우 left data와 right data의 위치를 바꾼다 
  else  
  {
   // 하나의 64bit를 둘의 left, right data 로 나눈다
   for( j = 0; j < 32; j++ )
   { 
    rightData[j] = srcBinary[j];
    leftData[j] = srcBinary[j+32];
   }
  }

  DESRound( leftData, rightData );

  //Encrypt일 경우
  if( iJobType == ENCRYPT ) 
   DESSwap32Bit( leftData, rightData, swapBuff );

  // 둘의 left, right data 를 하나의 64bit로 합한다 
  for( j = 0; j < 32; j++ )
  { 
   // 또한 32bit swap을 한다 
   binaryBuff[j] = rightData[j]; 
   binaryBuff[j+32] = leftData[j];
  }

  // Inverse Initial Permutation 
  for( j = 0; j < 64; j++ ) 
   tgtBinary[j] = binaryBuff[ MAT_IP_1[j]-1 ];

  memset( textBuff, 0, 9 );

  // tgtBinary를 ascii로 변형후 textBuff에 저장 
  for( j = 0, k = 0; j < 64; j += 8, k++ ) 
   textBuff[k] = DESBinary2Char( & tgtBinary[j] );


  // textBuff의 내용을 tgtData로 복사 
  memcpy( ( ptgtData + tgtIndex ), textBuff, 8 ); 
  tgtIndex += 8;
 }
}

/************************************************************************/
/* DESSwap32Bit( int * piLeftBit, int * piRightBit, int * piBufferBit )
/************************************************************************/
void CDES::DESSwap32Bit( int * piLeftBit, int * piRightBit, int * piBufferBit )
{
 int i;

 for( i = 0; i < 32; i++)
  piBufferBit[i] = piLeftBit[i];

 for( i = 0; i < 32; i++ )
  piLeftBit[i] = piRightBit[i];

 for( i = 0; i < 32; i++ )
  piRightBit[i] = piBufferBit[i];
}

/************************************************************************/
/* DESRound( int * piLeftData, int * piRightData )
/************************************************************************/
void CDES::DESRound( int * piLeftData, int * piRightData )
{
 int sboxOut[ 32 ] = { 0, }, leftFinal[ 32 ] = { 0, }, permuOut[ 32 ] = { 0, };
 int eBuff[ 48 ] = { 0, }, eBuffOut[ 48 ] = { 0, };
 int sboxRow, sboxCol, sboxValue;
 int i, j, k, keyIndex;

 //16번의 round를 거친다 
 for( keyIndex = 0; keyIndex < 16; keyIndex++ )
 { 
  for( i = 0; i < 32; i++ )
   leftFinal[ i ] = * ( piRightData + i );

  /* E table 적용 */
  for( i = 0; i < 48; i++ )
  {  
   eBuff[ i ] = * ( piRightData + ( MAT_EXP[ i ] -1 ) );
  }

  // eBuff xor key 
  for( i = 0; i < 48; i++ )
  {  
   eBuffOut[i] = eBuff[i] ^ KEY[keyIndex][i];
  }

  // sBox 적용 
  for( i = 0, j = 0, k = 0; i < 8; i++ )
  { 
   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 );
   sboxOut[k+3] = sboxValue & 1; 
   j += 6;
   k += 4;
  }

  //sboxOut 에 p table적용 
  for( i = 0; i < 32; i++ )  
   permuOut[ i ] = sboxOut[ MAT_PERMU[ i ] - 1 ];  

  // permuOut xor leftData 를 rightData에 저장
  for( i = 0; i < 32; i++ ) 
  {  
   * ( piRightData + i ) = * ( piLeftData + i ) ^ permuOut[ i ];
  }

  //첨에 복사한 leftFinal을 leftData에 복사 
  for( i = 0; i < 32; i++ )  
   * ( piLeftData + i ) = leftFinal[ i ];
 }
}

/************************************************************************/
/* DESKeyGenerate( char * pKeySource )
/************************************************************************/
void CDES::DESKeyGenerate( char * pKeySource )
{
 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, tmp1, tmp2, srcLen;

 //입력된 암호의 길이가 8자 이상일 경우 Truncate해 줌
 if( ( strlen( pKeySource ) ) > 8 ) /* 입력된 암호의 길이가 8자 이상이면 */
  DESKeyTruncate( pKeySource );

 strncpy( tempKey, pKeySource, 8 );
 tempKey[8] = '\0';

 srcLen = strlen( tempKey );
 DESChar2Binary( binaryKey, tempKey, srcLen );
 memset( tempKey, 0, 8 );

 //64bit를 56bit로 줄이는거 
 for( i = 0; i < 56; i++ )  
  pc1[i] = binaryKey[ MAT_PC_1[i]-1 ];

 for( i = 0; i < 16; i++ )
 {
  for( j = 0; j < keySchedule[ i ]; j++ )
  {
   tmp1 = pc1[0];
   tmp2 = pc1[28];
   for(k=1; k<28; k++)
   {
    pc1[k-1] = pc1[k];
    pc1[k+27] = pc1[k+28];
   }
   pc1[27] = tmp1;
   pc1[55] = tmp2;
  }
  //56bit 를 48bit로 줄여서 저장 - 최종 key 
  for(j=0; j<48; j++)  
   KEY[i][j] = pc1[ MAT_PC_2[j]-1 ];
 }
}

/************************************************************************/
/* DESKeyTruncate( char * pKeySource )
/************************************************************************/
void CDES::DESKeyTruncate( char * pKeySource )
{
 char * temp;
 int srcLen = 0, dev4;
 int i, j;

 srcLen = strlen( pKeySource );
 temp = ( char * )malloc( srcLen + 1 );
 memset( temp, 0, srcLen +1 );
 strcpy( temp, pKeySource );
 memset( pKeySource, 0, srcLen );

 dev4 = srcLen / 4;

 srcLen-- ;

 for(i=0,j=0;i<4;i++,j+=dev4)
 {
  * ( pKeySource + i ) = * ( temp + srcLen - j );
  * ( pKeySource + i + 4 ) = * ( temp + j );
 }  
}

/************************************************************************/
/* DESChar2Binary( int * piTarget, char * pSource, int iSourceLen )
/* char 를 binary형태로 만들기 
/************************************************************************/
void CDES::DESChar2Binary( int * piTarget, char * pSource, int iSourceLen )
{
 int targetIndex = 0, i, j;
 char oneChar, temp1, temp2;

 for( i = 0 ; i < iSourceLen; i++)
 {
  oneChar=*( pSource + i);
  for( j = 7; j >= 0; j-- )
  {
   temp1 = oneChar >> j;
   temp2 = temp1 & 0x0001;
   * ( piTarget + targetIndex ) = ( temp2 == 1 ? 1 : 0 );
   targetIndex++;
  }
 }
}

/************************************************************************/
/* DESBinary2Char( int * iSource )
/* 8개의 2진수를 하나의 Char로 만듬 
/************************************************************************/
char CDES::DESBinary2Char( int * iSource )
{
 char temp;
 int i, j, inTemp=1, chTemp=0;

 for( i = 0; i < 8; i++ )
 {
  inTemp=1;
  if( * ( iSource + i) ) 
  {
   for(j=7; j>i; j--)
    inTemp *= 2;
   chTemp += inTemp;
  }
 }
 temp=chTemp;
 return temp;
}

/************************************************************************/
/* DESEncrypt( char * pFileName, char * pDesFileName, char * pPassword  )
/************************************************************************/
int CDES::DESEncrypt( char * pFileName, char * pDesFileName, char * pPassword, int nLength  )
{
 return DESOperation( ENCRYPT, pFileName, pDesFileName, pPassword, nLength);
}

/************************************************************************/
/* DESDecrypt( char * pFileName, char * pDesFileName, char * pPassword  )
/************************************************************************/
int CDES::DESDecrypt( char * pFileName, char * pDesFileName, char * pPassword, int nLength  )
{
 return DESOperation( DECRYPT, pFileName, pDesFileName, pPassword, nLength);
}

/************************************************************************/
/* DESOperation(int iJogType, char * pFileName, char * pDesFileName, char * pPassword  )
/************************************************************************/
int CDES::DESOperation(int iJogType, char * pInput, char * pOutput, char * pKey, int nLength)
{
 int tempKey[16][48];
 long int datasize = 0, readSize = 0, writesize = nLength;
 char * pInputBuff, * pOutputBuff;
 char nameTemp[100] = {0, };
 char qprkDes[100] = {0, };
 int i, j;

 DESKeyGenerate(pKey);

 
 if(iJogType == DECRYPT)
 {
  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];
   }
  }
 }
 
 pInputBuff = new char [BUFFSIZE];
 pOutputBuff = new char [BUFFSIZE];

 int iCount = 0;

 int iRength = ( ! iJogType ) ? (( nLength / RWSIZE ) + 1 ) :
         ( nLength / RWSIZE );
 for( i = 0; i < iRength ; i++ )
 { 
  ZeroMemory(pInputBuff, BUFFSIZE);
  ZeroMemory(pOutputBuff, BUFFSIZE);

  if(writesize > RWSIZE)
  {
   memcpy(pInputBuff, &pInput[readSize], RWSIZE);
  }
  else
  {
   memcpy(pInputBuff, &pInput[readSize], writesize);
  }
 
  //Encrypt 시작
  DESStart( iJogType, RWSIZE / 8, pInputBuff, pOutputBuff ); 
  //memcpy(&pOutput[readSize], pOutputBuff, RWSIZE);
 
  if(writesize > RWSIZE)
   memcpy(&pOutput[readSize], pOutputBuff, RWSIZE);
  
  readSize += RWSIZE;
  writesize -=  RWSIZE;
 }

 delete [] pInputBuff;
 pInputBuff = NULL;
 delete [] pOutputBuff;
 pOutputBuff = NULL;
 
 return readSize - writesize; 
}
[/CODE]