대칭알고리즘 AES.

Presentation on theme: "대칭알고리즘 AES."— Presentation transcript:

1 대칭알고리즘 AES

2 DES challenge DES Challenge 일자 해독시간 수상자 비고 I 1997년1월 96일 -DESHALL 팀구성
R.Verser -DESHALL 팀구성 -인터넷의 위력 입증 -약 24.6%의 키 공간 조사 II 1998년1월 41일 Distributed.Net -약 22,000명 참여 -약 50,000 CPU 링크 II-2 1998년7월 56시간 EFF -DES Cracker 라는 칩사용($250,000) -초당 880억개의 키를 조사하는 속도 III 1999년1월 22시간 15분 & Distrubuted.Net -Deep Crack 사용 -약 10만대의 PC 이용 -초당 2,450억개의 키 조사속도

3 AES (Advanced Encryption Standard)
1997 AES 알고리즘 공모 • 대칭키 블록 암호 알고리즘 • 입출력 크기 : 128비트 • 키 크기 : 128/192/256비트 1998 15개 후보 알고리즘 선정 1999 다섯개 알고리즘 최종후보 • MARS ,RC6 ,Rijndael ,Serpent , Twofish 2001 Rijndael 채택 • 개발자: J.Daemen, v.Rijmen

4 AES Pseudo AES(in,out,key) { KeyExpansion(Key,RoundKey) state = in
AddRoundKey (state,RoundKey[0]) for round=1 step 1 to Nr-1 SubBytes(stats) ShiftRows(stats) MixColumns(stats) AddRoundKey(stats,RoundKey[i] end for AddRoundKey(stats,RoundKeyp[Nr]) out = stats }

5 암호화 복호화

6 Rijndeal Structure 입력 구조 : 10 / 12 / 14 라운드의 SPN 구조 블록사이즈 128 비트
키 사이즈 128/192/256 비트 구조 : 10 / 12 / 14 라운드의 SPN 구조 Byte 단위의 연산을 이용 세개의 layer로 구성 14 Nk=8 12 Nk=6 10 Nk=4 Nb=8 Nb=6 Nb=4 Nr Nr : rounds Nb : block size / 32bit Nk : key size / 32bit ► Linear mixing layer 여러 라운드에 걸친 높은 확산 ShiftRow(state), MixColumn(state) ► Non-linear Layer S-box의 병렬 적용 ByteSub(state) ► Key Addition Layer 중간 state에 라운드 키의 EXOR AddRoundKey(state)

7 Nb =4 일때의 block state 와 Nk = 4 일때의 key state
Rijndael 연산들은 상태(state)라고 하는 2차원 바이트배열에 수행된다 State는 2차원 배열로 구성된다.행은 4행으로 구성되고 , 각 행은 Nb 바이트로 구성된다 . A0,0 A0,1 A0,2 A0,3 A1,1 A1,2 A1,3 A2,0 A2,1 A2,2 A2,3 A3,0 A3,1 A3,2 A3,3 K0,0 K0,1 K0,2 K0,3 K1,1 K1,2 K1,3 K2,0 K2,1 K2,2 K2,3 K3,0 K3,1 K3,2 K3,3 Nb =4 일때의 block state 와 Nk = 4 일때의 key state ex) 128비트 입력 : EA 83 5C F D 65 5D 98 AD B0 C5 EA 04 65 85 83 45 5D 96 5C 33 98 B0 F0 2D AD C5

8 GF(28)에서 곱셈에 대한 역원 ◈곱셈에 대한 역원 찾기
만약 GCD(d,f)=1이라면 그때 d는 modulo f 상에서 곱셈에 대한 역원을 갖는다. 양의 정수 d<f에 대해, dd-1=1 mod f인 d-1<f가 존재 • Extended Euclid(d,f) 1. (X1, X2, X3)<-(1,0,f);(Y1, Y2, Y3)<-(0,1,d) 2. If X3= 0 return X3=GCD(d,f); no inverse 3. If X3 = 1 return Y3=GCD(d,f); Y2=d-1 mod f 4. Q = X3 / Y3 5. (T1, T2, T3) <- (X1-QY1, X2-QY2, X3-QY3) 6. (X1, X2, X3) <- (Y1, Y2, Y3) 7. (Y1, Y2, Y3) <- (T1, T2, T3) 8. Goto 2

9 GF(28)에서 곱셈에 대한 역원 ex) GF(28) 에서 95의 곱셈에 대한 역구하기
GCD(95,m(x))=1 m(x)=x8 +x4 +x3+x b(x)=x7 +x4 +x2+1 A1(x)=1 , A2(x)=0 , A3(x) = x8 +x4 +x3+x+1 B1(x)=0 , B2(x)=1 , B3(x) = x7 +x4 +x2+1 1.Q(x)=(x8 +x4 +x3+x+1) /(x7 +x4 +x2+1) = x [T1,T2,T3]<-[1-x·0 ,0-x·1 , (x8 +x4 +x3+x+1) –x·(x7 +x4 +x2+1)] A1(x)=0 A2(x)=1 A3(x)=x7 +x4 +x2+1 B1(x)=1 B2(x)=x B3(x)=x5 +x4+1 2.Q(x)= (x7 +x4 +x2+1) / (x5 +x4+1) = x2 +x+1 [T1,T2,T3]<-[0-(x2 +x+1)·1 ,1-(x2 +x+1)·x , (x7 +x4 +x2+1) –(x2 +x+1)·(x5 +x4 +1)] A1(x)=1 A2(x)=x A3(x)=x5 +x4 +1 B1(x)=x2 +x+1 B2(x)=x3+x2 +x+1 B3(x)=x 3.Q(x)=(x5+x4 +1) / x = x4 +x3 [T1,T2,T3]<-[1-(x4 +x3)·(x2 +x+1) ,x-(x4 +x3)·(x3+x2 +x+1) , (x5 +x4 +1) –(x4 +x3)·x] <-[x6 +x3 , x7+x3 +x ,1] A1(x)=x2 +x+1 A2(x)=x3+x2 +x+1 A3(x)=x B1(x)=x6 +x3 B2(x)=x7+x3 +x B3(x)=1 B3(x)=1 이므로 B2(x)=B(x)-1 mod m(x) B2(x)=x7+x3 +x = 8A ∴ 95-1 = 8A

10 Substitute Bytes Transformation
◈ state 의 각 바이트를 치환 • 각 바이트를 16x16 s-box를 이용하여 치환 • 8비트를 상위 4비트가 행, 하위 4비트가 열로 사용.

