source: chevmsgr/trunk/aria.c@ 7

Last change on this file since 7 was 7, checked in by cheese, 9 years ago

암복호 알고리즘 추가
File size: 13.4 KB
Line 
1#include "aria.h"
2
3#include <stdlib.h>
4#include <string.h>
5
6static byte SBOX_1[16][16] = {
7 {0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76},
8 {0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0},
9 {0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15},
10 {0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75},
11 {0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84},
12 {0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf},
13 {0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8},
14 {0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2},
15 {0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73},
16 {0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb},
17 {0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79},
18 {0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08},
19 {0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a},
20 {0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e},
21 {0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf},
22 {0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16}
23};
24
25static byte SBOX_1_I[16][16] = {
26 {0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb},
27 {0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb},
28 {0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e},
29 {0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25},
30 {0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92},
31 {0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84},
32 {0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06},
33 {0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b},
34 {0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73},
35 {0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e},
36 {0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b},
37 {0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4},
38 {0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f},
39 {0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef},
40 {0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61},
41 {0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d}
42};
43
44static byte SBOX_2[16][16] = {
45 {0xe2,0x4e,0x54,0xfc,0x94,0xc2,0x4a,0xcc,0x62,0x0d,0x6a,0x46,0x3c,0x4d,0x8b,0xd1},
46 {0x5e,0xfa,0x64,0xcb,0xb4,0x97,0xbe,0x2b,0xbc,0x77,0x2e,0x03,0xd3,0x19,0x59,0xc1},
47 {0x1d,0x06,0x41,0x6b,0x55,0xf0,0x99,0x69,0xea,0x9c,0x18,0xae,0x63,0xdf,0xe7,0xbb},
48 {0x00,0x73,0x66,0xfb,0x96,0x4c,0x85,0xe4,0x3a,0x09,0x45,0xaa,0x0f,0xee,0x10,0xeb},
49 {0x2d,0x7f,0xf4,0x29,0xac,0xcf,0xad,0x91,0x8d,0x78,0xc8,0x95,0xf9,0x2f,0xce,0xcd},
50 {0x08,0x7a,0x88,0x38,0x5c,0x83,0x2a,0x28,0x47,0xdb,0xb8,0xc7,0x93,0xa4,0x12,0x53},
51 {0xff,0x87,0x0e,0x31,0x36,0x21,0x58,0x48,0x01,0x8e,0x37,0x74,0x32,0xca,0xe9,0xb1},
52 {0xb7,0xab,0x0c,0xd7,0xc4,0x56,0x42,0x26,0x07,0x98,0x60,0xd9,0xb6,0xb9,0x11,0x40},
53 {0xec,0x20,0x8c,0xbd,0xa0,0xc9,0x84,0x04,0x49,0x23,0xf1,0x4f,0x50,0x1f,0x13,0xdc},
54 {0xd8,0xc0,0x9e,0x57,0xe3,0xc3,0x7b,0x65,0x3b,0x02,0x8f,0x3e,0xe8,0x25,0x92,0xe5},
55 {0x15,0xdd,0xfd,0x17,0xa9,0xbf,0xd4,0x9a,0x7e,0xc5,0x39,0x67,0xfe,0x76,0x9d,0x43},
56 {0xa7,0xe1,0xd0,0xf5,0x68,0xf2,0x1b,0x34,0x70,0x05,0xa3,0x8a,0xd5,0x79,0x86,0xa8},
57 {0x30,0xc6,0x51,0x4b,0x1e,0xa6,0x27,0xf6,0x35,0xd2,0x6e,0x24,0x16,0x82,0x5f,0xda},
58 {0xe6,0x75,0xa2,0xef,0x2c,0xb2,0x1c,0x9f,0x5d,0x6f,0x80,0x0a,0x72,0x44,0x9b,0x6c},
59 {0x90,0x0b,0x5b,0x33,0x7d,0x5a,0x52,0xf3,0x61,0xa1,0xf7,0xb0,0xd6,0x3f,0x7c,0x6d},
60 {0xed,0x14,0xe0,0xa5,0x3d,0x22,0xb3,0xf8,0x89,0xde,0x71,0x1a,0xaf,0xba,0xb5,0x81}
61};
62
63static byte SBOX_2_I[16][16] = {
64 {0x30,0x68,0x99,0x1b,0x87,0xb9,0x21,0x78,0x50,0x39,0xdb,0xe1,0x72,0x09,0x62,0x3c},
65 {0x3e,0x7e,0x5e,0x8e,0xf1,0xa0,0xcc,0xa3,0x2a,0x1d,0xfb,0xb6,0xd6,0x20,0xc4,0x8d},
66 {0x81,0x65,0xf5,0x89,0xcb,0x9d,0x77,0xc6,0x57,0x43,0x56,0x17,0xd4,0x40,0x1a,0x4d},
67 {0xc0,0x63,0x6c,0xe3,0xb7,0xc8,0x64,0x6a,0x53,0xaa,0x38,0x98,0x0c,0xf4,0x9b,0xed},
68 {0x7f,0x22,0x76,0xaf,0xdd,0x3a,0x0b,0x58,0x67,0x88,0x06,0xc3,0x35,0x0d,0x01,0x8b},
69 {0x8c,0xc2,0xe6,0x5f,0x02,0x24,0x75,0x93,0x66,0x1e,0xe5,0xe2,0x54,0xd8,0x10,0xce},
70 {0x7a,0xe8,0x08,0x2c,0x12,0x97,0x32,0xab,0xb4,0x27,0x0a,0x23,0xdf,0xef,0xca,0xd9},
71 {0xb8,0xfa,0xdc,0x31,0x6b,0xd1,0xad,0x19,0x49,0xbd,0x51,0x96,0xee,0xe4,0xa8,0x41},
72 {0xda,0xff,0xcd,0x55,0x86,0x36,0xbe,0x61,0x52,0xf8,0xbb,0x0e,0x82,0x48,0x69,0x9a},
73 {0xe0,0x47,0x9e,0x5c,0x04,0x4b,0x34,0x15,0x79,0x26,0xa7,0xde,0x29,0xae,0x92,0xd7},
74 {0x84,0xe9,0xd2,0xba,0x5d,0xf3,0xc5,0xb0,0xbf,0xa4,0x3b,0x71,0x44,0x46,0x2b,0xfc},
75 {0xeb,0x6f,0xd5,0xf6,0x14,0xfe,0x7c,0x70,0x5a,0x7d,0xfd,0x2f,0x18,0x83,0x16,0xa5},
76 {0x91,0x1f,0x05,0x95,0x74,0xa9,0xc1,0x5b,0x4a,0x85,0x6d,0x13,0x07,0x4f,0x4e,0x45},
77 {0xb2,0x0f,0xc9,0x1c,0xa6,0xbc,0xec,0x73,0x90,0x7b,0xcf,0x59,0x8f,0xa1,0xf9,0x2d},
78 {0xf2,0xb1,0x00,0x94,0x37,0x9f,0xd0,0x2e,0x9c,0x6e,0x28,0x3f,0x80,0xf0,0x3d,0xd3},
79 {0x25,0x8a,0xb5,0xe7,0x42,0xb3,0xc7,0xea,0xf7,0x4c,0x11,0x33,0x03,0xa2,0xac,0x60}
80};
81
82static byte C1[] = {0x51,0x7c,0xc1,0xb7,0x27,0x22,0x0a,0x94,
83 0xfe,0x13,0xab,0xe8,0xfa,0x9a,0x6e,0xe0};
84
85static byte C2[] = {0x6d,0xb1,0x4a,0xcc,0x9e,0x21,0xc8,0x20,
86 0xff,0x28,0xb1,0xd5,0xef,0x5d,0xe2,0xb0};
87
88static byte C3[] = {0xdb,0x92,0x37,0x1d,0x21,0x26,0xe9,0x70,
89 0x03,0x24,0x97,0x75,0x04,0xe8,0xc9,0x0e};
90
91int
92CHEV_ARIA_SubstitutionLayer (byte * state,
93 byte * out)
94{
95#define LT(in, out) \
96 (out)[0] = SBOX_1 [((in)[0] & 0xf0) >> 4][(in)[0] & 0x0f]; \
97 (out)[1] = SBOX_2 [((in)[1] & 0xf0) >> 4][(in)[1] & 0x0f]; \
98 (out)[2] = SBOX_1_I[((in)[2] & 0xf0) >> 4][(in)[2] & 0x0f]; \
99 (out)[3] = SBOX_2_I[((in)[3] & 0xf0) >> 4][(in)[3] & 0x0f]
100
101 LT (state + 0, out + 0);
102 LT (state + 4, out + 4);
103 LT (state + 8, out + 8);
104 LT (state + 12, out + 12);
105
106 return 0;
107}
108
109int
110CHEV_ARIA_SubstitutionLayer_I (byte * state,
111 byte * out)
112{
113#define LT_I(in, out) \
114 (out)[0] = SBOX_1_I[((in)[0] & 0xf0) >> 4][(in)[0] & 0x0f]; \
115 (out)[1] = SBOX_2_I[((in)[1] & 0xf0) >> 4][(in)[1] & 0x0f]; \
116 (out)[2] = SBOX_1 [((in)[2] & 0xf0) >> 4][(in)[2] & 0x0f]; \
117 (out)[3] = SBOX_2 [((in)[3] & 0xf0) >> 4][(in)[3] & 0x0f]
118
119 LT_I (state + 0, out + 0);
120 LT_I (state + 4, out + 4);
121 LT_I (state + 8, out + 8);
122 LT_I (state + 12, out + 12);
123
124 return 0;
125}
126
127int
128CHEV_ARIA_DiffusionLayer (byte * state,
129 byte * out)
130{
131#define DIFFUSION(st, i1, i2, i3, i4, i5, i6, i7) \
132 (st[i1] ^ st[i2] ^ st[i3] ^ st[i4] ^ st[i5] ^ st[i6] ^ st[i7])
133
134 out[ 0] = DIFFUSION (state, 3, 4, 6, 8, 9, 13, 14);
135 out[ 1] = DIFFUSION (state, 2, 5, 7, 8, 9, 12, 15);
136 out[ 2] = DIFFUSION (state, 1, 4, 6, 10, 11, 12, 15);
137 out[ 3] = DIFFUSION (state, 0, 5, 7, 10, 11, 13, 14);
138 out[ 4] = DIFFUSION (state, 0, 2, 5, 8, 11, 14, 15);
139 out[ 5] = DIFFUSION (state, 1, 3, 4, 9, 10, 14, 15);
140 out[ 6] = DIFFUSION (state, 0, 2, 7, 9, 10, 12, 13);
141 out[ 7] = DIFFUSION (state, 1, 3, 6, 8, 11, 12, 13);
142 out[ 8] = DIFFUSION (state, 0, 1, 4, 7, 10, 13, 15);
143 out[ 9] = DIFFUSION (state, 0, 1, 5, 6, 11, 12, 14);
144 out[10] = DIFFUSION (state, 2, 3, 5, 6, 8, 13, 15);
145 out[11] = DIFFUSION (state, 2, 3, 4, 7, 9, 12, 14);
146 out[12] = DIFFUSION (state, 1, 2, 6, 7, 9, 11, 12);
147 out[13] = DIFFUSION (state, 0, 3, 6, 7, 8, 10, 13);
148 out[14] = DIFFUSION (state, 0, 3, 4, 5, 9, 11, 14);
149 out[15] = DIFFUSION (state, 1, 2, 4, 5, 8, 10, 15);
150
151 return 0;
152}
153
154int
155CHEV_ARIA_FunctionFo (byte * state,
156 byte * key,
157 byte * out)
158{
159 byte buf1[16] = {0x00,};
160 byte buf2[16] = {0x00,};
161
162 CHEV_BIT_XOR (state, key, 128, buf1);
163 CHEV_ARIA_SubstitutionLayer (buf1, buf2);
164 CHEV_ARIA_DiffusionLayer (buf2, out);
165
166 return 0;
167}
168
169int
170CHEV_ARIA_FunctionFe (byte * state,
171 byte * key,
172 byte * out)
173{
174 byte buf1[16] = {0x00,};
175 byte buf2[16] = {0x00,};
176
177 CHEV_BIT_XOR (state, key, 128, buf1);
178 CHEV_ARIA_SubstitutionLayer_I (buf1, buf2);
179 CHEV_ARIA_DiffusionLayer (buf2, out);
180
181 return 0;
182}
183
184int
185CHEV_ARIA_FunctionFf (byte * state,
186 byte * key1,
187 byte * key2,
188 byte * out)
189{
190 byte buf1[16] = {0x00,};
191 byte buf2[16] = {0x00,};
192
193 CHEV_BIT_XOR (state, key1, 128, buf1);
194 CHEV_ARIA_SubstitutionLayer_I (buf1, buf2);
195 CHEV_BIT_XOR (buf2, key2, 128, out);
196
197 return 0;
198}
199
200int
201CHEV_ARIA_GenerateEncryptionKey (CHEV_ARIA_INFO * info,
202 byte * w0,
203 byte * w1,
204 byte * w2,
205 byte * w3)
206{
207 byte buf[16] = {0x00,};
208
209#define ROT_XOR_19(keep, rot, out) \
210 CHEV_BIT_RotateRight (rot, buf, 128, 19); \
211 CHEV_BIT_XOR (buf, keep, 128, out)
212
213#define ROT_XOR_31(keep, rot, out) \
214 CHEV_BIT_RotateRight (rot, buf, 128, 31); \
215 CHEV_BIT_XOR (buf, keep, 128, out)
216
217#define ROT_XOR_67(keep, rot, out) \
218 CHEV_BIT_RotateRight (rot, buf, 128, 67); \
219 CHEV_BIT_XOR (buf, keep, 128, out)
220
221#define ROT_XOR_97(keep, rot, out) \
222 CHEV_BIT_RotateRight (rot, buf, 128, 97); \
223 CHEV_BIT_XOR (buf, keep, 128, out)
224
225#define ROT_XOR_109(keep, rot, out) \
226 CHEV_BIT_RotateRight (rot, buf, 128, 109); \
227 CHEV_BIT_XOR (buf, keep, 128, out)
228
229 ROT_XOR_19 (w0, w1, info->ek[ 0]);
230 ROT_XOR_19 (w1, w2, info->ek[ 1]);
231 ROT_XOR_19 (w2, w3, info->ek[ 2]);
232 ROT_XOR_19 (w3, w0, info->ek[ 3]);
233
234 ROT_XOR_31 (w0, w1, info->ek[ 4]);
235 ROT_XOR_31 (w1, w2, info->ek[ 5]);
236 ROT_XOR_31 (w2, w3, info->ek[ 6]);
237 ROT_XOR_31 (w3, w0, info->ek[ 7]);
238
239 ROT_XOR_67 (w0, w1, info->ek[ 8]);
240 ROT_XOR_67 (w1, w2, info->ek[ 9]);
241 ROT_XOR_67 (w2, w3, info->ek[10]);
242 ROT_XOR_67 (w3, w0, info->ek[11]);
243
244 ROT_XOR_97 (w0, w1, info->ek[12]);
245
246 if (info->type > CHEV_ARIA_128)
247 {
248 ROT_XOR_97 (w1, w2, info->ek[13]);
249 ROT_XOR_97 (w2, w3, info->ek[14]);
250
251 if (info->type > CHEV_ARIA_192)
252 {
253 ROT_XOR_97 (w3, w0, info->ek[15]);
254 ROT_XOR_109 (w0, w1, info->ek[16]);
255 }
256 }
257
258 return 0;
259}
260
261int
262CHEV_ARIA_GenerateDecryptionKey (CHEV_ARIA_INFO * info)
263{
264 int iter = 0;
265 int lastRound = info->round - 1;
266
267 memcpy (info->dk[0], info->ek[lastRound], 16);
268 memcpy (info->dk[lastRound], info->ek[0], 16);
269
270 for (iter = 1 ; iter < lastRound ; iter++)
271 {
272 CHEV_ARIA_DiffusionLayer (info->ek[iter], info->dk[lastRound - iter]);
273 }
274
275 return 0;
276}
277
278int
279CHEV_ARIA_GenerateRoundKey (CHEV_ARIA_INFO * info,
280 byte * key)
281{
282 byte * ck1 = NULL;
283 byte * ck2 = NULL;
284 byte * ck3 = NULL;
285
286 /* 128-bits */
287 byte w0[16] = {0x00,};
288 byte w1[16] = {0x00,};
289 byte w2[16] = {0x00,};
290 byte w3[16] = {0x00,};
291
292 byte buf[16] = {0x00,};
293
294 switch (info->type)
295 {
296 case CHEV_ARIA_128: ck1 = C1; ck2 = C2; ck3 = C3; break;
297 case CHEV_ARIA_192: ck1 = C2; ck2 = C3; ck3 = C1; break;
298 case CHEV_ARIA_256: ck1 = C3; ck2 = C1; ck3 = C2; break;
299 default: return -1;
300 }
301
302 /* step 1. Initialize Round Key */
303 /* step 1.1. w0 */
304 memcpy (w0, key, 16);
305
306 /* step 1.2. w1 */
307 CHEV_ARIA_FunctionFo (w0, ck1, buf);
308 CHEV_BIT_XOR (buf, &key[16], 128, w1);
309
310 /* step 1.3. w2 */
311 CHEV_ARIA_FunctionFe (w1, ck2, buf);
312 CHEV_BIT_XOR (buf, w0, 128, w2);
313
314 /* step 1.4. w3 */
315 CHEV_ARIA_FunctionFo (w2, ck3, buf);
316 CHEV_BIT_XOR (buf, w1, 128, w3);
317
318 /* step 2. Generate Round Key (Key Expansion) */
319 CHEV_ARIA_GenerateEncryptionKey (info, w0, w1, w2, w3);
320 CHEV_ARIA_GenerateDecryptionKey (info);
321
322 return 0;
323}
324
325int
326CHEV_ARIA_Initialize (CHEV_ARIA_INFO * info,
327 CHEV_ARIA_TYPE type,
328 byte * inputKey,
329 int keySize)
330{
331#define CHEV_ARIA_KEY_SIZE 32 /* 256-bits */
332 int algSize = 16 + (8 * (int)type);
333 byte key[CHEV_ARIA_KEY_SIZE] = {0x00,};
334
335 memset (info, 0x00, sizeof (CHEV_ARIA_INFO));
336
337 info->type = type;
338
339 switch (type)
340 {
341 case CHEV_ARIA_128: info->round = 13; break;
342 case CHEV_ARIA_192: info->round = 15; break;
343 case CHEV_ARIA_256: info->round = 17; break;
344 default: return -1;
345 }
346
347 memcpy (key, inputKey, (keySize < algSize) ? keySize : algSize);
348
349 CHEV_ARIA_GenerateRoundKey (info, key);
350
351 return 0;
352}
353
354int
355CHEV_ARIA_CryptBlock (CHEV_ARIA_INFO * info,
356 byte key[17][16],
357 byte * input,
358 byte * out)
359{
360 int iter = 0;
361 int round = info->round - 3;
362
363 byte buf1[16] = {0x00,};
364 byte buf2[16] = {0x00,};
365
366 memcpy (buf1, input, 16);
367
368 for (iter = 0 ; iter < round ; iter += 2)
369 {
370 CHEV_ARIA_FunctionFo (buf1, key[iter ], buf2);
371 CHEV_ARIA_FunctionFe (buf2, key[iter + 1], buf1);
372 }
373
374 CHEV_ARIA_FunctionFo (buf1, key[iter ], buf2);
375 CHEV_ARIA_FunctionFf (buf2, key[iter + 1], key[iter + 2], out);
376
377 return 0;
378}
379
380int
381CHEV_ARIA_EncryptBlock (CHEV_ARIA_INFO * info,
382 byte * input,
383 byte * out)
384{
385 return CHEV_ARIA_CryptBlock (info, info->ek, input, out);
386}
387
388int
389CHEV_ARIA_DecryptBlock (CHEV_ARIA_INFO * info,
390 byte * input,
391 byte * out)
392{
393 return CHEV_ARIA_CryptBlock (info, info->dk, input, out);
394}
395
396int
397CHEV_ARIA_Encrypt (CHEV_ARIA_INFO * info,
398 byte * input,
399 int inSize,
400 byte * out,
401 int * outSize)
402{
403 int iter = 0;
404
405 for (iter = 0 ; iter < inSize ; iter += 16)
406 CHEV_ARIA_EncryptBlock (info, input + iter, out + iter);
407
408 *outSize = iter;
409
410 return 0;
411}
412
413int
414CHEV_ARIA_Decrypt (CHEV_ARIA_INFO * info,
415 byte * input,
416 int inSize,
417 byte * out,
418 int * outSize)
419{
420 int iter = 0;
421
422 for (iter = 0 ; iter < inSize ; iter += 16)
423 CHEV_ARIA_DecryptBlock (info, input + iter, out + iter);
424
425 *outSize = iter;
426
427 return 0;
428}
Note: See TracBrowser for help on using the repository browser.