amplengin2님의 이글루

암호 알고리즘 종류

amplengin2 — Sat, 08 Aug 2009 14:32:09 GMT

출처 : http://blog.naver.com/kant77?Redirect=Log&logNo=80019703395

각종 암호 알고리즘

블럭 암호	(64 비트) DES, DES3, DESX, RC5, BLOWFISH, CAST128, IDEA, SAFER , RC2
	(128 비트) SEED, CRYPTON, CAST256, RC6, TWOFISH, RIJNDAEL, MARS, SERPENT
	Mode of Operation : ECB, ECB_CTS, CBC, CBC_PAD, CBC_CTS, OFB, CFB, Counter
스트림 암호	RC4, SEAL
해쉬 함수	MD5, SHA1, SHA256, SHA384, SHA512, RMD128, RMD160, RMD256, RMD320, HAS160, TIGER
MAC 함수	HMAC-XXX, KMAC-XXX (XXX : 해쉬 함수)
MAC 함수	YYY-MAC (YYY : 블럭 암호); FIPS 113, ISO/IEC 9797-1)
공개키 암호	RSA (PKCS#1 v2.1, P1363)
공개키 서명	RSA (PKCS#1 v2.1, P1363), DSA (FIPS186-2), ECDSA (X9.62), KCDSA (표준안), ECKCDSA (표준안)
키 분배	Diffie-Hellman (DH) (PKCS#3, X9.42, RFC 2631)
키 분배	Elliptic Curve Diffie-Hellman (EC-DH)
키 암호화	RFC 2630, S/MIME WG Drafts, Proprieatary
키 유도	Password-based : PKCS#5, PKCS#12, PKIX (RFC 2510)
키 유도	General : IEEE P1363, X9.42, IPSEC, etc.

tag : 암호알고리즘

DES, 3DES, AES, DSA, ECDSA, SHA1, SHA2

amplengin2 — Sat, 08 Aug 2009 14:25:21 GMT

출처 : http://blog.naver.com/willflow00?Redirect=Log&logNo=60001556381

미연방 표준 암호 알고리즘

미연방 표준 알고리즘들에 대한 표준 문서, 소스 코드(테스트 벡터 포함) 등을 제공합니다.

DES/3DES/AES

SHA1/SHA2

DSA/ECDSA

DES/3DES/AES

DES(Data Encryption Standard)는 Lucifer를 보완하여 IBM에서 개발한 블럭암호 알고리즘으로 1977년에 미국 표준국(U.S. National Bureau of Standards : NBS, NIST 전신)에서 표준으로 채택(FIPS PUB 46)되었읍니다. 64비트 입력 블럭을 56비트 비밀키를 이용하여 암호화하는 블럭암호 알고리즘이며, 미국 연방정부의 데이터 보호용으로 출발하여 ANSI(American National Standards Institute)의 표준 암호 알고리즘, ABA(American Bankers' Association)에서 미국내 금융 정보의 보호 표준으로 사용하기까지 사용 범위가 확대되어 현재 전세계적으로 가장 널리 사용되고 있습니다. 그러나 56비트라는 짧은 키 길이로 인해 더 이상 안전하지 않다고 보는 것이 일반적인 견해이며, IPSEC이나 PKIX 등 새로운 응용들에서는 DES를 3회 반복는 Triple DES를 사용하도록 권고하였으며, 최근 차세대 미국 표준인 AES가 확정됨에 따라 앞으로 점차적으로 그 사용범위가 줄어들 것으로 보입니다.

DES의 56비트라는 짧은 키 길이로 인한 안전성 문제를 해결하기 위한 대안으로 3개의 키로 DES를 3회 반복하여 사용하는 Triple DES를 사용하였읍니다. 3DES는 속도가 DES보다 3배 정도 느리다는 단점에도 불구하고, 기존의 DES를 이용하여 쉽게 구현되며 DES의 안전성 문제를 해결하는 장점으로 인하여 여러 표준에서 사용되었습니다. 최근 차세대 미국 표준인 AES가 확정됨에 따라 앞으로 점차적으로 그 사용범위가 줄어들 것으로 보입니다.

1998년을 기점으로 표준 기한이 만료된 DES를 대체할 블럭암호의 필요성에 따라, NIST에서는 향후 정부와 상업계에서 사용할 수 있는 강한 암호화 알고리즘 표준으로 AES(Advanced Encryption Standard)의 개발을 추진하였읍니다. NIST는 3DES보다 더 효율적이고 안전하며 로얄티가 없어야 하는 등을 만족하는 알고리즘을 공모하고, 3년여에 걸쳐 15개의 후보 알고리즘을 공개적으로 평가하여, 2000년 10월 2일 최종 AES 알고리즘을 선정/발표하였읍니다. AES에 채택된 블럭암호는 Daemem과 Rijmen에 의해 개발되고 RIJNDAEL로 명명된 알고리즘으로 DES와 Triple DES를 대신해서 새로운 업계 표준으로 자리잡게 될 것입니다.

DES : 표준문서(pdf), local copy, 관련정보(htm), 소스코드(zip).
3DES : 관련정보(htm), 소스코드(zip).
AES : 관련정보, 소스코드(zip).

SHA1/SHA2

SHA1는 미 연방정부의 디지탈 서명 표준인 DSA를 위해 개발된 해쉬함수로 MD5와 유사한 구조로 설계되었으나 보다 안전한 것으로 인정되고 있습니다. 160비트 길이의 출력을 내며, 대부분의 인터넷 응용이나 국제/업계 표준들에서 DEFAULT 해쉬함수로 사용되고 있습니다.

SHA2는 보다 높은 수준의 안전성이 요구되는 응용을 위해 만들어진 해쉬 알고리즘들로 256비트, 384비트, 512비트 길이의 출력을 내며, 현재 FIPS에서 표준화를 추진중에 있습니다.

SHA1 : 표준문서(htm), 소스코드(zip).
SHA2 : 관련정보(html), 소스코드(sha256, zip), 소스코드(sha384, zip), 소스코드(sha512, zip).

DSA/ECDSA

DSA(Digital Signature Algorithm)는 1991년 8월에 NIST(National Institution of Standard and Technology)가 DSS(Digital Signature Standard)에서 사용하기 위하여 발표한 정부용 전자서명 알고리즘으로 그 안전성은 이산대수 문제의 어려움에 기반을 두었읍니다.

ECDSA는 DSA 전자서명을 타원곡선을 이용한 전자서명 알고리즘으로 변형한 것으로, 다른 공개키 시스템의 키 길이에 비해서 훨씬 짧은 키를 사용하여도 동일한 안전도를 제공하므로 스마트 카드, 무선 통신 등과 같이 메모리와 처리능력이 제한된 분야에서 매우 효과적일 수 있읍니다.

DSA : 표준문서(pdf), local copy, 소스코드(zip).
ECDSA : 관련정보(htm).

tag : DES, 3DES, AES, DSA, ECDSA, SHA1, SHA2, 소스코드, 소스, 암호

C언어에서 디버그 메시지 출력 2

amplengin2 — Wed, 05 Aug 2009 01:31:52 GMT

#include
#include

void log( char *format, ...)
{
va_list ap;
FILE *fp = NULL;

fp = fopen( "log.txt", "a");

va_start( ap, format);

vfprintf( fp, format, ap);
fprintf( fp, "\n");

fclose(fp);

va_end(ap);
}

tag : 디버그

C언어에서 디버그 메시지

amplengin2 — Tue, 04 Aug 2009 18:02:34 GMT

출처 : http://telpitz.tistory.com/157

해당 파일명과 현재 라인수가 출력

#define DEBUG printf("File: %s, Line: %d \n",__FILE__, __LINE__);

tag : 디버그, 메시지, 파일명, 라인수

AES 소스코드

amplengin2 — Wed, 29 Jul 2009 21:18:41 GMT

출처 : http://www.geocities.com/malbrain/aestable_c.html

// advanced encryption standard
// author: karl malbrain, malbrain@yahoo.com

/*
This work, including the source code, documentation
and related data, is placed into the public domain.

The orginal author is Karl Malbrain.

THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY
OF ANY KIND, NOT EVEN THE IMPLIED WARRANTY OF
MERCHANTABILITY. THE AUTHOR OF THIS SOFTWARE,
ASSUMES _NO_ RESPONSIBILITY FOR ANY CONSEQUENCE
RESULTING FROM THE USE, MODIFICATION, OR
REDISTRIBUTION OF THIS SOFTWARE.
*/

typedef unsigned char uchar;
#include
#include

// AES only supports Nb=4
#define Nb 4 // number of columns in the state & expanded key

#define Nk 4 // number of columns in a key
#define Nr 10 // number of rounds in encryption

uchar Sbox[256] = { // forward s-box
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};

uchar InvSbox[256] = { // inverse s-box
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d};

// combined Xtimes2[Sbox[]]
uchar Xtime2Sbox[256] = {
0xc6, 0xf8, 0xee, 0xf6, 0xff, 0xd6, 0xde, 0x91, 0x60, 0x02, 0xce, 0x56, 0xe7, 0xb5, 0x4d, 0xec,
0x8f, 0x1f, 0x89, 0xfa, 0xef, 0xb2, 0x8e, 0xfb, 0x41, 0xb3, 0x5f, 0x45, 0x23, 0x53, 0xe4, 0x9b,
0x75, 0xe1, 0x3d, 0x4c, 0x6c, 0x7e, 0xf5, 0x83, 0x68, 0x51, 0xd1, 0xf9, 0xe2, 0xab, 0x62, 0x2a,
0x08, 0x95, 0x46, 0x9d, 0x30, 0x37, 0x0a, 0x2f, 0x0e, 0x24, 0x1b, 0xdf, 0xcd, 0x4e, 0x7f, 0xea,
0x12, 0x1d, 0x58, 0x34, 0x36, 0xdc, 0xb4, 0x5b, 0xa4, 0x76, 0xb7, 0x7d, 0x52, 0xdd, 0x5e, 0x13,
0xa6, 0xb9, 0x00, 0xc1, 0x40, 0xe3, 0x79, 0xb6, 0xd4, 0x8d, 0x67, 0x72, 0x94, 0x98, 0xb0, 0x85,
0xbb, 0xc5, 0x4f, 0xed, 0x86, 0x9a, 0x66, 0x11, 0x8a, 0xe9, 0x04, 0xfe, 0xa0, 0x78, 0x25, 0x4b,
0xa2, 0x5d, 0x80, 0x05, 0x3f, 0x21, 0x70, 0xf1, 0x63, 0x77, 0xaf, 0x42, 0x20, 0xe5, 0xfd, 0xbf,
0x81, 0x18, 0x26, 0xc3, 0xbe, 0x35, 0x88, 0x2e, 0x93, 0x55, 0xfc, 0x7a, 0xc8, 0xba, 0x32, 0xe6,
0xc0, 0x19, 0x9e, 0xa3, 0x44, 0x54, 0x3b, 0x0b, 0x8c, 0xc7, 0x6b, 0x28, 0xa7, 0xbc, 0x16, 0xad,
0xdb, 0x64, 0x74, 0x14, 0x92, 0x0c, 0x48, 0xb8, 0x9f, 0xbd, 0x43, 0xc4, 0x39, 0x31, 0xd3, 0xf2,
0xd5, 0x8b, 0x6e, 0xda, 0x01, 0xb1, 0x9c, 0x49, 0xd8, 0xac, 0xf3, 0xcf, 0xca, 0xf4, 0x47, 0x10,
0x6f, 0xf0, 0x4a, 0x5c, 0x38, 0x57, 0x73, 0x97, 0xcb, 0xa1, 0xe8, 0x3e, 0x96, 0x61, 0x0d, 0x0f,
0xe0, 0x7c, 0x71, 0xcc, 0x90, 0x06, 0xf7, 0x1c, 0xc2, 0x6a, 0xae, 0x69, 0x17, 0x99, 0x3a, 0x27,
0xd9, 0xeb, 0x2b, 0x22, 0xd2, 0xa9, 0x07, 0x33, 0x2d, 0x3c, 0x15, 0xc9, 0x87, 0xaa, 0x50, 0xa5,
0x03, 0x59, 0x09, 0x1a, 0x65, 0xd7, 0x84, 0xd0, 0x82, 0x29, 0x5a, 0x1e, 0x7b, 0xa8, 0x6d, 0x2c
};

// combined Xtimes3[Sbox[]]
uchar Xtime3Sbox[256] = {
0xa5, 0x84, 0x99, 0x8d, 0x0d, 0xbd, 0xb1, 0x54, 0x50, 0x03, 0xa9, 0x7d, 0x19, 0x62, 0xe6, 0x9a,
0x45, 0x9d, 0x40, 0x87, 0x15, 0xeb, 0xc9, 0x0b, 0xec, 0x67, 0xfd, 0xea, 0xbf, 0xf7, 0x96, 0x5b,
0xc2, 0x1c, 0xae, 0x6a, 0x5a, 0x41, 0x02, 0x4f, 0x5c, 0xf4, 0x34, 0x08, 0x93, 0x73, 0x53, 0x3f,
0x0c, 0x52, 0x65, 0x5e, 0x28, 0xa1, 0x0f, 0xb5, 0x09, 0x36, 0x9b, 0x3d, 0x26, 0x69, 0xcd, 0x9f,
0x1b, 0x9e, 0x74, 0x2e, 0x2d, 0xb2, 0xee, 0xfb, 0xf6, 0x4d, 0x61, 0xce, 0x7b, 0x3e, 0x71, 0x97,
0xf5, 0x68, 0x00, 0x2c, 0x60, 0x1f, 0xc8, 0xed, 0xbe, 0x46, 0xd9, 0x4b, 0xde, 0xd4, 0xe8, 0x4a,
0x6b, 0x2a, 0xe5, 0x16, 0xc5, 0xd7, 0x55, 0x94, 0xcf, 0x10, 0x06, 0x81, 0xf0, 0x44, 0xba, 0xe3,
0xf3, 0xfe, 0xc0, 0x8a, 0xad, 0xbc, 0x48, 0x04, 0xdf, 0xc1, 0x75, 0x63, 0x30, 0x1a, 0x0e, 0x6d,
0x4c, 0x14, 0x35, 0x2f, 0xe1, 0xa2, 0xcc, 0x39, 0x57, 0xf2, 0x82, 0x47, 0xac, 0xe7, 0x2b, 0x95,
0xa0, 0x98, 0xd1, 0x7f, 0x66, 0x7e, 0xab, 0x83, 0xca, 0x29, 0xd3, 0x3c, 0x79, 0xe2, 0x1d, 0x76,
0x3b, 0x56, 0x4e, 0x1e, 0xdb, 0x0a, 0x6c, 0xe4, 0x5d, 0x6e, 0xef, 0xa6, 0xa8, 0xa4, 0x37, 0x8b,
0x32, 0x43, 0x59, 0xb7, 0x8c, 0x64, 0xd2, 0xe0, 0xb4, 0xfa, 0x07, 0x25, 0xaf, 0x8e, 0xe9, 0x18,
0xd5, 0x88, 0x6f, 0x72, 0x24, 0xf1, 0xc7, 0x51, 0x23, 0x7c, 0x9c, 0x21, 0xdd, 0xdc, 0x86, 0x85,
0x90, 0x42, 0xc4, 0xaa, 0xd8, 0x05, 0x01, 0x12, 0xa3, 0x5f, 0xf9, 0xd0, 0x91, 0x58, 0x27, 0xb9,
0x38, 0x13, 0xb3, 0x33, 0xbb, 0x70, 0x89, 0xa7, 0xb6, 0x22, 0x92, 0x20, 0x49, 0xff, 0x78, 0x7a,
0x8f, 0xf8, 0x80, 0x17, 0xda, 0x31, 0xc6, 0xb8, 0xc3, 0xb0, 0x77, 0x11, 0xcb, 0xfc, 0xd6, 0x3a
};

// modular multiplication tables
// based on:

// Xtime2[x] = (x & 0x80 ? 0x1b : 0) ^ (x + x)
// Xtime3[x] = x^Xtime2[x];

uchar Xtime2[256] = {
0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23, 0x21, 0x27, 0x25,
0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45,
0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5};

uchar Xtime9[256] = {
0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc,
0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01,
0xe6, 0xef, 0xf4, 0xfd, 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a,
0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa,
0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10, 0x19, 0x02, 0x0b,
0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0,
0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46};

uchar XtimeB[256] = {
0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2,
0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f,
0x46, 0x4d, 0x50, 0x5b, 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4,
0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54,
0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2e,
0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5,
0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3};

uchar XtimeD[256] = {
0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20,
0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26,
0xbd, 0xb0, 0xa7, 0xaa, 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d,
0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d,
0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56, 0x5b, 0x4c, 0x41,
0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a,
0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97};

uchar XtimeE[256] = {
0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61,
0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7,
0x4d, 0x43, 0x51, 0x5f, 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c,
0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc,
0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9, 0xe7, 0xf5, 0xfb,
0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0,
0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d};

// exchanges columns in each of 4 rows
// row0 - unchanged, row1- shifted left 1,
// row2 - shifted left 2 and row3 - shifted left 3
void ShiftRows (uchar *state)
{
uchar tmp;

// just substitute row 0
state[0] = Sbox[state[0]], state[4] = Sbox[state[4]];
state[8] = Sbox[state[8]], state[12] = Sbox[state[12]];

// rotate row 1
tmp = Sbox[state[1]], state[1] = Sbox[state[5]];
state[5] = Sbox[state[9]], state[9] = Sbox[state[13]], state[13] = tmp;

// rotate row 2
tmp = Sbox[state[2]], state[2] = Sbox[state[10]], state[10] = tmp;
tmp = Sbox[state[6]], state[6] = Sbox[state[14]], state[14] = tmp;

// rotate row 3
tmp = Sbox[state[15]], state[15] = Sbox[state[11]];
state[11] = Sbox[state[7]], state[7] = Sbox[state[3]], state[3] = tmp;
}

// restores columns in each of 4 rows
// row0 - unchanged, row1- shifted right 1,
// row2 - shifted right 2 and row3 - shifted right 3
void InvShiftRows (uchar *state)
{
uchar tmp;

// restore row 0
state[0] = InvSbox[state[0]], state[4] = InvSbox[state[4]];
state[8] = InvSbox[state[8]], state[12] = InvSbox[state[12]];

// restore row 1
tmp = InvSbox[state[13]], state[13] = InvSbox[state[9]];
state[9] = InvSbox[state[5]], state[5] = InvSbox[state[1]], state[1] = tmp;

// restore row 2
tmp = InvSbox[state[2]], state[2] = InvSbox[state[10]], state[10] = tmp;
tmp = InvSbox[state[6]], state[6] = InvSbox[state[14]], state[14] = tmp;

// restore row 3
tmp = InvSbox[state[3]], state[3] = InvSbox[state[7]];
state[7] = InvSbox[state[11]], state[11] = InvSbox[state[15]], state[15] = tmp;
}

// recombine and mix each row in a column
void MixSubColumns (uchar *state)
{
uchar tmp[4 * Nb];

// mixing column 0
tmp[0] = Xtime2Sbox[state[0]] ^ Xtime3Sbox[state[5]] ^ Sbox[state[10]] ^ Sbox[state[15]];
tmp[1] = Sbox[state[0]] ^ Xtime2Sbox[state[5]] ^ Xtime3Sbox[state[10]] ^ Sbox[state[15]];
tmp[2] = Sbox[state[0]] ^ Sbox[state[5]] ^ Xtime2Sbox[state[10]] ^ Xtime3Sbox[state[15]];
tmp[3] = Xtime3Sbox[state[0]] ^ Sbox[state[5]] ^ Sbox[state[10]] ^ Xtime2Sbox[state[15]];

// mixing column 1
tmp[4] = Xtime2Sbox[state[4]] ^ Xtime3Sbox[state[9]] ^ Sbox[state[14]] ^ Sbox[state[3]];
tmp[5] = Sbox[state[4]] ^ Xtime2Sbox[state[9]] ^ Xtime3Sbox[state[14]] ^ Sbox[state[3]];
tmp[6] = Sbox[state[4]] ^ Sbox[state[9]] ^ Xtime2Sbox[state[14]] ^ Xtime3Sbox[state[3]];
tmp[7] = Xtime3Sbox[state[4]] ^ Sbox[state[9]] ^ Sbox[state[14]] ^ Xtime2Sbox[state[3]];

// mixing column 2
tmp[8] = Xtime2Sbox[state[8]] ^ Xtime3Sbox[state[13]] ^ Sbox[state[2]] ^ Sbox[state[7]];
tmp[9] = Sbox[state[8]] ^ Xtime2Sbox[state[13]] ^ Xtime3Sbox[state[2]] ^ Sbox[state[7]];
tmp[10] = Sbox[state[8]] ^ Sbox[state[13]] ^ Xtime2Sbox[state[2]] ^ Xtime3Sbox[state[7]];
tmp[11] = Xtime3Sbox[state[8]] ^ Sbox[state[13]] ^ Sbox[state[2]] ^ Xtime2Sbox[state[7]];

// mixing column 3
tmp[12] = Xtime2Sbox[state[12]] ^ Xtime3Sbox[state[1]] ^ Sbox[state[6]] ^ Sbox[state[11]];
tmp[13] = Sbox[state[12]] ^ Xtime2Sbox[state[1]] ^ Xtime3Sbox[state[6]] ^ Sbox[state[11]];
tmp[14] = Sbox[state[12]] ^ Sbox[state[1]] ^ Xtime2Sbox[state[6]] ^ Xtime3Sbox[state[11]];
tmp[15] = Xtime3Sbox[state[12]] ^ Sbox[state[1]] ^ Sbox[state[6]] ^ Xtime2Sbox[state[11]];

memcpy (state, tmp, sizeof(tmp));
}

// restore and un-mix each row in a column
void InvMixSubColumns (uchar *state)
{
uchar tmp[4 * Nb];
int i;

// restore column 0
tmp[0] = XtimeE[state[0]] ^ XtimeB[state[1]] ^ XtimeD[state[2]] ^ Xtime9[state[3]];
tmp[5] = Xtime9[state[0]] ^ XtimeE[state[1]] ^ XtimeB[state[2]] ^ XtimeD[state[3]];
tmp[10] = XtimeD[state[0]] ^ Xtime9[state[1]] ^ XtimeE[state[2]] ^ XtimeB[state[3]];
tmp[15] = XtimeB[state[0]] ^ XtimeD[state[1]] ^ Xtime9[state[2]] ^ XtimeE[state[3]];

// restore column 1
tmp[4] = XtimeE[state[4]] ^ XtimeB[state[5]] ^ XtimeD[state[6]] ^ Xtime9[state[7]];
tmp[9] = Xtime9[state[4]] ^ XtimeE[state[5]] ^ XtimeB[state[6]] ^ XtimeD[state[7]];
tmp[14] = XtimeD[state[4]] ^ Xtime9[state[5]] ^ XtimeE[state[6]] ^ XtimeB[state[7]];
tmp[3] = XtimeB[state[4]] ^ XtimeD[state[5]] ^ Xtime9[state[6]] ^ XtimeE[state[7]];

// restore column 2
tmp[8] = XtimeE[state[8]] ^ XtimeB[state[9]] ^ XtimeD[state[10]] ^ Xtime9[state[11]];
tmp[13] = Xtime9[state[8]] ^ XtimeE[state[9]] ^ XtimeB[state[10]] ^ XtimeD[state[11]];
tmp[2] = XtimeD[state[8]] ^ Xtime9[state[9]] ^ XtimeE[state[10]] ^ XtimeB[state[11]];
tmp[7] = XtimeB[state[8]] ^ XtimeD[state[9]] ^ Xtime9[state[10]] ^ XtimeE[state[11]];

// restore column 3
tmp[12] = XtimeE[state[12]] ^ XtimeB[state[13]] ^ XtimeD[state[14]] ^ Xtime9[state[15]];
tmp[1] = Xtime9[state[12]] ^ XtimeE[state[13]] ^ XtimeB[state[14]] ^ XtimeD[state[15]];
tmp[6] = XtimeD[state[12]] ^ Xtime9[state[13]] ^ XtimeE[state[14]] ^ XtimeB[state[15]];
tmp[11] = XtimeB[state[12]] ^ XtimeD[state[13]] ^ Xtime9[state[14]] ^ XtimeE[state[15]];

for( i=0; i < 4 * Nb; i++ )
state[i] = InvSbox[tmp[i]];
}

// encrypt/decrypt columns of the key
// n.b. you can replace this with
// byte-wise xor if you wish.

void AddRoundKey (unsigned *state, unsigned *key)
{
int idx;

for( idx = 0; idx < 4; idx++ )
state[idx] ^= key[idx];
}

uchar Rcon[11] = {
0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36};

// produce Nb bytes for each round
void ExpandKey (uchar *key, uchar *expkey)
{
uchar tmp0, tmp1, tmp2, tmp3, tmp4;
unsigned idx;

memcpy (expkey, key, Nk * 4);

for( idx = Nk; idx < Nb * (Nr + 1); idx++ ) {
tmp0 = expkey[4*idx - 4];
tmp1 = expkey[4*idx - 3];
tmp2 = expkey[4*idx - 2];
tmp3 = expkey[4*idx - 1];
if( !(idx % Nk) ) {
tmp4 = tmp3;
tmp3 = Sbox[tmp0];
tmp0 = Sbox[tmp1] ^ Rcon[idx/Nk];
tmp1 = Sbox[tmp2];
tmp2 = Sbox[tmp4];
} else if( Nk > 6 && idx % Nk == 4 ) {
tmp0 = Sbox[tmp0];
tmp1 = Sbox[tmp1];
tmp2 = Sbox[tmp2];
tmp3 = Sbox[tmp3];
}

expkey[4*idx+0] = expkey[4*idx - 4*Nk + 0] ^ tmp0;
expkey[4*idx+1] = expkey[4*idx - 4*Nk + 1] ^ tmp1;
expkey[4*idx+2] = expkey[4*idx - 4*Nk + 2] ^ tmp2;
expkey[4*idx+3] = expkey[4*idx - 4*Nk + 3] ^ tmp3;
}
}

// encrypt one 128 bit block
void Encrypt (uchar *in, uchar *expkey, uchar *out)
{
uchar state[Nb * 4];
unsigned round;

memcpy (state, in, Nb * 4);
AddRoundKey ((unsigned *)state, (unsigned *)expkey);

for( round = 1; round < Nr + 1; round++ ) {
if( round < Nr )
MixSubColumns (state);
else
ShiftRows (state);

AddRoundKey ((unsigned *)state, (unsigned *)expkey + round * Nb);
}

memcpy (out, state, sizeof(state));
}

void Decrypt (uchar *in, uchar *expkey, uchar *out)
{
uchar state[Nb * 4];
unsigned round;

memcpy (state, in, sizeof(state));

AddRoundKey ((unsigned *)state, (unsigned *)expkey + Nr * Nb);
InvShiftRows(state);

for( round = Nr; round--; )
{
AddRoundKey ((unsigned *)state, (unsigned *)expkey + round * Nb);
if( round )
InvMixSubColumns (state);
}

memcpy (out, state, sizeof(state));
}

#include
#include
extern int _setmode (int, int);

uchar in[16] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};

uchar key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};

uchar out[16];

#ifndef unix
void rd_clock (__int64 *ans)
{
unsigned dwLow, dwHigh;

__asm {
rdtsc
mov dwLow, eax
mov dwHigh, edx
}
*ans = (__int64)dwHigh << 32 | (__int64)dwLow;
}
#else
typedef long long __int64;

void rd_clock (__int64 *ans)
{
unsigned long long dwBoth;

__asm__ volatile(".byte 0x0f, 0x31" : "=A"(dwBoth));
*ans = dwBoth;
}
#endif

uchar samplekey[] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab,
0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};

uchar samplein[] = {0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31,
0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34};

void sample ()
{
uchar expkey[4 * Nb * (Nr + 1)];
unsigned idx, diff;
__int64 start, stop;

ExpandKey (samplekey, expkey);
Encrypt (samplein, expkey, out);

rd_clock(&start);

Encrypt (samplein, expkey, out);

rd_clock(&stop);
diff = stop - start;
printf ("encrypt time: %d, %d cycles per byte\n", diff, diff/16);

for( idx = 0; idx < 16; idx++ )
printf ("%.2x ", out[idx]);

printf ("\n");
Decrypt (out, expkey, in);
rd_clock(&start);
Decrypt (out, expkey, in);

rd_clock(&stop);
diff = stop - start;
printf ("decrypt time: %d, %d cycles per byte\n", diff, diff/16);

for( idx = 0; idx < 16; idx++ )
printf ("%.2x ", in[idx]);

printf ("\n");
}

void certify ()
{
uchar expkey[4 * Nb * (Nr + 1)];
unsigned idx, diff;
__int64 start, stop;

ExpandKey (key, expkey);
Encrypt (in, expkey, out);

rd_clock(&start);

Encrypt (in, expkey, out);

rd_clock(&stop);
diff = stop - start;
printf ("encrypt time: %d, %d cycles per byte\n", diff, diff/16);

for( idx = 0; idx < 16; idx++ )
printf ("%.2x ", out[idx]);

printf ("\n");
Decrypt (out, expkey, in);
rd_clock(&start);
Decrypt (out, expkey, in);

rd_clock(&stop);
diff = stop - start;
printf ("decrypt time: %d, %d cycles per byte\n", diff, diff/16);

for( idx = 0; idx < 16; idx++ )
printf ("%.2x ", in[idx]);

printf ("\n");
}

void decrypt (char *mykey, char *name)
{
uchar expkey[4 * Nb * (Nr + 1)];
FILE *fd = fopen (name, "rb");
int ch, idx = 0;

strncpy (key, mykey, sizeof(key));
ExpandKey (key, expkey);

while( ch = getc(fd), ch != EOF ) {
in[idx++] = ch;
if( idx % 16 )
continue;

Decrypt (in, expkey, out);

for( idx = 0; idx < 16; idx++ )
putchar (out[idx]);
idx = 0;
}
}

void encrypt (char *mykey, char *name)
{
uchar expkey[4 * Nb * (Nr + 1)];
FILE *fd = fopen (name, "rb");
int ch, idx = 0;

strncpy (key, mykey, sizeof(key));
ExpandKey (key, expkey);

while( ch = getc(fd), ch != EOF ) {
in[idx++] = ch;
if( idx % 16 )
continue;

Encrypt (in, expkey, out);

for( idx = 0; idx < 16; idx++ )
putchar (out[idx]);
idx = 0;
}

if( idx )
while( idx % 16 )
in[idx++] = 0;
else
return;

Encrypt (in, expkey, out);

for( idx = 0; idx < 16; idx++ )
putchar (out[idx]);
}

uchar expkey[4 * Nb * (Nr + 1)];
void mrandom (int, char *);
unsigned xrandom (void);

int aescycles ()
{
__int64 start, end;
int t;

do {
rd_clock(&start);
Encrypt (in, expkey, out);
rd_clock (&end);
t = end - start;
} while( t<= 0 || t>= 4000);
return t;
}

int bestx (int b, int loops)
{
int bestx = 0, bestxt = 0;
int x, xt, i, j;

for( x = 0; x < 256; x++ ) {
xt = 0;
for( i = 0; i < loops; i++ ) {
for( j = 0; j < 16; j++ )
in[j] = xrandom() >> 16;
in[b] = x;
xt += aescycles(); xt += aescycles(); xt += aescycles();
xt += aescycles(); xt += aescycles();
}
if( xt > bestxt )
bestx = x, bestxt = xt;
}
return bestx;
}

void bernstein (char *seed)
{
int loops, b, j, k;

mrandom (strlen(seed), seed);

for( loops = 4; loops <= 65536; loops *= 16) {
for( b = 0; b < 16; b++ ) {
printf ("%.2d, %.5d loops:", b, loops);
for( k = 0; k < 10; k++ ) {
for( j = 0; j < 16; j++ )
key[j] = xrandom() >> 16;
ExpandKey (key, expkey);
printf (" %.2x", bestx (b, loops) ^ key[b]);
fflush (stdout);
}
printf ("\n");
}
}
}

void tables()
{
int i;

for( i = 0; i < 256; i++)
{
printf("0x%.2x, ", Sbox[i] ^ Xtime2[Sbox[i]]);
if( !((i+1) % 16) )
printf("\n");
}

printf("\n");

for( i = 0; i < 256; i++)
{
printf("0x%.2x, ", Xtime2[Sbox[i]]);
if ( !((i+1) % 16) )
printf("\n");
}
}

int main (int argc, char *argv[])
{
#ifndef unix
_setmode (_fileno(stdout), _O_BINARY);
#endif

switch( argv[1][0] ) {
case 'c': certify(); break;
case 'e': encrypt(argv[2], argv[3]); break;
case 'd': decrypt(argv[2], argv[3]); break;
case 'b': bernstein(argv[2]); break;
case 's': sample(); break;
case 't': tables(); break;
}
}

/*
* The package generates far better random numbers than a linear
* congruential generator. The random number generation technique
* is a linear feedback shift register approach. In this approach,
* the least significant bit of all the numbers in the RandTbl table
* will act as a linear feedback shift register, and will have period
* of approximately 2^96 - 1.
*
*/

#define RAND_order (7 * sizeof(unsigned))
#define RAND_size (96 * sizeof(unsigned))

uchar RandTbl[RAND_size + RAND_order];
int RandHead = 0;

/*
* random: x**96 + x**7 + x**6 + x**4 + x**3 + x**2 + 1
*
* The basic operation is to add to the number at the head index
* the XOR sum of the lower order terms in the polynomial.
* Then the index is advanced to the next location cyclically
* in the table. The value returned is the sum generated.
*
*/

unsigned xrandom ()
{
register unsigned fact;

if( (RandHead -= sizeof(unsigned)) < 0 ) {
RandHead = RAND_size - sizeof(unsigned);
memcpy (RandTbl + RAND_size, RandTbl, RAND_order);
}

fact = *(unsigned *)(RandTbl + RandHead + 7 * sizeof(unsigned));
fact ^= *(unsigned *)(RandTbl + RandHead + 6 * sizeof(unsigned));
fact ^= *(unsigned *)(RandTbl + RandHead + 4 * sizeof(unsigned));
fact ^= *(unsigned *)(RandTbl + RandHead + 3 * sizeof(unsigned));
fact ^= *(unsigned *)(RandTbl + RandHead + 2 * sizeof(unsigned));
return *(unsigned *)(RandTbl + RandHead) += fact;
}

/*
* mrandom:
* Initialize the random number generator based on the given seed.
*
*/

void mrandom (int len, char *ptr)
{
unsigned short rand = *ptr;
int idx, bit = len * 4;

memset (RandTbl, 0, sizeof(RandTbl));
RandHead = 0;

while( rand *= 20077, rand += 11, bit-- )
if( ptr[bit >> 2] & (1 << (bit & 3)) )
for (idx = 0; idx < 5; idx++) {
rand *= 20077, rand += 11;
RandTbl[rand % 96 << 2] ^= 1;
}

for( idx = 0; idx < 96 * 63; idx++ )
xrandom ();
}

tag : AES, 소스코드

직장인을 위한 이메일 관리 방법

amplengin2 — Fri, 24 Jul 2009 16:49:15 GMT

출처 : http://lunaris.egloos.com/1931734

0. 스팸 메일, 바이러스나 악성 코드를 포함한 메일이 아닌 한 어떤 메일도 사본을 남겨두지 않은 상태로는 지우지 말라. 회사 생활을 하면서 주고 받는 메일은 그 자체로 '기록'으로서의 가치를 가진다. 내용이 중복된 메일이든, 일시적인 공지 메일이든, 어쨌든 지우지 마라. 물론, 당신이 회사 내의 누군가에게 보낸 메일도 마찬가지다. 언제, 누구와, 어떤 메일을 주고 받았다는 그 사실 자체가 당신의 기록으로 남아있어야 한다. 언젠가, 필요할 때 든든한 자료가 되어줄 것이다.

1. 사내 메일이 웹 메일 형태인 경우, 대개는 쿼터가 모자라서 메일을 지우게 된다. 최소한 쿼터가 모자라서 메일을 못받는 상황은 만들지 말아야 한다. (직장 생활의 에티켓이다) 하지만 언제는 메일 지우지 말라며? 당연히, 백업을 해야 한다. 대부분의 메일 서버는 POP3 서버를 내장하고 있으며, (대개 높으신 분의 필요에 의해) 일부 또는 전체 사용자에게 기능이 활성화되어있다. 또, 그렇지 않은 경우라도, 웬만하면 메시지를 eml 파일 형태로 내려받을 수 있는 기능 정도는 있다. 최악의 경우 메일들을 POP3가 되는 다른 서버로 포워딩 시켜서 받아 내려야 하는 경우도 있을 수 있겠다. 어쨌든 메일을 지우기 전에 무슨 수를 써서든 Outlook등 널리 사용되는 메일러 프로그램으로 본인 PC로 메일을 가져다 놓자.

2. 백업 이야기가 나와서 말인데, PC 밀때 파일만 백업하고 메일 백업 잊어먹는 사람들 많다. "빨래 끝은 옥시크린" 이고 "백업 끝은 메일" 이다. 중요하면 백업 작업을 시작할 때 하면 좋겠지만, 대개의 경우 백업은 오래 걸리는 작업이고 그 동안 많은 양의 메일이 도착할 가능성도 있어서 일을 두 번 하게 되는 경우가 왕왕 있다. 습관적으로 모든 백업이 끝난 후, 인터넷 선 뽑기 전에 메일을 백업하는 것을 추천한다. Outlook 을 쓰든 thunderbird 를 쓰든, 메일 데이터가 저장되는 경로는 옆사람이든 구글신에게든 물어서 꼭 파악해놓고, 가능하면 잊지 않도록 본인이 관리 가능한 영역으로 변경해두는 습관을 들이는 것도 좋다.

3. PC에서 Outlook 등의 프로그램으로 메일을 보내고 받을 때 서버와의 인증 과정에서 ID/Password가 암호화 되는지의 여부를 확인할 필요가 있다. 가급적 SSL/TLS 접속만 사용하는 것을 추천하며, 최소한 APOP, CRAM-MD5등의 인증 매커니즘을 통해 비밀번호가 암호화 되는 방식으로 접속하여야 한다. 아직도 널리 사용되는 Outlook Express의 경우, SPA를 활성화 하면 서버에서 인증을 못해주는 경우도 많고, 서버가 SSL/TLS 접속을 지원하지 않는 경우도 많아서 대개 메일 서버 관리 권한이 없는 사용자라면 애를 먹기 십상이다. 여태까지 나온 이야기를 이해할 수 없는 경우, 메일 비번은 다른 비번과 겹치지 않게 따로 설정해놓고 사용하며, 암호화를 사용하지 않는 무선 랜(맥도날드, 스타벅스, 옆 건물 AP등)에 연결된 상태에서는 절대로 이메일을 체크하지 말도록 하자.

4. 메일을 많이 주고 받는 경우, 본인에게 적절한 형태로 폴더링하고, 메일 필터링 규칙을 잘 만들어두면 관리가 훨씬 용이해진다. 본인에게 적절한 형태의 폴더링을 개발해내는 것은 본인 몫이다. 남들의 스타일을 따라가려고 애쓸 필요는 없다. 어쨌든, 문서 작성 능력만큼이나 중요한 것이 자료를 분류, 보관하는 능력이다. 고만고만한 처세술 책 읽을 시간에 본인 메일 관리할 방법이나 연구해보는 건 어떨까?

5. 혹시 서버에 쿼터가 남아 도는 행복한 환경이라면, POP3 대신 IMAP을 쓰는 것도 좋은 생각이다. 본인 컴퓨터가 바이러스 먹거나 하드 뻑나서 메일 데이터 날려먹을 확률보다는, 그래도 관리자가 공들여 관리해주는 서버가 훨씬 안정적이기 마련이다. 물론, 전술한대로, 백업은 가급적 자주 해놓도록 하자.

6. 아주 많은 사람들이 이메일 체크를 그리 자주 하지 않음에도 불구하고, 메일을 보내면 상대방이 '곧' 읽어볼 것이라고 생각하는 경향이 있다. 메일을 바로 읽어주길 바란다면 메일 보내놓고 상대에게 바로 전화를 걸자. 전화상으로 직접 이야기할 수 있을 만큼 짧은 내용이라도 '기록을 남기기 위해' 메일을 보내야 하는 경우는 빈번히 있을 수 있다. 어떤 메일에도 '빨리' 반응하고 싶다면 늘 메일 프로그램을 띄워놓든지, 아니면 새 메일이 도착한 경우 팝업을 띄워 알려주는 프로그램을 사용하는 것이 좋다. 아울러, 대부분의 메일 프로그램/서비스들이 제공하는 '수신확인' 기능은 아주 많은 경우에 동작하지 않기 때문에 믿어선 안된다. 실제로 수신 확인 기능을 구현하는 방법은 여러가지가 있지만 어느 것도 완벽하지 않다.

tag : 직장인, 관리, 이메일, 방법

“지갑 잘 분실한다면 ‘이것’을 넣어둬라”

amplengin2 — Tue, 14 Jul 2009 00:18:52 GMT

출처 : http://nownews.seoul.co.kr/news/newsView.php?id=20090713601009

길가에 떨어진 지갑을 발견했을 때, 사람들의 반응은 다양하다. 그대로 두거나 경찰서로 가져가거나 또는 우체통에 넣기도 하지만 본인의 지갑인 양 ‘꿀꺽’ 하는 경우도 많다.

하지만 지갑 속에서 ‘이것’을 발견한 사람은 대부분 지갑을 돌려준다는 연구결과가 발표됐다.

영국 하트퍼트셔 대학 연구팀이 지난 한 해 동안 사람들로 북적이는 에딘버그(Edinburgh) 한복판에 지갑 240개를 던져두고 사람들의 반응을 지켜봤다.

지갑 속에는 웃고 있는 아기사진, 귀여운 강아지 사진, 행복한 중년 부부의 사진과 가족사진 등이 담겨 있다. 또 어떤 지갑에는 사진을 넣지 않거나, 지갑의 주인이 기부활동을 한다는 카드를 넣어두기도 했다.

그 결과 총 42%의 지갑이 우편을 통해 되돌아왔으며, 아기사진이 든 지갑의 회수율은 무려 88%에 달했다.

뒤를 이어 강아지 사진이 든 지갑은 53%, 가족 사진과 행복한 중년 부부의 사진이 든 지갑은 각각 48%, 28%가 돌아왔다.

또 기부활동 카드가 든 지갑은 그렇지 않은 지갑에 비해 15~20% 포인트 더 많이 되돌아왔다.

전문가들은 아기사진이 든 지갑의 회수율이 높은 이유가 미래 세대인 아이를 안전하게 보호하려는 동정심 때문인 것으로 해석하고 있다.

심리학자인 리차드 와이즈먼 박사는 “이 결과는 사람들이 아기를 돌봐야 할 대상으로 인식하는 행동성향과 연관이 있다.”고 분석했다. 또 절반에 가까운 지갑이 되돌아 왔다는 사실에 매우 놀라움을 표했다.

와이즈먼 박사는 “지갑을 잘 잃어버리는 사람이라면, 만약을 대비해 잘 보이는 곳에 아기 사진을 넣어두길 권한다.”고 덧붙였다.

사진=flickr.com

서울신문 나우뉴스 송혜민 기자 huimin0217@seoul.co.kr

기사일자 : 2009-07-13

tag : 지갑

[MFC]다이나믹 버튼

amplengin2 — Sun, 14 Jun 2009 05:51:20 GMT

more information link http://www.codeproject.com/KB/buttons/cbuttonst.aspx

tag : button, buttonst

[MFC]시스템 핫키 등록

amplengin2 — Sun, 14 Jun 2009 05:28:44 GMT

출처 : http://panboy.tistory.com/category/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D

RegisterHotKey 사용법...

1. 시작 시기에 걸맞는 곳에다 코딩한다.

예를 들어 CMainFrame의 OnCreate에 코딩한다고 하고, Ctrl + P를 핫키로 하겠다면

멤버 변수로 int m_nHotKeyID;

m_nHotKeyID = ::GlobalAddAtom("test");

if(!::RegisterHotKey(GetSafeHwnd(), m_nHotKeyID, MOD_CONTROL, 'P'))

AfxMessageBox("핫키 등록 실패!");

2. CMainFrame에 afx_msg LONG OnHotKey(WPARAM wParam, LPARAM lParam)함수 추가하고

메시지맵에 ON_MESSAGE(WM_HOTKEY, OnHotKey)

한다. 이 때 //}}AFX_MSG_MAP 바깥에 한다.

LONG CMainFrame::OnHotKey(WPARAM wParam, LPARAM lParam)
{
if((int)wParam == m_nHotKeyID)
{
// 하고 싶은 일 구현
}
}

3. 종료할 때 핫키를 해제한다.

void CMainFrame::OnClose()
{
::UnregisterHotKey(GetSafeHwnd(), m_nHotKeyID);
}

tag : hotkey, register, system

Diffie-Hellman 키 분배 알고리즘

amplengin2 — Tue, 02 Jun 2009 12:49:44 GMT

출처 : 네트워크,보안계열,IT취업 관련사이트
http://blog.etnews.co.kr/ppyspyss/172415

Public Key 암호화 기법을 제안한 Diffie-Hellman은 이 기법에서 생성된 키를 안전
하게 송/수신자들에게 분배하는 알고리즘을 제안하였다. 즉, 이 알고리즘은 비밀키
와 공개키를 생성하여 암호화와 복호화를 수행하는 방식에 관한 알고리즘이 아니라
메세지를 주고 받으려는 두 명의 사람이 비밀리에 비밀키를 공유하기 위한 방법이라
는 것을 잊지 말도록 하자. 현재 이 방식은 상용 보안 소프트웨어에 널리 사용되고
있다

Diffie-Hellman의 키분배 알고리즘을 간단하게 설명하면 다음과 같다.

<전제 조건>

n,g : 크기가 큰 정수들로서 메세지의 송수신에 참여하는 모든 사람들에게 공개되어
있다. 그리고 특히 g값은 n보다는 작고 1보다는 크다.

1.송신자는 비교적 크기가 큰 난수 x를 발생시키고 이 값을 보관한다.

2.수신자 역시 비교적 크기가 큰 난수 y를 발생시키고 이값을 보관한다.

3.송신자는 다음의 계산을 하여 그 결과를 수신자에게 보낸다.
X = gx mod n

4.수신자는 다음의 계산을 하여 그 결과를 송신자에게 보낸다.
Y = gy mod n

5.송신자는 Y를 받아서 다음의 계산을 한 후 비밀키 Ks를 얻는다.
Ks = (Y)x mod n = gyx mod n

6.수신자는 X를 받아서 다음의 계산을 한 후 비밀키 Kr을 얻는다.
Kr = (X)y mod n = gxy mod n

위의 (e)와 (f)에서 계산된 결과인 Ks와 Kr이 같은 값을 갖는다는 것을 쉽게 알 수
있을것이다. 따라서 송신자와 수신자는 이 값을 비밀키로하여 메세지를 암호화/복호
화할 수 있게 된다.

계산된 비밀키(Kr 또는 Ks)가 왜 비밀키인가? 라고 의아해 할 독자를 위해 위의 과
정을 정리하면 다음과 같다.

◆수신자와 송신자가 주고 받는 값들(즉 공격자에게 노출될 가능성이 많은 값들)
X(=gx), Y(=gy)

◆모든 사람들이 다 알고 있는 값들(즉, 공격자도 이미 다 알고 있는 값들)
n, g

◆송신자만이 알고 있는 값(그래서 안전하다고 생각되는 값)
x

◆수신자만이 알고 있는 값(그래서 안전하다고 생각되는 값)
y

따라서 공격자가 최대한으로 얻을 수 있는 정보는 n, g, X, Y이다. 공격자들이 비밀
키를 계산하기 위해서는 x 또는 y의 값을 알아야 한다. 이 값을 알기 위해서는 다음
의 계산에서 x 또는 y를 구해야 한다.

X = gx mod n
Y = gy mod n

위의 식에 있어서 (X, g, n), (Y, g, n)을 알고 있고 n이 충분히 클 경우 x, y를
구하는 것은 수학적으로 불가능(infeasible)하다고 알려져 있다(일방향 함수의 특성
). 따라서 비밀키(Kr, Ks)는 비밀키이다.

그러나 Diffie-Hellman의 알고리즘을 공략할 수 있는 공격방법이 없는 것없는 것은
아니다. 즉, 알고리즘 자체는 수학적으로 안전하다고 할 수 있지만 사실 암호 프로
토콜중에 헛점(security hole)이 없는 것은 아무것도 없다. 소위 흉내내기 공격법(i
mpersonation attack)이란 것이 Diffie-Hellman 키 분배 프로토콜의 공격방법이다.

즉, 공격자가 송신자와 수신자의 사이에서 "송신자에게는 공격자 자신이 수신자인
것처럼" 그리고 "수신자에게는 공격자 자신이 송신자인 것처럼" 속이는 방법이다.
이방법은 다음과 같이 이루어진다.

<전제 조건>

공격자는 송신자와 수신자가 주고 받는 모든 데이타를 얻을 수 있다.

1.공격자는 송신자가 보낸 X값을 가로채서 보관하고 자신이 생성시킨 난수값 z을 이
용하여 Z를 송신자와 수신자에게 보낸다.
Z = gz mod n

2.공격자는 수신자로부터 Y값을 얻는다.

3.송신자와 수신자는 자신들이 얻은 값 Z를 이용하여 다음의 비밀키를 생성한다.
송신자 : Kxz = gxz mod n
수신자 : Kzy = gzy mod n

4.공격자는 (b)에서 얻은 X, Y 값을 이용하여 다음의 비밀키를 계산할 수 있다.
송신자용 비밀키 : gzx mod n
수신자용 비밀키 : gzy mod n

결과적으로 Kxz와 Kzy라는 두개의 비밀키가 생성되어 전자는 송신자와 공격자가 통
신을 하는 데 사용되고 후자는 공격자와 수신자가 통신을 하는데 사용된다. 당연히
송신자와 수신자는 서로가 서로에게 메세지를 안전하게(?) 주고 받는 다고 착각을
하고 있게 된다.

tag : diffie-hellman, security, key, public, 키분배, 분배