11 Substitute Bytes Transformation
• S-box()는 기약다항식 m(x) = x8 +x4 +x3+x+1을 사용하여 구성한다. • 구성방법 • 먼저 s-box()에 00,01,...,FF 순으로 초기화 한다. • 이 값들을 GF(28)에서 곱셈에 대한 역원으로 매핑한다. 00 -> 00 • 한 항의 값이 b7b6b5b4b3b2b1b0 이면 다음 식에 의해 변형된다. bi ’ =bi ⊕ b(i+4)mod 8 ⊕ b(i+6)mod 8 ⊕ b(i+7)mod 8 ⊕ ci i 를 0 ~ 7까지 대입하여 정리하면 아래식이 나온다 . 그리고 뒤에 63은 임의로 주어진 1 바이트 수 이다 . 95 = 95-1 = 8A

12 S-box

13 Inverse Substitute Bytes Transformation
• Inverse s-box 는 s-box()의 bi ’ =bi ⊕ b(i+4)mod 8 ⊕ b(i+6)mod 8 ⊕ b(i+7)mod 8 ⊕ ci 의 역을 적용한 다음 GF(28)에서 곱셈에 대한 역원으로 구성한다. 역변환은 bi ’ = b(i+2)mod 8 ⊕ b(i+5)mod 8 ⊕ b(i+7)mod 8 ⊕ di 이며 바이트 d는 63의 곱셈에 대한 역원인 05 이다. b´0 b´1 b´2 b´3 b´4 b´5 b´6 b´7 b0 b1 b2 b3 b4 b5 b6 b7 = + 1

14 Inverse S-box

15 Shift row Transformation
• 각행을 행의 index 만큼 왼쪽으로 circular shift 함 .

16 Mix Column • Mix column에서는 state의 column이 GF()에서의 다항식 a(x)가 고정된 다항식 c(x)에 대해 a(x) ⊕ c(x) mod (x4+1) 연산을 행한다. • c(x) = ’03’ x3 + ’01’ x2 + ’01’ x + ’02’ • d(x) = ’0B’x3 + ’0D’x2 + ’09’x + ’0E’ • m(x) = x4+1 최고차항이 4차 보다 작은 두 다항식 a(x) b(x)가 있다고 가정하면 a(x)= a3x3 +a2x2 +a1x+a0 , b(x)= b3x3 +b2x2 +b1x+b0 이다 c(x)= a(x)b(x) 하면 c(x)= c6x6 +c5x5 +c4x4 +c3x3 +c2x2 +c1x1+c0 c0 = a0•b0 c1 = a1•b0  a0 •b1 c2 = a2•b0  a1•b1  a0•b2 c3 = a3•b0  a2•b1  a1•b2  a0•b3 c4 = a3•b1  a2•b2  a1•b3 c5 = a3•b2  a2•b3 c6 = a3•b3

17 Mix Column c(x)의 최고차항이 4보다 크기때문에 mod m(x) 연산을 해주면 그값은 아래와 같다.
c(x)mod m(x)= d(x) = d3x3 +d2x2 +d1x+d0 = c3x3 +c2x2+c6x2 +c1x+c5x+c4 +c0 d0 = a0•b0  a3•b1  a2•b2  a1•b3 d1 = a1•b0  a0•b1  a3•b2  a2• b3 d2 = a2•b0  a1•b1  a0•b2  a3• b3 d3 = a3•b0  a2•b1  a1•b2  a0• b3 위 식을 간단히 하면 아래와 같이 된다. b0 b1 b2 b3 d0 d1 d2 d3 = a0 a3 a2 a1 a1 a0 a3 a2 a2 a1 a0 a3 a3 a2 a1 a0 d0 d1 d2 d3 = b0 b1 b2 b3

18 Mix Column 87 6E 46 A6 47 37 94 ED =

19 The round key addition • 라운드 키는 키 스케줄에 의해 생성된 키들과 state의 EXOR 이다.

20 Key expansion Pseudo code

21 Key expansion •128 비트 키를 4Nr+4 개의 32비트 워드로 확장

22 대칭알고리즘 SEED

23 개 요 SEED Feistel 구조 1999년 2월 한국정보보호센터(現 한국정보보호진흥원)에서 개발
개 요 SEED 1999년 2월 한국정보보호센터(現 한국정보보호진흥원)에서 개발 민간 부분인 인터넷, 전자상거래, 무선 통신에 이용 블록암호알고리즘 Feistel 구조

24 개발 목적 전자상거래등 Network상 전송 Data의 안전성 보장 목적으로 개발 DES 64의 해독과 국내 표준의 필요
256/(60*60*24*365*106) ~= 2285년 Network상의 Parallel처리로 56시간 내에 해독 128 bit Block Encryption Algorithm ~= 1025년 3중 DES보다 Software적으로 빠른 Algorithm, Hardware적으로도 구현이 용이함을 목표 Smart card에 적합 정보보호센터(KISA) 주관 암호전문가들이 개발

25 개발 현황 추진현황 1997년 9월 ~ 1998년 9월 128 bit Block Algorithm(SEED) 초안 개발 완료
1998년 9월 2일 ~ 1998년 9월 30일 암호알고리즘 초안 1차 자체 평가 완료 1998년 10월 29일 ~ 1999년 2월 15일 공개 검증을 위한 의견 수렴 공고(Algorithm 공개) 1999년 2월 128비트 암호알고리즘 표준 SEED [TTAS.KO ] 개발 1999년 3월 30일 표준 최종안 확정 1999년 9월 28일 표준 제정 완료(TTAS KO )

26 설계 기준 데이터 처리단위 : 8, 16, 32 bit 모두 가능 암ㆍ복호화 방식 : Block 암호 방식
안전성 : DC/LC에 대하여 안전하도록 설계 효율성 : 암ㆍ복호화 속도는 3중 DES 이상 구 조 : Feistel 구조

27 설계 기준 (계속) 내부함수 Round 수 Key 생성 알고리즘
SPN 구조이며, 비선형함수를 Look-up table로 변형하여 사용 연산은 + , + 만 사용 DC, LC에 대한 이론적 안전성 증명 가능 내부함수 F의 구조는 DES, MISTY등과 비교하여 우수함 Round 수 안전성은 Key 전수 조사공격에 필요한 계산 복잡도 Key 생성 알고리즘 알고리즘의 라운드 동작과 동시에 암/복호화 라운드 키가 생성될 수 있도록 설계 □ ○

