avutil/camellia: use K[2] instead of *K in generate_round_keys()
[ffmpeg.git] / libavutil / camellia.c
1 /*
2  * An implementation of the CAMELLIA algorithm as mentioned in RFC3713
3  * Copyright (c) 2014 Supraja Meedinti
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include "camellia.h"
22 #include "common.h"
23 #include "intreadwrite.h"
24 #include "attributes.h"
25
26 #define LR32(x,c) ((x) << (c) | (x) >> (32 - (c)))
27 #define RR32(x,c) ((x) >> (c) | (x) << (32 - (c)))
28
29 #define MASK8 0xff
30 #define MASK32 0xffffffff
31 #define MASK64 0xffffffffffffffff
32
33 #define Sigma1  0xA09E667F3BCC908B
34 #define Sigma2  0xB67AE8584CAA73B2
35 #define Sigma3  0xC6EF372FE94F82BE
36 #define Sigma4  0x54FF53A5F1D36F1C
37 #define Sigma5  0x10E527FADE682D1D
38 #define Sigma6  0xB05688C2B3E6C1FD
39
40 typedef struct AVCAMELLIA {
41     uint64_t Kw[4];
42     uint64_t Ke[6];
43     uint64_t K[24];
44     int key_bits;
45 } AVCAMELLIA;
46
47 static const uint8_t SBOX1[256] =
48 {
49     112, 130, 44, 236, 179, 39, 192, 229, 228, 133, 87, 53, 234, 12, 174, 65,
50     35, 239, 107, 147, 69, 25, 165, 33, 237, 14, 79, 78, 29, 101, 146, 189,
51     134, 184, 175, 143, 124, 235, 31, 206, 62, 48, 220, 95, 94, 197, 11, 26,
52     166, 225, 57, 202, 213, 71, 93, 61, 217, 1, 90, 214, 81, 86, 108, 77,
53     139, 13, 154, 102, 251, 204, 176, 45, 116, 18, 43, 32, 240, 177, 132, 153,
54     223, 76, 203, 194, 52, 126, 118, 5, 109, 183, 169, 49, 209, 23, 4, 215,
55     20, 88, 58, 97, 222, 27, 17, 28, 50, 15, 156, 22, 83, 24, 242, 34,
56     254, 68, 207, 178, 195, 181, 122, 145, 36, 8, 232, 168, 96, 252, 105, 80,
57     170, 208, 160, 125, 161, 137, 98, 151, 84, 91, 30, 149, 224, 255, 100, 210,
58     16, 196, 0, 72, 163, 247, 117, 219, 138, 3, 230, 218, 9,  63, 221, 148,
59     135, 92, 131, 2, 205, 74, 144, 51, 115, 103, 246, 243, 157, 127, 191, 226,
60     82, 155, 216, 38, 200, 55, 198, 59, 129, 150, 111, 75, 19, 190, 99, 46,
61     233, 121, 167, 140, 159, 110, 188, 142, 41, 245, 249, 182, 47, 253, 180, 89,
62     120, 152, 6, 106, 231, 70, 113, 186, 212, 37, 171, 66, 136, 162, 141, 250,
63     114, 7, 185, 85, 248, 238, 172, 10, 54, 73, 42, 104, 60, 56, 241, 164,
64     64, 40, 211, 123, 187, 201, 67, 193, 21, 227, 173, 244, 119, 199, 128, 158
65 };
66
67 static const uint8_t SBOX2[256] =
68 {
69     224, 5, 88, 217, 103, 78, 129, 203, 201, 11, 174, 106, 213, 24, 93, 130,
70     70, 223, 214, 39, 138, 50, 75, 66, 219, 28, 158, 156, 58, 202, 37, 123,
71     13, 113, 95, 31, 248, 215, 62, 157, 124, 96, 185, 190, 188, 139, 22, 52,
72     77, 195, 114, 149, 171, 142, 186, 122, 179, 2, 180, 173, 162, 172, 216, 154,
73     23, 26, 53, 204, 247, 153, 97, 90, 232, 36, 86, 64, 225, 99, 9, 51,
74     191, 152, 151, 133, 104, 252, 236, 10, 218, 111, 83, 98, 163, 46, 8, 175,
75     40, 176, 116, 194, 189, 54, 34, 56, 100, 30, 57, 44, 166, 48, 229, 68,
76     253, 136, 159, 101, 135, 107, 244, 35, 72, 16, 209, 81, 192, 249, 210, 160,
77     85, 161,  65, 250, 67, 19, 196, 47, 168, 182, 60, 43, 193, 255, 200, 165,
78     32, 137, 0, 144, 71, 239, 234, 183, 21, 6, 205, 181, 18, 126, 187, 41,
79     15, 184, 7, 4, 155, 148, 33, 102, 230, 206, 237, 231, 59, 254, 127, 197,
80     164, 55, 177, 76, 145, 110, 141, 118, 3,  45, 222, 150, 38, 125, 198, 92,
81     211, 242, 79, 25, 63, 220, 121, 29, 82, 235, 243, 109, 94, 251, 105, 178,
82     240, 49, 12, 212, 207, 140, 226, 117, 169, 74, 87, 132, 17, 69, 27, 245,
83     228, 14, 115, 170, 241, 221, 89, 20, 108, 146, 84, 208, 120, 112, 227, 73,
84     128, 80, 167, 246, 119, 147, 134, 131, 42, 199, 91, 233, 238, 143, 1, 61
85 };
86
87 static const uint8_t SBOX3[256] =
88 {
89     56, 65, 22, 118, 217, 147, 96, 242, 114, 194, 171, 154, 117, 6, 87, 160,
90     145, 247, 181, 201, 162, 140, 210, 144, 246, 7, 167, 39, 142, 178, 73, 222,
91     67, 92, 215, 199, 62, 245, 143, 103, 31, 24, 110, 175, 47, 226, 133, 13,
92     83, 240, 156, 101, 234, 163, 174, 158, 236, 128, 45, 107, 168, 43, 54, 166,
93     197, 134, 77, 51, 253, 102, 88, 150, 58, 9, 149, 16, 120, 216, 66, 204,
94     239, 38, 229, 97, 26, 63, 59, 130, 182, 219, 212, 152, 232, 139, 2, 235,
95     10, 44, 29, 176, 111, 141, 136, 14, 25, 135, 78, 11, 169, 12, 121, 17,
96     127, 34, 231, 89, 225, 218, 61, 200, 18, 4, 116, 84, 48, 126, 180, 40,
97     85, 104, 80, 190, 208, 196, 49, 203, 42, 173, 15, 202, 112, 255, 50, 105,
98     8, 98, 0, 36, 209, 251, 186, 237, 69, 129, 115, 109, 132, 159, 238, 74,
99     195, 46, 193, 1, 230, 37, 72, 153, 185, 179, 123, 249, 206, 191, 223, 113,
100     41, 205, 108, 19, 100, 155, 99, 157, 192, 75, 183, 165, 137, 95, 177, 23,
101     244, 188, 211, 70, 207, 55, 94, 71, 148, 250, 252, 91, 151, 254, 90, 172,
102     60, 76, 3, 53, 243, 35, 184, 93, 106, 146, 213, 33, 68, 81, 198, 125,
103     57, 131, 220, 170, 124, 119, 86, 5, 27, 164, 21, 52, 30, 28, 248, 82,
104     32, 20, 233, 189, 221, 228, 161, 224, 138, 241, 214, 122, 187, 227, 64, 79
105 };
106
107 static const uint8_t SBOX4[256] =
108 {
109     112, 44, 179, 192, 228, 87, 234, 174, 35, 107, 69, 165, 237, 79, 29, 146,
110     134, 175, 124, 31, 62, 220, 94, 11, 166, 57, 213, 93, 217, 90, 81, 108,
111     139, 154, 251, 176, 116, 43, 240, 132, 223, 203, 52, 118, 109, 169, 209, 4,
112     20, 58, 222, 17,  50, 156, 83, 242, 254, 207, 195, 122, 36, 232, 96, 105,
113     170, 160, 161, 98, 84, 30, 224, 100, 16, 0, 163, 117, 138, 230, 9, 221,
114     135, 131, 205, 144, 115, 246, 157, 191, 82, 216, 200, 198, 129, 111, 19, 99,
115     233, 167, 159, 188, 41, 249, 47, 180, 120, 6, 231, 113, 212, 171, 136, 141,
116     114, 185, 248, 172, 54, 42, 60, 241, 64, 211, 187, 67, 21, 173, 119, 128,
117     130, 236, 39, 229, 133, 53, 12, 65, 239, 147, 25, 33, 14, 78, 101, 189,
118     184, 143, 235, 206, 48, 95, 197, 26, 225, 202, 71, 61, 1, 214, 86, 77,
119     13, 102, 204, 45, 18, 32, 177, 153, 76, 194, 126, 5, 183, 49, 23, 215,
120     88, 97, 27, 28, 15, 22, 24, 34, 68, 178, 181, 145, 8, 168, 252, 80,
121     208, 125, 137, 151, 91, 149, 255, 210, 196, 72, 247, 219, 3, 218, 63, 148,
122     92, 2, 74, 51, 103, 243, 127, 226, 155, 38, 55, 59, 150, 75, 190, 46,
123     121, 140, 110, 142, 245, 182, 253, 89, 152, 106, 70, 186, 37, 66, 162, 250,
124     7, 85, 238, 10, 73, 104, 56, 164, 40, 123, 201, 193, 227, 244, 199, 158
125 };
126
127 const int av_camellia_size = sizeof(AVCAMELLIA);
128
129 static void LR128(uint64_t d[2], const uint64_t K[2], int x)
130 {
131     int i = 0;
132     if (x >=64 && x < 128) {
133         i = 1;
134         x -= 64;
135     }
136     if (x <= 0 || x >= 128) {
137         d[0] = K[i];
138         d[1] = K[!i];
139         return;
140     }
141     d[0] = (K[i] << x | K[!i] >> (64 - x));
142     d[1] = (K[!i] << x | K[i] >> (64 - x));
143 }
144 static uint64_t F(uint64_t F_IN, uint64_t KE)
145 {
146     uint32_t Zl, Zr;
147     KE ^= F_IN;
148     Zl = KE >> 32;
149     Zr = KE & MASK32;
150     Zl = (((uint32_t)SBOX1[(Zl >> 24)] << 24) | ((uint32_t)SBOX2[(Zl >> 16) & MASK8] << 16) | ((uint32_t)SBOX3[(Zl >> 8) & MASK8] << 8) |(SBOX4[Zl & MASK8]));
151     Zr = (((uint32_t)SBOX2[(Zr >> 24)] << 24) | ((uint32_t)SBOX3[(Zr >> 16) & MASK8] << 16) | ((uint32_t)SBOX4[(Zr >> 8) & MASK8] << 8) |(SBOX1[Zr & MASK8]));
152     Zl ^= LR32(Zr, 8);
153     Zr ^= LR32(Zl, 16);
154     Zl ^= RR32(Zr, 8);
155     Zr ^= RR32(Zl, 8);
156     return ((uint64_t)Zr << 32) | (uint64_t)Zl;
157 }
158
159 static uint64_t FL(uint64_t FL_IN, uint64_t KE)
160 {
161     uint32_t x1, x2, k1, k2;
162     x1 = FL_IN >> 32;
163     x2 = FL_IN & MASK32;
164     k1 = KE >> 32;
165     k2 = KE & MASK32;
166     x2 = x2 ^ LR32((x1 & k1), 1);
167     x1 = x1 ^ (x2 | k2);
168     return ((uint64_t)x1 << 32) | (uint64_t)x2;
169 }
170
171 static uint64_t FLINV(uint64_t FLINV_IN, uint64_t KE)
172 {
173     uint32_t x1, x2, k1, k2;
174     x1 = FLINV_IN >> 32;
175     x2 = FLINV_IN & MASK32;
176     k1 = KE >> 32;
177     k2 = KE & MASK32;
178     x1 = x1 ^ (x2 | k2);
179     x2 = x2 ^ LR32((x1 & k1), 1);
180     return ((uint64_t)x1 << 32) | (uint64_t)x2;
181 }
182
183 static const uint8_t shifts[2][12] = {
184     {0,15,15,45,45,60,94,94,111},
185     {0,15,15,30,45,45,60,60,77,94,94,111}
186 };
187
188 static const uint8_t vars[2][12] = {
189     {2,0,2,0,2,2,0,2,0},
190     {3,1,2,3,0,2,1,3,0,1,2,0}
191 };
192
193 static void generate_round_keys(AVCAMELLIA* cs, uint64_t Kl[2], uint64_t Kr[2], uint64_t Ka[2], uint64_t Kb[2])
194 {
195     int i;
196     uint64_t *Kd[4], d[2];
197     Kd[0] = Kl;
198     Kd[1] = Kr;
199     Kd[2] = Ka;
200     Kd[3] = Kb;
201     cs->Kw[0] = Kl[0];
202     cs->Kw[1] = Kl[1];
203     if (cs->key_bits == 128) {
204         for (i = 0; i < 9; i++) {
205             LR128(d, Kd[vars[0][i]], shifts[0][i]);
206             cs->K[2*i] = d[0];
207             cs->K[2*i+1] = d[1];
208         }
209         LR128(d, Kd[0], 60);
210         cs->K[9] = d[1];
211         LR128(d, Kd[2], 30);
212         cs->Ke[0] = d[0];
213         cs->Ke[1] = d[1];
214         LR128(d, Kd[0], 77);
215         cs->Ke[2] = d[0];
216         cs->Ke[3] = d[1];
217         LR128(d, Kd[2], 111);
218         cs->Kw[2] = d[0];
219         cs->Kw[3] = d[1];
220     } else {
221         for (i = 0; i < 12; i++) {
222             LR128(d, Kd[vars[1][i]], shifts[1][i]);
223             cs->K[2*i] = d[0];
224             cs->K[2*i+1] = d[1];
225         }
226         LR128(d, Kd[1], 30);
227         cs->Ke[0] = d[0];
228         cs->Ke[1] = d[1];
229         LR128(d, Kd[0], 60);
230         cs->Ke[2] = d[0];
231         cs->Ke[3] = d[1];
232         LR128(d, Kd[2], 77);
233         cs->Ke[4] = d[0];
234         cs->Ke[5] = d[1];
235         LR128(d, Kd[3], 111);
236         cs->Kw[2] = d[0];
237         cs->Kw[3] = d[1];
238     }
239 }
240
241 static void camellia_encrypt(AVCAMELLIA* cs, uint8_t* dst, const uint8_t* src)
242 {
243     uint64_t D1, D2;
244     D1 = AV_RB64(src);
245     D2 = AV_RB64(src + 8);
246     D1 ^= cs->Kw[0];
247     D2 ^= cs->Kw[1];
248     D2 ^= F(D1, cs->K[0]);
249     D1 ^= F(D2, cs->K[1]);
250     D2 ^= F(D1, cs->K[2]);
251     D1 ^= F(D2, cs->K[3]);
252     D2 ^= F(D1, cs->K[4]);
253     D1 ^= F(D2, cs->K[5]);
254     D1 = FL(D1, cs->Ke[0]);
255     D2 = FLINV(D2, cs->Ke[1]);
256     D2 ^= F(D1, cs->K[6]);
257     D1 ^= F(D2, cs->K[7]);
258     D2 ^= F(D1, cs->K[8]);
259     D1 ^= F(D2, cs->K[9]);
260     D2 ^= F(D1, cs->K[10]);
261     D1 ^= F(D2, cs->K[11]);
262     D1 = FL(D1, cs->Ke[2]);
263     D2 = FLINV(D2, cs->Ke[3]);
264     D2 ^= F(D1, cs->K[12]);
265     D1 ^= F(D2, cs->K[13]);
266     D2 ^= F(D1, cs->K[14]);
267     D1 ^= F(D2, cs->K[15]);
268     D2 ^= F(D1, cs->K[16]);
269     D1 ^= F(D2, cs->K[17]);
270     if (cs->key_bits != 128) {
271         D1 = FL(D1, cs->Ke[4]);
272         D2 = FLINV(D2, cs->Ke[5]);
273         D2 ^= F(D1, cs->K[18]);
274         D1 ^= F(D2, cs->K[19]);
275         D2 ^= F(D1, cs->K[20]);
276         D1 ^= F(D2, cs->K[21]);
277         D2 ^= F(D1, cs->K[22]);
278         D1 ^= F(D2, cs->K[23]);
279     }
280     D2 ^= cs->Kw[2];
281     D1 ^= cs->Kw[3];
282     AV_WB64(dst, D2);
283     AV_WB64(dst + 8, D1);
284 }
285
286 static void camellia_decrypt(AVCAMELLIA* cs, uint8_t* dst, const uint8_t* src, uint8_t* iv)
287 {
288     uint64_t D1, D2;
289     D1 = AV_RB64(src);
290     D2 = AV_RB64(src + 8);
291     D1 ^= cs->Kw[2];
292     D2 ^= cs->Kw[3];
293     if (cs->key_bits != 128) {
294         D2 ^= F(D1, cs->K[23]);
295         D1 ^= F(D2, cs->K[22]);
296         D2 ^= F(D1, cs->K[21]);
297         D1 ^= F(D2, cs->K[20]);
298         D2 ^= F(D1, cs->K[19]);
299         D1 ^= F(D2, cs->K[18]);
300         D1 = FL(D1, cs->Ke[5]);
301         D2 = FLINV(D2, cs->Ke[4]);
302     }
303     D2 ^= F(D1, cs->K[17]);
304     D1 ^= F(D2, cs->K[16]);
305     D2 ^= F(D1, cs->K[15]);
306     D1 ^= F(D2, cs->K[14]);
307     D2 ^= F(D1, cs->K[13]);
308     D1 ^= F(D2, cs->K[12]);
309     D1 = FL(D1, cs->Ke[3]);
310     D2 = FLINV(D2, cs->Ke[2]);
311     D2 ^= F(D1, cs->K[11]);
312     D1 ^= F(D2, cs->K[10]);
313     D2 ^= F(D1, cs->K[9]);
314     D1 ^= F(D2, cs->K[8]);
315     D2 ^= F(D1, cs->K[7]);
316     D1 ^= F(D2, cs->K[6]);
317     D1 = FL(D1, cs->Ke[1]);
318     D2 = FLINV(D2, cs->Ke[0]);
319     D2 ^= F(D1, cs->K[5]);
320     D1 ^= F(D2, cs->K[4]);
321     D2 ^= F(D1, cs->K[3]);
322     D1 ^= F(D2, cs->K[2]);
323     D2 ^= F(D1, cs->K[1]);
324     D1 ^= F(D2, cs->K[0]);
325     D2 ^= cs->Kw[0];
326     D1 ^= cs->Kw[1];
327     if (iv) {
328         D2 ^= AV_RB64(iv);
329         D1 ^= AV_RB64(iv + 8);
330         memcpy(iv, src, 16);
331     }
332     AV_WB64(dst, D2);
333     AV_WB64(dst + 8, D1);
334 }
335
336 struct AVCAMELLIA *av_camellia_alloc(void)
337 {
338     return av_mallocz(sizeof(struct AVCAMELLIA));
339 }
340
341 av_cold int av_camellia_init(AVCAMELLIA* cs, const uint8_t *key, int key_bits)
342 {
343     uint64_t Kl[2], Kr[2], Ka[2], Kb[2];
344     uint64_t D1, D2;
345     if (key_bits != 128 && key_bits != 192 && key_bits != 256)
346         return -1;
347     memset(Kb, 0, sizeof(Kb));
348     memset(Kr, 0, sizeof(Kr));
349     cs->key_bits = key_bits;
350     Kl[0] = AV_RB64(key);
351     Kl[1] = AV_RB64(key + 8);
352     if (key_bits == 192) {
353         Kr[0] = AV_RB64(key + 16);
354         Kr[1] = ~Kr[0];
355     } else if (key_bits == 256) {
356         Kr[0] = AV_RB64(key + 16);
357         Kr[1] = AV_RB64(key + 24);
358     }
359     D1 = Kl[0] ^ Kr[0];
360     D2 = Kl[1] ^ Kr[1];
361     D2 ^= F(D1, Sigma1);
362     D1 ^= F(D2, Sigma2);
363     D1 ^= Kl[0];
364     D2 ^= Kl[1];
365     D2 ^= F(D1, Sigma3);
366     D1 ^= F(D2, Sigma4);
367     Ka[0] = D1;
368     Ka[1] = D2;
369     if (key_bits != 128) {
370         D1 = Ka[0] ^ Kr[0];
371         D2 = Ka[1] ^ Kr[1];
372         D2 ^= F(D1, Sigma5);
373         D1 ^= F(D2, Sigma6);
374         Kb[0] = D1;
375         Kb[1] = D2;
376     }
377     generate_round_keys(cs, Kl, Kr, Ka, Kb);
378     return 0;
379 }
380
381 void av_camellia_crypt(AVCAMELLIA* cs, uint8_t* dst, const uint8_t* src, int count, uint8_t *iv, int decrypt)
382 {
383     int i;
384     while (count--) {
385         if (decrypt) {
386             camellia_decrypt(cs, dst, src, iv);
387         } else {
388             if (iv) {
389                 for (i = 0; i < 16; i++)
390                     dst[i] = src[i] ^ iv[i];
391                 camellia_encrypt(cs, dst, dst);
392                 memcpy(iv, dst, 16);
393             } else {
394                 camellia_encrypt(cs, dst, src);
395             }
396         }
397         src = src + 16;
398         dst = dst + 16;
399     }
400 }
401
402 #ifdef TEST
403 #include<stdio.h>
404 #include<stdlib.h>
405 #include"log.h"
406
407 int main(int argc, char** argv)
408 {
409     const uint8_t Key[3][32] = {
410         {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10},
411         {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},
412         {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}
413     };
414     const uint8_t rct[3][16] = {
415         {0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73, 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43},
416         {0xb4, 0x99, 0x34, 0x01, 0xb3, 0xe9,0x96, 0xf8, 0x4e, 0xe5, 0xce, 0xe7, 0xd7, 0x9b, 0x09, 0xb9},
417         {0x9a, 0xcc, 0x23, 0x7d, 0xff, 0x16, 0xd7, 0x6c, 0x20, 0xef, 0x7c, 0x91, 0x9e, 0x3a, 0x75, 0x09}
418     };
419     const uint8_t rpt[32] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10};
420     const int kbits[3] = {128, 192, 256};
421     int i, j, err = 0;
422     uint8_t temp[32], iv[16];
423     AVCAMELLIA *cs;
424     cs = av_camellia_alloc();
425     if (!cs)
426         return 1;
427     for (j = 0; j < 3; j++) {
428         av_camellia_init(cs, Key[j], kbits[j]);
429         av_camellia_crypt(cs, temp, rpt, 1, NULL, 0);
430         for (i = 0; i < 16; i++) {
431             if (rct[j][i] != temp[i]) {
432                 av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rct[j][i], temp[i]);
433                 err = 1;
434             }
435         }
436         av_camellia_crypt(cs, temp, rct[j], 1, NULL, 1);
437         for (i = 0; i < 16; i++) {
438             if (rpt[i] != temp[i]) {
439                 av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
440                 err = 1;
441             }
442         }
443     }
444     av_camellia_init(cs, Key[0], 128);
445     memcpy(iv, "HALLO123HALLO123", 16);
446     av_camellia_crypt(cs, temp, rpt, 2, iv, 0);
447     memcpy(iv, "HALLO123HALLO123", 16);
448     av_camellia_crypt(cs, temp, temp, 2, iv, 1);
449     for (i = 0; i < 32; i++) {
450         if (rpt[i] != temp[i]) {
451             av_log(NULL, AV_LOG_ERROR, "%d %02x %02x\n", i, rpt[i], temp[i]);
452             err = 1;
453         }
454     }
455     av_free(cs);
456     return err;
457 }
458 #endif