1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23 #include <sal/types.h>
24 #include <osl/diagnose.h>
25 #include <rtl/cipher.h>
26
27 #include <stdio.h>
28 #include <string.h>
29
30 #define NUM_VARIABLE_KEY_TESTS 34
31 #define NUM_SET_KEY_TESTS 24
32
33 /* plaintext bytes -- left halves */
34 unsigned long plaintext_l[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
35 0x00000000l, 0xFFFFFFFFl, 0x10000000l, 0x11111111l, 0x11111111l,
36 0x01234567l, 0x00000000l, 0x01234567l, 0x01A1D6D0l, 0x5CD54CA8l,
37 0x0248D438l, 0x51454B58l, 0x42FD4430l, 0x059B5E08l, 0x0756D8E0l,
38 0x762514B8l, 0x3BDD1190l, 0x26955F68l, 0x164D5E40l, 0x6B056E18l,
39 0x004BD6EFl, 0x480D3900l, 0x437540C8l, 0x072D43A0l, 0x02FE5577l,
40 0x1D9D5C50l, 0x30553228l, 0x01234567l, 0x01234567l, 0x01234567l,
41 0xFFFFFFFFl, 0x00000000l, 0x00000000l, 0xFFFFFFFFl, 0xFEDCBA98l,
42 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
43 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
44 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
45 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
46 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l };
47
48 /* plaintext bytes -- right halves */
49 unsigned long plaintext_r[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
50 0x00000000l, 0xFFFFFFFFl, 0x00000001l, 0x11111111l, 0x11111111l,
51 0x89ABCDEFl, 0x00000000l, 0x89ABCDEFl, 0x39776742l, 0x3DEF57DAl,
52 0x06F67172l, 0x2DDF440Al, 0x59577FA2l, 0x51CF143Al, 0x774761D2l,
53 0x29BF486Al, 0x49372802l, 0x35AF609Al, 0x4F275232l, 0x759F5CCAl,
54 0x09176062l, 0x6EE762F2l, 0x698F3CFAl, 0x77075292l, 0x8117F12Al,
55 0x18F728C2l, 0x6D6F295Al, 0x89ABCDEFl, 0x89ABCDEFl, 0x89ABCDEFl,
56 0xFFFFFFFFl, 0x00000000l, 0x00000000l, 0xFFFFFFFFl, 0x76543210l,
57 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
58 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
59 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
60 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
61 0x76543210l, 0x76543210l, 0x76543210l };
62
63 /* key bytes for variable key tests */
64 unsigned char variable_key[NUM_VARIABLE_KEY_TESTS][8] = {
65 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
66 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
67 { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
68 { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
69 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
70 { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
71 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
72 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
73 { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
74 { 0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E },
75 { 0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86 },
76 { 0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E },
77 { 0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6 },
78 { 0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE },
79 { 0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6 },
80 { 0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE },
81 { 0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16 },
82 { 0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F },
83 { 0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46 },
84 { 0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E },
85 { 0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76 },
86 { 0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07 },
87 { 0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F },
88 { 0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7 },
89 { 0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF },
90 { 0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6 },
91 { 0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF },
92 { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
93 { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
94 { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
95 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
96 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
97 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
98 { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }};
99
100 /* key bytes for set key tests */
101 unsigned char set_key[24] = {
102 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
103 0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
104 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
105
106 /* ciphertext bytes -- left halves */
107 unsigned long ciphertext_l[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
108 0x4EF99745l, 0x51866FD5l, 0x7D856F9Al, 0x2466DD87l, 0x61F9C380l,
109 0x7D0CC630l, 0x4EF99745l, 0x0ACEAB0Fl, 0x59C68245l, 0xB1B8CC0Bl,
110 0x1730E577l, 0xA25E7856l, 0x353882B1l, 0x48F4D088l, 0x432193B7l,
111 0x13F04154l, 0x2EEDDA93l, 0xD887E039l, 0x5F99D04Fl, 0x4A057A3Bl,
112 0x452031C1l, 0x7555AE39l, 0x53C55F9Cl, 0x7A8E7BFAl, 0xCF9C5D7Al,
113 0xD1ABB290l, 0x55CB3774l, 0xFA34EC48l, 0xA7907951l, 0xC39E072Dl,
114 0x014933E0l, 0xF21E9A77l, 0x24594688l, 0x6B5C5A9Cl, 0xF9AD597Cl,
115 0xE91D21C1l, 0xE9C2B70Al, 0xBE1E6394l, 0xB39E4448l, 0x9457AA83l,
116 0x8BB77032l, 0xE87A244El, 0x15750E7Al, 0x122BA70Bl, 0x3A833C9Al,
117 0x9409DA87l, 0x884F8062l, 0x1F85031Cl, 0x79D9373Al, 0x93142887l,
118 0x03429E83l, 0xA4299E27l, 0xAFD5AED1l, 0x10851C0El, 0xE6F51ED7l,
119 0x64A6E14Al, 0x80C7D7D4l, 0x05044B62l };
120
121 /* ciphertext bytes -- right halves */
122 unsigned long ciphertext_r[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
123 0x6198DD78l, 0xB85ECB8Al, 0x613063F2l, 0x8B963C9Dl, 0x2281B096l,
124 0xAFDA1EC7l, 0x6198DD78l, 0xC6A0A28Dl, 0xEB05282Bl, 0x250F09A0l,
125 0x8BEA1DA4l, 0xCF2651EBl, 0x09CE8F1Al, 0x4C379918l, 0x8951FC98l,
126 0xD69D1AE5l, 0xFFD39C79l, 0x3C2DA6E3l, 0x5B163969l, 0x24D3977Bl,
127 0xE4FADA8El, 0xF59B87BDl, 0xB49FC019l, 0x937E89A3l, 0x4986ADB5l,
128 0x658BC778l, 0xD13EF201l, 0x47B268B2l, 0x08EA3CAEl, 0x9FAC631Dl,
129 0xCDAFF6E4l, 0xB71C49BCl, 0x5754369Al, 0x5D9E0A5Al, 0x49DB005El,
130 0xD961A6D6l, 0x1BC65CF3l, 0x08640F05l, 0x1BDB1E6El, 0xB1928C0Dl,
131 0xF960629Dl, 0x2CC85E82l, 0x4F4EC577l, 0x3AB64AE0l, 0xFFC537F6l,
132 0xA90F6BF2l, 0x5060B8B4l, 0x19E11968l, 0x714CA34Fl, 0xEE3BE15Cl,
133 0x8CE2D14Bl, 0x469FF67Bl, 0xC1BC96A8l, 0x3858DA9Fl, 0x9B9DB21Fl,
134 0xFD36B46Fl, 0x5A5479ADl, 0xFA52D080l };
135
136
137 static sal_uInt8 cbc_key[16] =
138 {
139 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
140 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
141 };
142 static sal_uInt8 cbc_iv[8] =
143 {
144 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
145 };
146
147 static sal_Char cbc_data[40] = "7654321 Now is the time for ";
148
149 static sal_uInt8 ecb_ok[32] =
150 {
151 0x2A, 0xFD, 0x7D, 0xAA, 0x60, 0x62, 0x6B, 0xA3,
152 0x86, 0x16, 0x46, 0x8C, 0xC2, 0x9C, 0xF6, 0xE1,
153 0x29, 0x1E, 0x81, 0x7C, 0xC7, 0x40, 0x98, 0x2D,
154 0x6F, 0x87, 0xAC, 0x5F, 0x17, 0x1A, 0xAB, 0xEA
155 };
156 static sal_uInt8 cbc_ok[32] =
157 {
158 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
159 0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
160 0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
161 0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
162 };
163 static sal_uInt8 cfb_ok[] =
164 {
165 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
166 0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
167 0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
168 0x51, 0x9D, 0x57, 0xA6, 0xC3
169 };
170
171 static sal_uInt8 arcfour_key[6][30] =
172 {
173 { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
174 { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
175 { 8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
176 { 4, 0xef, 0x01, 0x23, 0x45 },
177 { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
178 { 4, 0xef, 0x01, 0x23, 0x45 }
179 };
180 static sal_uInt8 arcfour_data_len[6] =
181 {
182 8, 8, 8, 20, 28, 10
183 };
184 static sal_uInt8 arcfour_data[6][30] =
185 {
186 { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff },
187 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
188 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
189 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
190 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
191 0x00, 0x00, 0x00, 0x00, 0xff },
192 { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
193 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
194 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
195 0x12, 0x34, 0x56, 0x78, 0xff },
196 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
197 0x00, 0x00, 0xff }
198 };
199 static sal_uInt8 arcfour_ok[6][30] =
200 {
201 { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96, 0x00},
202 { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79, 0x00},
203 { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a, 0x00},
204 { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
205 0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
206 0x36, 0xb6, 0x78, 0x58, 0x00 },
207 { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
208 0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
209 0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
210 0x40, 0x01, 0x1e, 0xcf, 0x00 },
211 { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
212 0xbd, 0x61, 0x00}
213 };
214
main(int argc,char * argv)215 int SAL_CALL main (int argc, char *argv)
216 {
217 rtlCipher cipher;
218
219 /* ECB */
220 cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
221 OSL_ASSERT(cipher != 0);
222 if (cipher != 0)
223 {
224 rtlCipherError result;
225 sal_uInt8 ecb_in[40], ecb_out[40];
226 sal_uInt32 length = strlen(cbc_data) + 1;
227
228 result = rtl_cipher_init (
229 cipher, rtl_Cipher_DirectionBoth,
230 cbc_key, sizeof(cbc_key), NULL, 0);
231 OSL_ASSERT(result == rtl_Cipher_E_None);
232
233 memset (ecb_out, 0, sizeof(ecb_out));
234 result = rtl_cipher_encode (
235 cipher, cbc_data, length, ecb_out, sizeof(ecb_out));
236 OSL_ASSERT(result == rtl_Cipher_E_None);
237 OSL_ASSERT(memcmp (ecb_out, ecb_ok, sizeof(ecb_ok)) == 0);
238
239 memset (ecb_in, 0, sizeof(ecb_in));
240 result = rtl_cipher_decode (
241 cipher, ecb_out, length, ecb_in, sizeof(ecb_in));
242 OSL_ASSERT(result == rtl_Cipher_E_None);
243 OSL_ASSERT(memcmp (ecb_in, cbc_data, length) == 0);
244
245 rtl_cipher_destroy (cipher);
246 }
247
248 /* CBC */
249 cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeCBC);
250 OSL_ASSERT(cipher != 0);
251 if (cipher != 0)
252 {
253 rtlCipherError result;
254 sal_uInt8 cbc_in[40], cbc_out[40];
255 sal_uInt32 length = strlen(cbc_data) + 1;
256
257 result = rtl_cipher_init (
258 cipher, rtl_Cipher_DirectionEncode,
259 cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
260 OSL_ASSERT(result == rtl_Cipher_E_None);
261
262 memset (cbc_out, 0, sizeof(cbc_out));
263 result = rtl_cipher_encode (
264 cipher, cbc_data, length, cbc_out, sizeof(cbc_out));
265 OSL_ASSERT(result == rtl_Cipher_E_None);
266 OSL_ASSERT(memcmp (cbc_out, cbc_ok, sizeof(cbc_ok)) == 0);
267
268 result = rtl_cipher_init (
269 cipher, rtl_Cipher_DirectionDecode,
270 cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
271 OSL_ASSERT(result == rtl_Cipher_E_None);
272
273 memset (cbc_in, 0, sizeof(cbc_in));
274 result = rtl_cipher_decode (
275 cipher, cbc_out, length, cbc_in, sizeof(cbc_in));
276 OSL_ASSERT(result == rtl_Cipher_E_None);
277 OSL_ASSERT(memcmp (cbc_in, cbc_data, length) == 0);
278
279 rtl_cipher_destroy (cipher);
280 }
281
282 /* CFB */
283 cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream);
284 OSL_ASSERT(cipher != 0);
285 if (cipher != 0)
286 {
287 rtlCipherError result;
288 sal_uInt8 cfb_in[40], cfb_out[40];
289 sal_uInt32 length = strlen(cbc_data) + 1;
290
291 result = rtl_cipher_init (
292 cipher, rtl_Cipher_DirectionEncode,
293 cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
294 OSL_ASSERT(result == rtl_Cipher_E_None);
295
296 memset (cfb_out, 0, sizeof(cfb_out));
297 result = rtl_cipher_encode (
298 cipher, cbc_data, length, cfb_out, sizeof(cfb_out));
299 OSL_ASSERT(result == rtl_Cipher_E_None);
300 OSL_ASSERT(memcmp (cfb_out, cfb_ok, sizeof(cfb_ok)) == 0);
301
302 result = rtl_cipher_init (
303 cipher, rtl_Cipher_DirectionDecode,
304 cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
305 OSL_ASSERT(result == rtl_Cipher_E_None);
306
307 memset (cfb_in, 0, sizeof(cfb_in));
308 result = rtl_cipher_decode (
309 cipher, cfb_out, length, cfb_in, sizeof(cfb_in));
310 OSL_ASSERT(result == rtl_Cipher_E_None);
311 OSL_ASSERT(memcmp (cfb_in, cbc_data, length) == 0);
312
313 rtl_cipher_destroy (cipher);
314 }
315
316 /* ARCFOUR */
317 cipher = rtl_cipher_create (rtl_Cipher_AlgorithmARCFOUR, rtl_Cipher_ModeStream);
318 OSL_ASSERT(cipher != 0);
319 if (cipher != 0)
320 {
321 rtlCipherError result;
322 sal_uInt8 arcfour_out[40];
323 sal_Size length;
324 int i, n;
325
326 n = sizeof(arcfour_data_len) / sizeof(arcfour_data_len[0]);
327 for (i = 0; i < n; i++)
328 {
329 length = arcfour_data_len[i];
330
331 result = rtl_cipher_init (
332 cipher, rtl_Cipher_DirectionBoth,
333 &(arcfour_key[i][1]), arcfour_key[i][0], 0, 0);
334 OSL_ASSERT(result == rtl_Cipher_E_None);
335
336 memset (arcfour_out, 0, sizeof(arcfour_out));
337 result = rtl_cipher_encode (
338 cipher, &(arcfour_data[i][0]), length,
339 arcfour_out, sizeof(arcfour_out));
340 OSL_ASSERT(result == rtl_Cipher_E_None);
341 OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[i], length) == 0);
342 }
343
344 n = arcfour_data_len[3];
345 for (i = 1; i < n; i++)
346 {
347 length = i;
348
349 result = rtl_cipher_init (
350 cipher, rtl_Cipher_DirectionBoth,
351 &(arcfour_key[3][1]), arcfour_key[3][0], 0, 0);
352 OSL_ASSERT(result == rtl_Cipher_E_None);
353
354 memset (arcfour_out, 0, sizeof(arcfour_out));
355 result = rtl_cipher_encode (
356 cipher, &(arcfour_data[3][0]), length,
357 arcfour_out, sizeof(arcfour_out));
358 OSL_ASSERT(result == rtl_Cipher_E_None);
359 OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[3], length) == 0);
360 OSL_ASSERT(arcfour_out[length] == 0);
361 }
362
363 n = arcfour_data_len[3];
364 for (i = 1; i < n; i++)
365 {
366 length = i;
367
368 result = rtl_cipher_init (
369 cipher, rtl_Cipher_DirectionBoth,
370 &(arcfour_key[3][1]), arcfour_key[3][0], 0, 0);
371 OSL_ASSERT(result == rtl_Cipher_E_None);
372
373 memset (arcfour_out, 0, sizeof(arcfour_out));
374 result = rtl_cipher_encode (
375 cipher, &(arcfour_data[3][0]), length,
376 &(arcfour_out[0]), sizeof(arcfour_out));
377 OSL_ASSERT(result == rtl_Cipher_E_None);
378
379 result = rtl_cipher_encode (
380 cipher, &(arcfour_data[3][length]), n - length,
381 &(arcfour_out[length]), sizeof(arcfour_out) - length);
382 OSL_ASSERT(result == rtl_Cipher_E_None);
383
384 OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[3], length) == 0);
385 }
386
387 rtl_cipher_destroy (cipher);
388 }
389
390 /* Done */
391 return 0;
392 }
393