28 SEED의 초안 ● 연산 기호의 정의 ○ a + b : a bit-wise Exclusive-Or b ○
○ a + b : (a + b) mod 232 □ ○ a & b : a bit-wise AND b ○ X<<s : X를 s bit 만큼 왼쪽으로 순환 이동하는 연산 ○ X>>s : X를 s bit 만큼 오른쪽으로 순환 이동하는 연산 ○ Li : i Round에서 출력된 왼쪽 Message Block (64 bit) ○ Ri : i Round에서 출력된 오른쪽 Message Block (64 bit) ○ Ki = (Ki,0, Ki,1) : i Round의 Round Key (64 bit) ○ Ki,0 : i Round F함수의 오른쪽 입력 Key (32 bit) ○ Ki,1 : i Round F함수의 왼쪽 입력 Key (32 bit) ○ X = (X3 || X2 || X1 || X0) : G함수의 입력 값 (32 bit) ○ Y = (Y3 || Y2 || Y1 || Y0) : G함수에서 S-Box(S1, S2)의 출력 값 (32 bit) ○ Z = (Z3 || Z2 || Z1 || Z0) : G함수의 출력 값 (32 bit) ○ mi : 상수 ○ KCi : Round Key 생성 과정에서 사용되는 i + 1 Round 상수

29 전체 구성도 L0 F K1 R0 L1 K2 R1 L15 K15 R15 L16 R16 SEED 전체 구조도

30 F 함수 입력 : 32 bit 2개의 Block(C, D) 출력 : 32 bit 2개의 Block(C’, D’)
Ki,0 Ki,1 G C’ D’ 입력 : 32 bit 2개의 Block(C, D) 출력 : 32 bit 2개의 Block(C’, D’) 사용되는 키 : 64 bit Key Ki(=(Ki,0 ; Ki,1)) C’ = G[G[G{(C + Ki,0) + (D + Ki,1)} + (C + Ki,0)] + G{(C + Ki,0) + (D + Ki,1)}] + G[G{(C + Ki,0) + (D + Ki,1)} + (C + Ki,0)] ○ □ D’ = G[G[G{(C + Ki,0) + (D + Ki,1)} + (C + Ki,0)] + G{(C + Ki,0) + (D + Ki,1)}] ○ □

31 G 함수의 초안 두 개의 8비트 S-Box를 이용하여 입력의 각 바이트를 비선형 변환
그 결과 32 bit를 4 bit 왼쪽 회전이동한 후 출력 즉, G함수의 입력 32 bit를 4개의 8 bit Block (X3, X2, X1, X0)으로 분할 2개의 S-Box를 (S2, S1, S2, S1) 순서로 적용시켜 (Y3, Y2, Y1, Y0)를 생성하고, 4 bit 왼쪽 회전이동 후, 4개의 8 bit Block (Z3, Z2, Z1, Z0)을 생성 Y3 = (Y31, Y30) = S2(X3) Z3 = (Y30, Y21) Y2 = (Y21, Y20) = S1(X2) Z2 = (Y20, Y11) Y1 = (Y11, Y10) = S2(X1) , Z1 = (Y10, Y01) Y0 = (Y01, Y00) = S1(X0) Z0 = (Y00, Y31)

32 4 bit left shift rotation
G 함수의 초안 (계속) MSB LSB X3 X2 X1 X0 S2 S1 4 bit left shift rotation Z3 Z2 Z1 Z0

33 G 함수의 수정안 G함수에서 SEED 초안의 G함수 회전이동부분에 대한 약간의 수정을 가하였다.
단지 4 bit 회전 -> Byte들 간에 diffusion을 주지 못함 S-Box의 확률적 특성 ->각 워드의 상위 Byte의 difference가 다른 Byte에 영향을 주지 않는 truncated differential들이 높은 확률로 발생 SEED 초안의 G함수 회전이동부분에 대한 약간의 수정을 가하였다. Y3 = S2(X3), Y2 = S1(X2), Y1 = S2(X1), Y0 = S1(X0) Z3 = (Y0&m3) + (Y1&m0) + (Y2&m1) + (Y3&m2) ○ Z2 = (Y0&m2) + (Y1&m3) + (Y2&m0) + (Y3&m1) ○ Z1 = (Y0&m1) + (Y1&m2) + (Y2&m3) + (Y3&m0) ○ Z0 = (Y0&m0) + (Y1&m1) + (Y2&m2) + (Y3&m3) ○ (단, m0 = 0xfc, m1 = 0xf3, m2 = 0xcf, m3 = 0x3f)

34 G 함수의 수정안 (계속) X3 X2 X1 X0 S2 S1 Z3 Z2 Z1 Z0 &m3 &m2 &m1 &m0 &m3 &m2

35 S-Box 비선형 S-Box S1, S2는 다음의 식을 이용하여 생성 (n1=247, n2=251, b1=159, b2=56)
Si : Z28 → Z28, S(x) = A(i)ㆍxni + bi ○ MSB LSB A = A(1) = A(2) = 각 S-Box에 사용된 행렬 A(1), A(2)는 A의 행을 교환하여 사용한다. ( A(1) = A의 2행과 3행을 교환, 4행과 6행을 교환 A(2) = A의 1행과 5행을 교환, 6행과 7행을 교환 ) A는 nonsingular matrix이므로, 서로 다른 2개의 입력 x, x’에 대하여 Ax ≠ Ax’ 이다

36 S1 < S1-Box >

37 S2 < S2-Box >

38 Round Key 생성 Algorithm 입력 : 128 bit의 Key
128 bit 입력 Key를 32 bit 4개의 조각으로 나눈다 (A, B, C, D) K1,0 = G(A + C - KC0), K1,1 = G(B + KC0 – D) (단, KC0 : Round 상수)로 1 Round Key를 생성 B || A = (B || A)>>8 K2,0 = G(A + C – KC1), K2,1 = G(B + KC1 – D) (단, KC1 : Round 상수)로 2 Round Key를 생성 D || C = (D || C)<<8 K3,0 = G(A + C – KC2), K3,1 = G(B + KC2 – D) (단, KC2 : Round 상수)로 2 Round Key를 생성 이후 16 Round Key 생성까지 반복

39 Round Key 생성 Algorithm (계속)
for(i = 1; i ≥ 16; i++) { Ki,0 ← G(A + C - KCi-1); Ki,1 ← G(B + D - KCi-1); if(i % 2 == 1) A||B ← (A||B)>>8; else C||D ← (C||D)<<8; } Round 상수 KCi는 황금비의 소수 부분으로부터 다음과 같이 생성 KC0 = int( × 232 ) = 0x9e3779b9 5 - 1 2 KCi = KCi-1<< for 1 ≤ I ≤ 15 상 수 KC0 = 0x9e3779b9 KC8 = 0x3779b99e KC1 = 0x3c6ef373 KC9 = 0x6ef3733c KC2 = 0x78dde6e6 KC10 = 0xdde6e678 KC3 = 0xf1bbcdcc KC11 = 0xbbcdccf1 KC4 = 0xe3779b99 KC12 = 0x779b99e3 KC5 = 0xc6ef3733 KC13 = 0xef3733c6 KC6 = 0x8dde6e67 KC14 = 0xde6e678d KC7 = 0x1bbcdccf KC15 = 0xbcdccf1b

40 Round Key 생성 Algorithm (계속)
B C D KC0 + - G K 1,0 - + G K 1,1 A || B KC0 >>8 A B C D KC1 + - G K 2,0 - + G K 2,1 C || D KC1 <<8 A B C D

41 취약성 분석 Block 크기와 Key의 길이가 128bit 이면 충분한 안전도를 갖는다고 간주됨 (현재의 환경에서는 안전한 Key size) DES는 56비트의 길이를 갖는 경우도 56시간 만에 해독 가능 1998년 7월 $250,000 Chip으로 해독됨 (RSA DES Challenge Ⅱ) Differential Crypto-analysis, Linear Crypto-analysis 공격에 대해 안전

42 SEED와 DES의 비교 SEED와 DES의 구현차이 전체 Round와 제어 구조는 유사
구 분 DES SEED Structure Feistel Block length 64 128 Key length 64(56) Number of rounds 16 Characteristic Symmetric, Block SEED와 DES의 구현차이 전체 Round와 제어 구조는 유사 DES의 경우 XOR연산과 Permutation연산만을 사용하여 처리함으로써 Hardware로 구현하는 경우 속도 향상 SEED의 경우 Adder와 G함수의 잦은 사용으로Adder와 G함수의 속도 향상이 전체 성능을 좌우 Characteristic 특징 / 특성 / 특질 Symmetric <수학> 대칭[상칭]의

43 seedx.h /***************************************************** *
* FILE: seedx.h * DESCRIPTION: header file for seedx.c ******************************************************/ #ifndef SEED_H #define SEED_H /********************** Include files *******************/ #include <stdio.h> #include <stdlib.h> #include <string.h> /********************* Type Definitions *****************/ #ifndef TYPE_DEFINITION #define TYPE_DEFINITION #if defined(__alpha) typedef unsigned int DWORD; typedef unsigned short WORD; #else typedef unsigned long int DWORD; typedef unsigned short int WORD; #endif typedef unsigned char BYTE; /******************* Constant Definitions ****************/ #define NoRounds #define NoRoundKeys (NoRounds*2) #define SeedBlockSize /* in bytes */ #define SeedBlockLen /* in bits */ /********************** Common Macros *******************/ #if defined(_MSC_VER) #define ROTL(x, n) (_lrotl((x), (n))) #define ROTR(x, n) (_lrotr((x), (n))) #else #define ROTL(x, n) (((x) << (n)) | ((x) >> (32-(n)))) #define ROTR(x, n) (((x) >> (n)) | ((x) << (32-(n)))) #endif /**************** Function Prototype Declarations *********/ #ifndef PROTOTYPES #define PROTOTYPES 1 #if PROTOTYPES #define PROTO_LIST(list) list #define PROTO_LIST(list) () void SeedEncrypt PROTO_LIST((BYTE *pbData, DWORD *pdwRoundKey)); void SeedDecrypt void SeedEncRoundKey PROTO_LIST((DWORD *pdwRoundKey, BYTE *pbUserKey)); void SeedDecRoundKey /*************************************************************/

44 seedx.c #define EndianChange(dwS)
( (ROTL((dwS), 8) & (DWORD)0x00ff00ff) | (ROTL((dwS), 24) & (DWORD)0xff00ff00) ) /************************ Block Encryption **************/ void SeedEncrypt(BYTE *pbData, DWORD *pdwRoundKey) { DWORD L0, L1, R0, R1, T0, T1, *K = pdwRoundKey; L0 = ((DWORD *)pbData)[0]; L1 = ((DWORD *)pbData)[1]; R0 = ((DWORD *)pbData)[2]; R1 = ((DWORD *)pbData)[3]; #ifndef BIG_ENDIAN L0 = EndianChange(L0); L1 = EndianChange(L1); R0 = EndianChange(R0); R1 = EndianChange(R1); #endif SeedRound(L0, L1, R0, R1, K ); /* 1 */ SeedRound(R0, R1, L0, L1, K+ 2); /* 2 */ SeedRound(L0, L1, R0, R1, K+ 4); /* 3 */ SeedRound(R0, R1, L0, L1, K+ 6); /* 4 */ SeedRound(L0, L1, R0, R1, K+ 8); /* 5 */ SeedRound(R0, R1, L0, L1, K+10); /* 6 */ SeedRound(L0, L1, R0, R1, K+12); /* 7 */ SeedRound(R0, R1, L0, L1, K+14); /* 8 */ SeedRound(L0, L1, R0, R1, K+16); /* 9 */ SeedRound(R0, R1, L0, L1, K+18); /* 10 */ SeedRound(L0, L1, R0, R1, K+20); /* 11 */ SeedRound(R0, R1, L0, L1, K+22); /* 12 */ #if NoRounds == 16 SeedRound(L0, L1, R0, R1, K+24); /* 13 */ SeedRound(R0, R1, L0, L1, K+26); /* 14 */ SeedRound(L0, L1, R0, R1, K+28); /* 15 */ SeedRound(R0, R1, L0, L1, K+30); /* 16 */ /******************************************************* * * FILE: seedx.c * * DESCRIPTION: Core routines for the enhanced SEED ********************************************************/ #include "seedx.h" #include "seedx.tab" #include<iostream> using std::cout; using std::endl; /******************* Encryption/Decryption **************/ #define GetB0(A) ( (BYTE)((A) ) ) #define GetB1(A) ( (BYTE)((A)>> 8) ) #define GetB2(A) ( (BYTE)((A)>>16) ) #define GetB3(A) ( (BYTE)((A)>>24) ) #define SeedRound(L0, L1, R0, R1, K) { T0 = R0 ^ (K)[0]; T1 = R1 ^ (K)[1]; T1 ^= T0; T1 = SS0[GetB0(T1)] ^ SS1[GetB1(T1)] ^ SS2[GetB2(T1)] ^ SS3[GetB3(T1)]; T0 += T1; T0 = SS0[GetB0(T0)] ^ SS1[GetB1(T0)] ^ SS2[GetB2(T0)] ^ SS3[GetB3(T0)]; T1 += T0; L0 ^= T0; L1 ^= T1; }

45 seedx.c /******************** Key Scheduling ****************/
/* Constants for key schedule: KC0 = golden ratio; KCi = ROTL(KCi-1, 1) */ #define KC x9e3779b9UL #define KC x3c6ef373UL #define KC x78dde6e6UL #define KC xf1bbcdccUL #define KC xe3779b99UL #define KC xc6ef3733UL #define KC x8dde6e67UL #define KC x1bbcdccfUL #define KC x3779b99eUL #define KC x6ef3733cUL #define KC xdde6e678UL #define KC xbbcdccf1UL #if NoRounds == 16 #define KC x779b99e3UL #define KC xef3733c6UL #define KC xde6e678dUL #define KC xbcdccf1bUL #endif #define EncRoundKeyUpdate0(K, A, B, C, D, KC) { T0 = A; A = (A>>8) ^ (B<<24); B = (B>>8) ^ (T0<<24); T0 = A + C - KC; T1 = B + KC - D; (K)[0] = SS0[GetB0(T0)] ^ SS1[GetB1(T0)] ^ SS2[GetB2(T0)] ^ SS3[GetB3(T0)]; (K)[1] = SS0[GetB0(T1)] ^ SS1[GetB1(T1)] ^ SS2[GetB2(T1)] ^ SS3[GetB3(T1)]; } #define EncRoundKeyUpdate1(K, A, B, C, D, KC) { T0 = C; C = (C<<8) ^ (D>>24); D = (D<<8) ^ (T0>>24); T0 = A + C - KC; T1 = B + KC - D; (K)[0] = SS0[GetB0(T0)] ^ SS1[GetB1(T0)] ^ SS2[GetB2(T0)] ^ SS3[GetB3(T0)]; (K)[1] = SS0[GetB0(T1)] ^ SS1[GetB1(T1)] ^ SS2[GetB2(T1)] ^ SS3[GetB3(T1)]; } /* Encryption key schedule */ void SeedEncRoundKey(DWORD *pdwRoundKey, BYTE *pbUserKey) { DWORD A, B, C, D, T0, T1, *K=pdwRoundKey; A = ((DWORD *)pbUserKey)[0]; B = ((DWORD *)pbUserKey)[1]; C = ((DWORD *)pbUserKey)[2]; D = ((DWORD *)pbUserKey)[3]; #ifndef BIG_ENDIAN A = EndianChange(A); B = EndianChange(B); C = EndianChange(C); D = EndianChange(D); #endif

46 seedx.c #ifndef BIG_ENDIAN L0 = EndianChange(L0);
R0 = EndianChange(R0); R1 = EndianChange(R1); #endif ((DWORD *)pbData)[0] = R0; ((DWORD *)pbData)[1] = R1; ((DWORD *)pbData)[2] = L0; ((DWORD *)pbData)[3] = L1; } /* same as encrypt, except that round keys are applied in reverse order. */ void SeedDecrypt(BYTE *pbData, DWORD *pdwRoundKey) { DWORD L0, L1, R0, R1, T0, T1, *K=pdwRoundKey; L0 = ((DWORD *)pbData)[0]; L1 = ((DWORD *)pbData)[1]; R0 = ((DWORD *)pbData)[2]; R1 = ((DWORD *)pbData)[3]; #if NoRounds == 16 SeedRound(L0, L1, R0, R1, K+30); /* 1 */ SeedRound(R0, R1, L0, L1, K+28); /* 2 */ SeedRound(L0, L1, R0, R1, K+26); /* 3 */ SeedRound(R0, R1, L0, L1, K+24); /* 4 */ SeedRound(L0, L1, R0, R1, K+22); /* 5 */ SeedRound(R0, R1, L0, L1, K+20); /* 6 */ SeedRound(L0, L1, R0, R1, K+18); /* 7 */ SeedRound(R0, R1, L0, L1, K+16); /* 8 */ SeedRound(L0, L1, R0, R1, K+14); /* 9 */ SeedRound(R0, R1, L0, L1, K+12); /* 10 */ SeedRound(L0, L1, R0, R1, K+10); /* 11 */ SeedRound(R0, R1, L0, L1, K+ 8); /* 12 */ SeedRound(L0, L1, R0, R1, K+ 6); /* 13 */ SeedRound(R0, R1, L0, L1, K+ 4); /* 14 */ SeedRound(L0, L1, R0, R1, K+ 2); /* 15 */ SeedRound(R0, R1, L0, L1, K+ 0); /* 16 */ #ifndef BIG_ENDIAN L0 = EndianChange(L0); L1 = EndianChange(L1); R0 = EndianChange(R0); R1 = EndianChange(R1); #endif ((DWORD *)pbData)[0] = R0; ((DWORD *)pbData)[1] = R1; ((DWORD *)pbData)[2] = L0; ((DWORD *)pbData)[3] = L1; }

47 seedx.c int main(int argc, char** argv) { BYTE pbData[32];
BYTE pbUserKey[32]; DWORD pdwRoundKey[32]; int i; for(i=0; i<16;i++) { pbData[i] = i; pbUserKey[i] = 0x00; } printf("\nPlainText : 0x "); for(i=0;i<16;i++) printf("%2X ",pbData[i]); printf("\nKey : 0x "); printf("%2X ",pbUserKey[i]); //Create Encryption Key SeedEncRoundKey (pdwRoundKey, pbUserKey); //Encryption Key SeedEncrypt (pbData,pdwRoundKey);// Encryption printf("\nCipherText : 0x "); // Create Decryption key // Don't create key because we are knew key already // SeedDecRoundKey (pdwRoundKey,pbUserKey); //Decryption Key SeedDecrypt (pbData,pdwRoundKey); //Decryption printf("\nDecryptionText : 0x "); return 0; }; T0 = A + C - KC0; T1 = B - D + KC0; K[0] = SS0[GetB0(T0)] ^ SS1[GetB1(T0)] ^ SS2[GetB2(T0)] ^ SS3[GetB3(T0)]; K[1] = SS0[GetB0(T1)] ^ SS1[GetB1(T1)] ^ SS2[GetB2(T1)] ^ SS3[GetB3(T1)]; EncRoundKeyUpdate0(K+ 2, A, B, C, D, KC1 ); EncRoundKeyUpdate1(K+ 4, A, B, C, D, KC2 ); EncRoundKeyUpdate0(K+ 6, A, B, C, D, KC3 ); EncRoundKeyUpdate1(K+ 8, A, B, C, D, KC4 ); EncRoundKeyUpdate0(K+10, A, B, C, D, KC5 ); EncRoundKeyUpdate1(K+12, A, B, C, D, KC6 ); EncRoundKeyUpdate0(K+14, A, B, C, D, KC7 ); EncRoundKeyUpdate1(K+16, A, B, C, D, KC8 ); EncRoundKeyUpdate0(K+18, A, B, C, D, KC9 ); EncRoundKeyUpdate1(K+20, A, B, C, D, KC10); EncRoundKeyUpdate0(K+22, A, B, C, D, KC11); #if NoRounds == 16 EncRoundKeyUpdate1(K+24, A, B, C, D, KC12); EncRoundKeyUpdate0(K+26, A, B, C, D, KC13); EncRoundKeyUpdate1(K+28, A, B, C, D, KC14); EncRoundKeyUpdate0(K+30, A, B, C, D, KC15); #endif } /************************ END ****************************/

48 seedx.tab static DWORD SS0[256] = {
0x2989a1a8, 0x , 0x16c6d2d4, 0x13c3d3d0, 0x , 0x1d0d111c, 0x2c8ca0ac, 0x , 0x1d4d515c, 0x , 0x , 0x1e0e121c, 0x , 0x3cccf0fc, 0x0acac2c8, 0x , 0x , 0x , 0x , 0x1d8d919c, 0x20c0e0e0, 0x22c2e2e0, 0x08c8c0c8, 0x , 0x2585a1a4, 0x0f8f838c, 0x , 0x3b4b7378, 0x3b8bb3b8, 0x , 0x12c2d2d0, 0x2ecee2ec, 0x , 0x0c8c808c, 0x3f0f333c, 0x2888a0a8, 0x , 0x1dcdd1dc, 0x36c6f2f4, 0x , 0x2ccce0ec, 0x , 0x0b0b0308, 0x , 0x1c4c505c, 0x1b4b5358, 0x3d8db1bc, 0x , 0x , 0x1c0c101c, 0x , 0x , 0x , 0x0cccc0cc, 0x32c2f2f0, 0x19c9d1d8, 0x2c0c202c, 0x27c7e3e4, 0x , 0x , 0x1b8b9398, 0x11c1d1d0, 0x , 0x09c9c1c8, 0x , 0x , 0x2383a3a0, 0x2bcbe3e8, 0x0d0d010c, 0x3686b2b4, 0x1e8e929c, 0x0f4f434c, 0x3787b3b4, 0x1a4a5258, 0x06c6c2c4, 0x , 0x2686a2a4, 0x , 0x2f8fa3ac, 0x15c5d1d4, 0x , 0x03c3c3c0, 0x3484b0b4, 0x , 0x , 0x3d4d717c, 0x0d8d818c, 0x , 0x1f0f131c, 0x , 0x , 0x , 0x , 0x , 0x37c7f3f4, 0x21c1e1e0, 0x3dcdf1fc, 0x , 0x2f0f232c, 0x , 0x3080b0b0, 0x0b8b8388, 0x0e0e020c, 0x2b8ba3a8, 0x2282a2a0, 0x2e4e626c, 0x , 0x0d4d414c, 0x , 0x3c4c707c, 0x , 0x0a0a0208, 0x3f8fb3bc, 0x2fcfe3ec, 0x33c3f3f0, 0x05c5c1c4, 0x , 0x , 0x3ecef2fc, 0x , 0x1eced2dc, 0x2e0e222c, 0x0b4b4348, 0x1a0a1218, 0x , 0x , 0x2b4b6368, 0x , 0x , 0x35c5f1f4, 0x , 0x0a8a8288, 0x0c0c000c, 0x3383b3b0, 0x3e4e727c, 0x10c0d0d0, 0x3a4a7278, 0x , 0x , 0x25c5e1e4, 0x , 0x , 0x2d8da1ac, 0x1fcfd3dc, 0x2181a1a0, 0x , 0x , 0x2e8ea2ac, 0x , 0x , 0x , 0x , 0x34c4f0f4, 0x2787a3a4, 0x , 0x0c4c404c, 0x , 0x29c9e1e8, 0x , 0x , 0x , 0x0bcbc3c8, 0x0ecec2cc, 0x3c0c303c, 0x , 0x , 0x07c7c3c4, 0x , 0x , 0x3bcbf3f8, 0x1acad2d8, 0x38c8f0f8, 0x , 0x , 0x , 0x04c4c0c4, 0x3fcff3fc, 0x , 0x , 0x , 0x00c0c0c0, 0x0fcfc3cc, 0x17c7d3d4, 0x3888b0b8, 0x0f0f030c, 0x0e8e828c, 0x , 0x , 0x , 0x2c4c606c, 0x1bcbd3d8, 0x2484a0a4, 0x , 0x31c1f1f0, 0x , 0x02c2c2c0, 0x2f4f636c, 0x3d0d313c, 0x2d0d212c, 0x , 0x3e8eb2bc, 0x3e0e323c, 0x3c8cb0bc, 0x01c1c1c0, 0x2a8aa2a8, 0x3a8ab2b8, 0x0e4e424c, 0x , 0x3b0b3338, 0x1cccd0dc, 0x , 0x3f4f737c, 0x1c8c909c, 0x18c8d0d8, 0x0a4a4248, 0x , 0x , 0x2080a0a0, 0x2dcde1ec, 0x , 0x3585b1b4, 0x2b0b2328, 0x , 0x3acaf2f8, 0x23c3e3e0, 0x3989b1b8, 0x3181b1b0, 0x1f8f939c, 0x1e4e525c, 0x39c9f1f8, 0x26c6e2e4, 0x3282b2b0, 0x , 0x2acae2e8, 0x2d4d616c, 0x1f4f535c, 0x24c4e0e4, 0x30c0f0f0, 0x0dcdc1cc, 0x , 0x , 0x3a0a3238, 0x , 0x14c4d0d4, 0x , 0x , 0x , 0x , 0x28c8e0e8, 0x1b0b1318, 0x , 0x , 0x , 0x2a4a6268, 0x2a0a2228, 0x1a8a9298 };

49 seedx.tab static DWORD SS1[256] = {
0x , 0xe828c8e0, 0x2c2d0d21, 0xa42686a2, 0xcc0fcfc3, 0xdc1eced2, 0xb03383b3, 0xb83888b0, 0xac2f8fa3, 0x , 0x , 0xc407c7c3, 0x , 0x6c2f4f63, 0x682b4b63, 0x581b4b53, 0xc003c3c3, 0x , 0x , 0xb43585b1, 0x , 0xa02080a0, 0xe022c2e2, 0xa42787a3, 0xd013c3d3, 0x , 0x , 0x , 0x1c1c0c10, 0xbc3c8cb0, 0x , 0x480b4b43, 0xec2fcfe3, 0x , 0x6c2c4c60, 0xa82888a0, 0x , 0xc404c4c0, 0x , 0xf434c4f0, 0xc002c2c2, 0x , 0xe021c1e1, 0xd416c6d2, 0x3c3f0f33, 0x3c3d0d31, 0x8c0e8e82, 0x , 0x , 0x4c0e4e42, 0xf436c6f2, 0x3c3e0e32, 0xa42585a1, 0xf839c9f1, 0x0c0d0d01, 0xdc1fcfd3, 0xd818c8d0, 0x282b0b23, 0x , 0x783a4a72, 0x , 0x2c2f0f23, 0xf031c1f1, 0x , 0x , 0xd414c4d0, 0x , 0xc000c0c0, 0x , 0x , 0xac2c8ca0, 0x880b8b83, 0xf437c7f3, 0xac2d8da1, 0x , 0x1c1f0f13, 0xc80acac2, 0x2c2c0c20, 0xa82a8aa2, 0x , 0xd012c2d2, 0x080b0b03, 0xec2ecee2, 0xe829c9e1, 0x5c1d4d51, 0x , 0x , 0xf838c8f0, 0x , 0xac2e8ea2, 0x , 0xc405c5c1, 0x , 0xcc0dcdc1, 0x , 0xb83989b1, 0xfc3fcff3, 0x7c3d4d71, 0xc001c1c1, 0x , 0xf435c5f1, 0x880a8a82, 0x682a4a62, 0xb03181b1, 0xd011c1d1, 0x , 0xd417c7d3, 0x , 0x , 0x , 0x , 0x , 0x , 0xd81bcbd3, 0x9c1d8d91, 0x , 0x , 0xbc3e8eb2, 0xe426c6e2, 0x , 0xdc1dcdd1, 0x , 0x , 0xdc1cccd0, 0x981a8a92, 0xa02383a3, 0xa82b8ba3, 0xd010c0d0, 0x , 0x0c0f0f03, 0x , 0x181a0a12, 0xe023c3e3, 0xec2ccce0, 0x8c0d8d81, 0xbc3f8fb3, 0x , 0x783b4b73, 0x5c1c4c50, 0xa02282a2, 0xa02181a1, 0x , 0x , 0x4c0d4d41, 0xc808c8c0, 0x9c1e8e92, 0x9c1c8c90, 0x383a0a32, 0x0c0c0c00, 0x2c2e0e22, 0xb83a8ab2, 0x6c2e4e62, 0x9c1f8f93, 0x581a4a52, 0xf032c2f2, 0x , 0xf033c3f3, 0x , 0x , 0xcc0cccc0, 0x , 0xf83bcbf3, 0x , 0x , 0x7c3f4f73, 0x , 0x , 0x , 0x , 0x6c2d4d61, 0xc406c6c2, 0x , 0xd415c5d1, 0xb43484b0, 0xe82acae2, 0x , 0x , 0x , 0xfc3ecef2, 0x , 0x , 0xe020c0e0, 0xbc3d8db1, 0x , 0xf83acaf2, 0x , 0xf030c0f0, 0x282a0a22, 0x5c1e4e52, 0xa82989a1, 0x , 0x , 0x , 0x , 0x , 0x981b8b93, 0xb03080b0, 0xe425c5e1, 0x , 0x , 0x , 0xfc3cccf0, 0x1c1e0e12, 0x , 0x , 0x8c0c8c80, 0x181b0b13, 0x5c1f4f53, 0x , 0x , 0xb03282b2, 0x1c1d0d11, 0x , 0x4c0f4f43, 0x , 0x , 0xec2dcde1, 0x , 0x , 0xe82bcbe3, 0x7c3e4e72, 0xd81acad2, 0xc809c9c1, 0xfc3dcdf1, 0x , 0x , 0x , 0x3c3c0c30, 0xb43686b2, 0xe424c4e0, 0xb83b8bb3, 0x7c3c4c70, 0x0c0e0e02, 0x , 0x , 0x , 0x , 0x , 0x , 0x , 0x , 0xe427c7e3, 0x , 0xa42484a0, 0xc80bcbc3, 0x , 0x080a0a02, 0x , 0xd819c9d1, 0x4c0c4c40, 0x , 0x8c0f8f83, 0xcc0ecec2, 0x383b0b33, 0x480a4a42, 0xb43787b3 };

50 seedx.tab static DWORD SS2[256] = {
0xa1a82989, 0x , 0xd2d416c6, 0xd3d013c3, 0x , 0x111c1d0d, 0xa0ac2c8c, 0x , 0x515c1d4d, 0x , 0x , 0x121c1e0e, 0x , 0xf0fc3ccc, 0xc2c80aca, 0x , 0x , 0x , 0x , 0x919c1d8d, 0xe0e020c0, 0xe2e022c2, 0xc0c808c8, 0x , 0xa1a42585, 0x838c0f8f, 0x , 0x73783b4b, 0xb3b83b8b, 0x , 0xd2d012c2, 0xe2ec2ece, 0x , 0x808c0c8c, 0x333c3f0f, 0xa0a82888, 0x , 0xd1dc1dcd, 0xf2f436c6, 0x , 0xe0ec2ccc, 0x , 0x03080b0b, 0x , 0x505c1c4c, 0x53581b4b, 0xb1bc3d8d, 0x , 0x , 0x101c1c0c, 0x , 0x , 0x , 0xc0cc0ccc, 0xf2f032c2, 0xd1d819c9, 0x202c2c0c, 0xe3e427c7, 0x , 0x , 0x93981b8b, 0xd1d011c1, 0x , 0xc1c809c9, 0x , 0x , 0xa3a02383, 0xe3e82bcb, 0x010c0d0d, 0xb2b43686, 0x929c1e8e, 0x434c0f4f, 0xb3b43787, 0x52581a4a, 0xc2c406c6, 0x , 0xa2a42686, 0x , 0xa3ac2f8f, 0xd1d415c5, 0x , 0xc3c003c3, 0xb0b43484, 0x , 0x , 0x717c3d4d, 0x818c0d8d, 0x , 0x131c1f0f, 0x , 0x , 0x , 0x , 0x , 0xf3f437c7, 0xe1e021c1, 0xf1fc3dcd, 0x , 0x232c2f0f, 0x , 0xb0b03080, 0x83880b8b, 0x020c0e0e, 0xa3a82b8b, 0xa2a02282, 0x626c2e4e, 0x , 0x414c0d4d, 0x , 0x707c3c4c, 0x , 0x02080a0a, 0xb3bc3f8f, 0xe3ec2fcf, 0xf3f033c3, 0xc1c405c5, 0x , 0x , 0xf2fc3ece, 0x , 0xd2dc1ece, 0x222c2e0e, 0x43480b4b, 0x12181a0a, 0x , 0x , 0x63682b4b, 0x , 0x , 0xf1f435c5, 0x , 0x82880a8a, 0x000c0c0c, 0xb3b03383, 0x727c3e4e, 0xd0d010c0, 0x72783a4a, 0x , 0x , 0xe1e425c5, 0x , 0x , 0xa1ac2d8d, 0xd3dc1fcf, 0xa1a02181, 0x , 0x , 0xa2ac2e8e, 0x , 0x , 0x , 0x , 0xf0f434c4, 0xa3a42787, 0x , 0x404c0c4c, 0x , 0xe1e829c9, 0x , 0x , 0x , 0xc3c80bcb, 0xc2cc0ece, 0x303c3c0c, 0x , 0x , 0xc3c407c7, 0x , 0x , 0xf3f83bcb, 0xd2d81aca, 0xf0f838c8, 0x , 0x , 0x , 0xc0c404c4, 0xf3fc3fcf, 0x , 0x , 0x , 0xc0c000c0, 0xc3cc0fcf, 0xd3d417c7, 0xb0b83888, 0x030c0f0f, 0x828c0e8e, 0x , 0x , 0x , 0x606c2c4c, 0xd3d81bcb, 0xa0a42484, 0x , 0xf1f031c1, 0x , 0xc2c002c2, 0x636c2f4f, 0x313c3d0d, 0x212c2d0d, 0x , 0xb2bc3e8e, 0x323c3e0e, 0xb0bc3c8c, 0xc1c001c1, 0xa2a82a8a, 0xb2b83a8a, 0x424c0e4e, 0x , 0x33383b0b, 0xd0dc1ccc, 0x , 0x737c3f4f, 0x909c1c8c, 0xd0d818c8, 0x42480a4a, 0x , 0x , 0xa0a02080, 0xe1ec2dcd, 0x , 0xb1b43585, 0x23282b0b, 0x , 0xf2f83aca, 0xe3e023c3, 0xb1b83989, 0xb1b03181, 0x939c1f8f, 0x525c1e4e, 0xf1f839c9, 0xe2e426c6, 0xb2b03282, 0x , 0xe2e82aca, 0x616c2d4d, 0x535c1f4f, 0xe0e424c4, 0xf0f030c0, 0xc1cc0dcd, 0x , 0x , 0x32383a0a, 0x , 0xd0d414c4, 0x , 0x , 0x , 0x , 0xe0e828c8, 0x13181b0b, 0x , 0x , 0x , 0x62682a4a, 0x22282a0a, 0x92981a8a };

51 seedx.tab static DWORD SS3[256] = {
0x , 0xc8e0e828, 0x0d212c2d, 0x86a2a426, 0xcfc3cc0f, 0xced2dc1e, 0x83b3b033, 0x88b0b838, 0x8fa3ac2f, 0x , 0x , 0xc7c3c407, 0x , 0x4f636c2f, 0x4b63682b, 0x4b53581b, 0xc3c3c003, 0x , 0x , 0x85b1b435, 0x , 0x80a0a020, 0xc2e2e022, 0x87a3a427, 0xc3d3d013, 0x , 0x , 0x , 0x0c101c1c, 0x8cb0bc3c, 0x , 0x4b43480b, 0xcfe3ec2f, 0x , 0x4c606c2c, 0x88a0a828, 0x , 0xc4c0c404, 0x , 0xc4f0f434, 0xc2c2c002, 0x , 0xc1e1e021, 0xc6d2d416, 0x0f333c3f, 0x0d313c3d, 0x8e828c0e, 0x , 0x , 0x4e424c0e, 0xc6f2f436, 0x0e323c3e, 0x85a1a425, 0xc9f1f839, 0x0d010c0d, 0xcfd3dc1f, 0xc8d0d818, 0x0b23282b, 0x , 0x4a72783a, 0x , 0x0f232c2f, 0xc1f1f031, 0x , 0x , 0xc4d0d414, 0x , 0xc0c0c000, 0x , 0x , 0x8ca0ac2c, 0x8b83880b, 0xc7f3f437, 0x8da1ac2d, 0x , 0x0f131c1f, 0xcac2c80a, 0x0c202c2c, 0x8aa2a82a, 0x , 0xc2d2d012, 0x0b03080b, 0xcee2ec2e, 0xc9e1e829, 0x4d515c1d, 0x , 0x , 0xc8f0f838, 0x , 0x8ea2ac2e, 0x , 0xc5c1c405, 0x , 0xcdc1cc0d, 0x , 0x89b1b839, 0xcff3fc3f, 0x4d717c3d, 0xc1c1c001, 0x , 0xc5f1f435, 0x8a82880a, 0x4a62682a, 0x81b1b031, 0xc1d1d011, 0x , 0xc7d3d417, 0x , 0x , 0x , 0x , 0x , 0x , 0xcbd3d81b, 0x8d919c1d, 0x , 0x , 0x8eb2bc3e, 0xc6e2e426, 0x , 0xcdd1dc1d, 0x , 0x , 0xccd0dc1c, 0x8a92981a, 0x83a3a023, 0x8ba3a82b, 0xc0d0d010, 0x , 0x0f030c0f, 0x , 0x0a12181a, 0xc3e3e023, 0xcce0ec2c, 0x8d818c0d, 0x8fb3bc3f, 0x , 0x4b73783b, 0x4c505c1c, 0x82a2a022, 0x81a1a021, 0x , 0x , 0x4d414c0d, 0xc8c0c808, 0x8e929c1e, 0x8c909c1c, 0x0a32383a, 0x0c000c0c, 0x0e222c2e, 0x8ab2b83a, 0x4e626c2e, 0x8f939c1f, 0x4a52581a, 0xc2f2f032, 0x , 0xc3f3f033, 0x , 0x , 0xccc0cc0c, 0x , 0xcbf3f83b, 0x , 0x , 0x4f737c3f, 0x , 0x , 0x , 0x , 0x4d616c2d, 0xc6c2c406, 0x , 0xc5d1d415, 0x84b0b434, 0xcae2e82a, 0x , 0x , 0x , 0xcef2fc3e, 0x , 0x , 0xc0e0e020, 0x8db1bc3d, 0x , 0xcaf2f83a, 0x , 0xc0f0f030, 0x0a22282a, 0x4e525c1e, 0x89a1a829, 0x , 0x , 0x , 0x , 0x , 0x8b93981b, 0x80b0b030, 0xc5e1e425, 0x , 0x , 0x , 0xccf0fc3c, 0x0e121c1e, 0x , 0x , 0x8c808c0c, 0x0b13181b, 0x4f535c1f, 0x , 0x , 0x82b2b032, 0x0d111c1d, 0x , 0x4f434c0f, 0x , 0x , 0xcde1ec2d, 0x , 0x , 0xcbe3e82b, 0x4e727c3e, 0xcad2d81a, 0xc9c1c809, 0xcdf1fc3d, 0x , 0x , 0x , 0x0c303c3c, 0x86b2b436, 0xc4e0e424, 0x8bb3b83b, 0x4c707c3c, 0x0e020c0e, 0x , 0x , 0x , 0x , 0x , 0x , 0x , 0x , 0xc7e3e427, 0x , 0x84a0a424, 0xcbc3c80b, 0x , 0x0a02080a, 0x , 0xc9d1d819, 0x4c404c0c, 0x , 0x8f838c0f, 0xcec2cc0e, 0x0b33383b, 0x4a42480a, 0x87b3b437 };