?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sal / rtl / source / cipher.c
blob67f0036bd4cb435f9a3e90b3441d18c7987f4fc1
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: cipher.c,v $
10 * $Revision: 1.5 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 #define _RTL_CIPHER_C_ "$Revision: 1.5 $"
32
33 #include <sal/types.h>
34 #include <rtl/alloc.h>
35 #include <rtl/memory.h>
36 #include <rtl/cipher.h>
37
38 /*========================================================================
39 *
40 * rtlCipher internals.
41 *
42 *======================================================================*/
43 #define RTL_CIPHER_NTOHL(c, l) \
44 ((l) = ((sal_uInt32)(*((c)++))) << 24L, \
45 (l) |= ((sal_uInt32)(*((c)++))) << 16L, \
46 (l) |= ((sal_uInt32)(*((c)++))) << 8L, \
47 (l) |= ((sal_uInt32)(*((c)++))))
48
49 #define RTL_CIPHER_HTONL(l, c) \
50 (*((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff), \
51 *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
52 *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
53 *((c)++) = (sal_uInt8)(((l) ) & 0xff))
54
55 #define RTL_CIPHER_NTOHL64(c, xl, xr, n) \
56 { \
57 (xl) = (xr) = 0; \
58 (c) += (n); \
59 switch ((n)) \
60 { \
61 case 8: (xr) = ((sal_uInt32)(*(--(c)))); \
62 case 7: (xr) |= ((sal_uInt32)(*(--(c)))) << 8L; \
63 case 6: (xr) |= ((sal_uInt32)(*(--(c)))) << 16L; \
64 case 5: (xr) |= ((sal_uInt32)(*(--(c)))) << 24L; \
65 case 4: (xl) = ((sal_uInt32)(*(--(c)))); \
66 case 3: (xl) |= ((sal_uInt32)(*(--(c)))) << 8L; \
67 case 2: (xl) |= ((sal_uInt32)(*(--(c)))) << 16L; \
68 case 1: (xl) |= ((sal_uInt32)(*(--(c)))) << 24L; \
69 } \
70 }
71
72 #define RTL_CIPHER_HTONL64(xl, xr, c, n) \
73 { \
74 (c) += (n); \
75 switch ((n)) \
76 { \
77 case 8: *(--(c)) = (sal_uInt8)(((xr) ) & 0xff); \
78 case 7: *(--(c)) = (sal_uInt8)(((xr) >> 8L) & 0xff); \
79 case 6: *(--(c)) = (sal_uInt8)(((xr) >> 16L) & 0xff); \
80 case 5: *(--(c)) = (sal_uInt8)(((xr) >> 24L) & 0xff); \
81 case 4: *(--(c)) = (sal_uInt8)(((xl) ) & 0xff); \
82 case 3: *(--(c)) = (sal_uInt8)(((xl) >> 8L) & 0xff); \
83 case 2: *(--(c)) = (sal_uInt8)(((xl) >> 16L) & 0xff); \
84 case 1: *(--(c)) = (sal_uInt8)(((xl) >> 24L) & 0xff); \
85 } \
86 }
87
88 typedef rtlCipherError (SAL_CALL cipher_init_t) (
89 rtlCipher Cipher,
90 rtlCipherDirection Direction,
91 const sal_uInt8 *pKeyData, sal_Size nKeyLen,
92 const sal_uInt8 *pArgData, sal_Size nArgLen);
93
94 typedef rtlCipherError (SAL_CALL cipher_update_t) (
95 rtlCipher Cipher,
96 const void *pData, sal_Size nDatLen,
97 sal_uInt8 *pBuffer, sal_Size nBufLen);
98
99 typedef void (SAL_CALL cipher_delete_t) (rtlCipher Cipher);
100
101 /** Cipher_Impl.
102 */
103 typedef struct cipher_impl_st
104 {
105 rtlCipherAlgorithm m_algorithm;
106 rtlCipherDirection m_direction;
107 rtlCipherMode m_mode;
108
109 cipher_init_t *m_init;
110 cipher_update_t *m_encode;
111 cipher_update_t *m_decode;
112 cipher_delete_t *m_delete;
113 } Cipher_Impl;
114
115 /*========================================================================
116 *
117 * rtlCipher implementation.
118 *
119 *======================================================================*/
120 /*
121 * rtl_cipher_create.
122 */
123 rtlCipher SAL_CALL rtl_cipher_create (
124 rtlCipherAlgorithm Algorithm,
125 rtlCipherMode Mode)
126 {
127 rtlCipher Cipher = (rtlCipher)NULL;
128 switch (Algorithm)
129 {
130 case rtl_Cipher_AlgorithmBF:
131 Cipher = rtl_cipher_createBF (Mode);
132 break;
133
134 case rtl_Cipher_AlgorithmARCFOUR:
135 Cipher = rtl_cipher_createARCFOUR (Mode);
136 break;
137
138 default: /* rtl_Cipher_AlgorithmInvalid */
139 break;
140 }
141 return Cipher;
142 }
143
144 /*
145 * rtl_cipher_init.
146 */
147 rtlCipherError SAL_CALL rtl_cipher_init (
148 rtlCipher Cipher,
149 rtlCipherDirection Direction,
150 const sal_uInt8 *pKeyData, sal_Size nKeyLen,
151 const sal_uInt8 *pArgData, sal_Size nArgLen)
152 {
153 Cipher_Impl *pImpl = (Cipher_Impl*)Cipher;
154 if (pImpl == NULL)
155 return rtl_Cipher_E_Argument;
156 if (pImpl->m_init == NULL)
157 return rtl_Cipher_E_Unknown;
158
159 return (pImpl->m_init)(
160 Cipher, Direction, pKeyData, nKeyLen, pArgData, nArgLen);
161 }
162
163 /*
164 * rtl_cipher_encode.
165 */
166 rtlCipherError SAL_CALL rtl_cipher_encode (
167 rtlCipher Cipher,
168 const void *pData, sal_Size nDatLen,
169 sal_uInt8 *pBuffer, sal_Size nBufLen)
170 {
171 Cipher_Impl *pImpl = (Cipher_Impl*)Cipher;
172 if (pImpl == NULL)
173 return rtl_Cipher_E_Argument;
174 if (pImpl->m_encode == NULL)
175 return rtl_Cipher_E_Unknown;
176
177 return (pImpl->m_encode)(Cipher, pData, nDatLen, pBuffer, nBufLen);
178 }
179
180 /*
181 * rtl_cipher_decode.
182 */
183 rtlCipherError SAL_CALL rtl_cipher_decode (
184 rtlCipher Cipher,
185 const void *pData, sal_Size nDatLen,
186 sal_uInt8 *pBuffer, sal_Size nBufLen)
187 {
188 Cipher_Impl *pImpl = (Cipher_Impl*)Cipher;
189 if (pImpl == NULL)
190 return rtl_Cipher_E_Argument;
191 if (pImpl->m_decode == NULL)
192 return rtl_Cipher_E_Unknown;
193
194 return (pImpl->m_decode)(Cipher, pData, nDatLen, pBuffer, nBufLen);
195 }
196
197 /*
198 * rtl_cipher_destroy.
199 */
200 void SAL_CALL rtl_cipher_destroy (rtlCipher Cipher)
201 {
202 Cipher_Impl *pImpl = (Cipher_Impl*)Cipher;
203 if (pImpl && pImpl->m_delete)
204 pImpl->m_delete (Cipher);
205 }
206
207 /*========================================================================
208 *
209 * rtl_cipherBF (Blowfish) internals.
210 *
211 *======================================================================*/
212 #define CIPHER_ROUNDS_BF 16
213
214 typedef struct cipherBF_key_st
215 {
216 sal_uInt32 m_S[4][256];
217 sal_uInt32 m_P[CIPHER_ROUNDS_BF + 2];
218 } CipherKeyBF;
219
220 typedef struct cipherBF_context_st
221 {
222 CipherKeyBF m_key;
223 union
224 {
225 sal_uInt32 m_long[2];
226 sal_uInt8 m_byte[8];
227 } m_iv;
228 sal_uInt32 m_offset;
229 } CipherContextBF;
230
231 typedef struct cipherBF_impl_st
232 {
233 Cipher_Impl m_cipher;
234 CipherContextBF m_context;
235 } CipherBF_Impl;
236
237 /** __rtl_cipherBF_init.
238 */
239 static rtlCipherError __rtl_cipherBF_init (
240 CipherContextBF *ctx,
241 rtlCipherMode eMode,
242 const sal_uInt8 *pKeyData, sal_Size nKeyLen,
243 const sal_uInt8 *pArgData, sal_Size nArgLen);
244
245 /** __rtl_cipherBF_update.
246 */
247 static rtlCipherError __rtl_cipherBF_update (
248 CipherContextBF *ctx,
249 rtlCipherMode eMode,
250 rtlCipherDirection eDirection,
251 const sal_uInt8 *pData, sal_Size nDatLen,
252 sal_uInt8 *pBuffer, sal_Size nBufLen);
253
254 /** __rtl_cipherBF_updateECB.
255 */
256 static void __rtl_cipherBF_updateECB (
257 CipherContextBF *ctx,
258 rtlCipherDirection direction,
259 const sal_uInt8 *pData,
260 sal_uInt8 *pBuffer,
261 sal_Size nLength);
262
263 /** __rtl_cipherBF_updateCBC.
264 */
265 static void __rtl_cipherBF_updateCBC (
266 CipherContextBF *ctx,
267 rtlCipherDirection direction,
268 const sal_uInt8 *pData,
269 sal_uInt8 *pBuffer,
270 sal_Size nLength);
271
272 /** __rtl_cipherBF_updateCFB.
273 */
274 static void __rtl_cipherBF_updateCFB (
275 CipherContextBF *ctx,
276 rtlCipherDirection direction,
277 const sal_uInt8 *pData,
278 sal_uInt8 *pBuffer);
279
280 /** __rtl_cipher_encode.
281 */
282 static void __rtl_cipherBF_encode (
283 CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr);
284
285 /** __rtl_cipherBF_decode.
286 */
287 static void __rtl_cipherBF_decode (
288 CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr);
289
290 /** __rtl_cipherBF.
291 */
292 static sal_uInt32 __rtl_cipherBF (
293 CipherKeyBF *key, sal_uInt32 x);
294
295 /** __rtl_cipherBF_key.
296 */
297 static const CipherKeyBF __rtl_cipherBF_key =
298 {
299 /* S */
300 {
301 /* S[0] */
302 {
303 /* 0 */
304 0xD1310BA6L, 0x98DFB5ACL, 0x2FFD72DBL, 0xD01ADFB7L,
305 0xB8E1AFEDL, 0x6A267E96L, 0xBA7C9045L, 0xF12C7F99L,
306 0x24A19947L, 0xB3916CF7L, 0x0801F2E2L, 0x858EFC16L,
307 0x636920D8L, 0x71574E69L, 0xA458FEA3L, 0xF4933D7EL,
308
309 /* 1 */
310 0x0D95748FL, 0x728EB658L, 0x718BCD58L, 0x82154AEEL,
311 0x7B54A41DL, 0xC25A59B5L, 0x9C30D539L, 0x2AF26013L,
312 0xC5D1B023L, 0x286085F0L, 0xCA417918L, 0xB8DB38EFL,
313 0x8E79DCB0L, 0x603A180EL, 0x6C9E0E8BL, 0xB01E8A3EL,
314
315 /* 2 */
316 0xD71577C1L, 0xBD314B27L, 0x78AF2FDAL, 0x55605C60L,
317 0xE65525F3L, 0xAA55AB94L, 0x57489862L, 0x63E81440L,
318 0x55CA396AL, 0x2AAB10B6L, 0xB4CC5C34L, 0x1141E8CEL,
319 0xA15486AFL, 0x7C72E993L, 0xB3EE1411L, 0x636FBC2AL,
320
321 /* 3 */
322 0x2BA9C55DL, 0x741831F6L, 0xCE5C3E16L, 0x9B87931EL,
323 0xAFD6BA33L, 0x6C24CF5CL, 0x7A325381L, 0x28958677L,
324 0x3B8F4898L, 0x6B4BB9AFL, 0xC4BFE81BL, 0x66282193L,
325 0x61D809CCL, 0xFB21A991L, 0x487CAC60L, 0x5DEC8032L,
326
327 /* 4 */
328 0xEF845D5DL, 0xE98575B1L, 0xDC262302L, 0xEB651B88L,
329 0x23893E81L, 0xD396ACC5L, 0x0F6D6FF3L, 0x83F44239L,
330 0x2E0B4482L, 0xA4842004L, 0x69C8F04AL, 0x9E1F9B5EL,
331 0x21C66842L, 0xF6E96C9AL, 0x670C9C61L, 0xABD388F0L,
332
333 /* 5 */
334 0x6A51A0D2L, 0xD8542F68L, 0x960FA728L, 0xAB5133A3L,
335 0x6EEF0B6CL, 0x137A3BE4L, 0xBA3BF050L, 0x7EFB2A98L,
336 0xA1F1651DL, 0x39AF0176L, 0x66CA593EL, 0x82430E88L,
337 0x8CEE8619L, 0x456F9FB4L, 0x7D84A5C3L, 0x3B8B5EBEL,
338
339 /* 6 */
340 0xE06F75D8L, 0x85C12073L, 0x401A449FL, 0x56C16AA6L,
341 0x4ED3AA62L, 0x363F7706L, 0x1BFEDF72L, 0x429B023DL,
342 0x37D0D724L, 0xD00A1248L, 0xDB0FEAD3L, 0x49F1C09BL,
343 0x075372C9L, 0x80991B7BL, 0x25D479D8L, 0xF6E8DEF7L,
344
345 /* 7 */
346 0xE3FE501AL, 0xB6794C3BL, 0x976CE0BDL, 0x04C006BAL,
347 0xC1A94FB6L, 0x409F60C4L, 0x5E5C9EC2L, 0x196A2463L,
348 0x68FB6FAFL, 0x3E6C53B5L, 0x1339B2EBL, 0x3B52EC6FL,
349 0x6DFC511FL, 0x9B30952CL, 0xCC814544L, 0xAF5EBD09L,
350
351 /* 8 */
352 0xBEE3D004L, 0xDE334AFDL, 0x660F2807L, 0x192E4BB3L,
353 0xC0CBA857L, 0x45C8740FL, 0xD20B5F39L, 0xB9D3FBDBL,
354 0x5579C0BDL, 0x1A60320AL, 0xD6A100C6L, 0x402C7279L,
355 0x679F25FEL, 0xFB1FA3CCL, 0x8EA5E9F8L, 0xDB3222F8L,
356
357 /* 9 */
358 0x3C7516DFL, 0xFD616B15L, 0x2F501EC8L, 0xAD0552ABL,
359 0x323DB5FAL, 0xFD238760L, 0x53317B48L, 0x3E00DF82L,
360 0x9E5C57BBL, 0xCA6F8CA0L, 0x1A87562EL, 0xDF1769DBL,
361 0xD542A8F6L, 0x287EFFC3L, 0xAC6732C6L, 0x8C4F5573L,
362
363 /* A */
364 0x695B27B0L, 0xBBCA58C8L, 0xE1FFA35DL, 0xB8F011A0L,
365 0x10FA3D98L, 0xFD2183B8L, 0x4AFCB56CL, 0x2DD1D35BL,
366 0x9A53E479L, 0xB6F84565L, 0xD28E49BCL, 0x4BFB9790L,
367 0xE1DDF2DAL, 0xA4CB7E33L, 0x62FB1341L, 0xCEE4C6E8L,
368
369 /* B */
370 0xEF20CADAL, 0x36774C01L, 0xD07E9EFEL, 0x2BF11FB4L,
371 0x95DBDA4DL, 0xAE909198L, 0xEAAD8E71L, 0x6B93D5A0L,
372 0xD08ED1D0L, 0xAFC725E0L, 0x8E3C5B2FL, 0x8E7594B7L,
373 0x8FF6E2FBL, 0xF2122B64L, 0x8888B812L, 0x900DF01CL,
374
375 /* C */
376 0x4FAD5EA0L, 0x688FC31CL, 0xD1CFF191L, 0xB3A8C1ADL,
377 0x2F2F2218L, 0xBE0E1777L, 0xEA752DFEL, 0x8B021FA1L,
378 0xE5A0CC0FL, 0xB56F74E8L, 0x18ACF3D6L, 0xCE89E299L,
379 0xB4A84FE0L, 0xFD13E0B7L, 0x7CC43B81L, 0xD2ADA8D9L,
380
381 /* D */
382 0x165FA266L, 0x80957705L, 0x93CC7314L, 0x211A1477L,
383 0xE6AD2065L, 0x77B5FA86L, 0xC75442F5L, 0xFB9D35CFL,
384 0xEBCDAF0CL, 0x7B3E89A0L, 0xD6411BD3L, 0xAE1E7E49L,
385 0x00250E2DL, 0x2071B35EL, 0x226800BBL, 0x57B8E0AFL,
386
387 /* E */
388 0x2464369BL, 0xF009B91EL, 0x5563911DL, 0x59DFA6AAL,
389 0x78C14389L, 0xD95A537FL, 0x207D5BA2L, 0x02E5B9C5L,
390 0x83260376L, 0x6295CFA9L, 0x11C81968L, 0x4E734A41L,
391 0xB3472DCAL, 0x7B14A94AL, 0x1B510052L, 0x9A532915L,
392
393 /* F */
394 0xD60F573FL, 0xBC9BC6E4L, 0x2B60A476L, 0x81E67400L,
395 0x08BA6FB5L, 0x571BE91FL, 0xF296EC6BL, 0x2A0DD915L,
396 0xB6636521L, 0xE7B9F9B6L, 0xFF34052EL, 0xC5855664L,
397 0x53B02D5DL, 0xA99F8FA1L, 0x08BA4799L, 0x6E85076AL
398 },
399
400 /* S[1] */
401 {
402 0x4B7A70E9L, 0xB5B32944L, 0xDB75092EL, 0xC4192623L,
403 0xAD6EA6B0L, 0x49A7DF7DL, 0x9CEE60B8L, 0x8FEDB266L,
404 0xECAA8C71L, 0x699A17FFL, 0x5664526CL, 0xC2B19EE1L,
405 0x193602A5L, 0x75094C29L, 0xA0591340L, 0xE4183A3EL,
406
407 0x3F54989AL, 0x5B429D65L, 0x6B8FE4D6L, 0x99F73FD6L,
408 0xA1D29C07L, 0xEFE830F5L, 0x4D2D38E6L, 0xF0255DC1L,
409 0x4CDD2086L, 0x8470EB26L, 0x6382E9C6L, 0x021ECC5EL,
410 0x09686B3FL, 0x3EBAEFC9L, 0x3C971814L, 0x6B6A70A1L,
411
412 0x687F3584L, 0x52A0E286L, 0xB79C5305L, 0xAA500737L,
413 0x3E07841CL, 0x7FDEAE5CL, 0x8E7D44ECL, 0x5716F2B8L,
414 0xB03ADA37L, 0xF0500C0DL, 0xF01C1F04L, 0x0200B3FFL,
415 0xAE0CF51AL, 0x3CB574B2L, 0x25837A58L, 0xDC0921BDL,
416
417 0xD19113F9L, 0x7CA92FF6L, 0x94324773L, 0x22F54701L,
418 0x3AE5E581L, 0x37C2DADCL, 0xC8B57634L, 0x9AF3DDA7L,
419 0xA9446146L, 0x0FD0030EL, 0xECC8C73EL, 0xA4751E41L,
420 0xE238CD99L, 0x3BEA0E2FL, 0x3280BBA1L, 0x183EB331L,
421
422 0x4E548B38L, 0x4F6DB908L, 0x6F420D03L, 0xF60A04BFL,
423 0x2CB81290L, 0x24977C79L, 0x5679B072L, 0xBCAF89AFL,
424 0xDE9A771FL, 0xD9930810L, 0xB38BAE12L, 0xDCCF3F2EL,
425 0x5512721FL, 0x2E6B7124L, 0x501ADDE6L, 0x9F84CD87L,
426
427 0x7A584718L, 0x7408DA17L, 0xBC9F9ABCL, 0xE94B7D8CL,
428 0xEC7AEC3AL, 0xDB851DFAL, 0x63094366L, 0xC464C3D2L,
429 0xEF1C1847L, 0x3215D908L, 0xDD433B37L, 0x24C2BA16L,
430 0x12A14D43L, 0x2A65C451L, 0x50940002L, 0x133AE4DDL,
431
432 0x71DFF89EL, 0x10314E55L, 0x81AC77D6L, 0x5F11199BL,
433 0x043556F1L, 0xD7A3C76BL, 0x3C11183BL, 0x5924A509L,
434 0xF28FE6EDL, 0x97F1FBFAL, 0x9EBABF2CL, 0x1E153C6EL,
435 0x86E34570L, 0xEAE96FB1L, 0x860E5E0AL, 0x5A3E2AB3L,
436
437 0x771FE71CL, 0x4E3D06FAL, 0x2965DCB9L, 0x99E71D0FL,
438 0x803E89D6L, 0x5266C825L, 0x2E4CC978L, 0x9C10B36AL,
439 0xC6150EBAL, 0x94E2EA78L, 0xA5FC3C53L, 0x1E0A2DF4L,
440 0xF2F74EA7L, 0x361D2B3DL, 0x1939260FL, 0x19C27960L,
441
442 0x5223A708L, 0xF71312B6L, 0xEBADFE6EL, 0xEAC31F66L,
443 0xE3BC4595L, 0xA67BC883L, 0xB17F37D1L, 0x018CFF28L,
444 0xC332DDEFL, 0xBE6C5AA5L, 0x65582185L, 0x68AB9802L,
445 0xEECEA50FL, 0xDB2F953BL, 0x2AEF7DADL, 0x5B6E2F84L,
446
447 0x1521B628L, 0x29076170L, 0xECDD4775L, 0x619F1510L,
448 0x13CCA830L, 0xEB61BD96L, 0x0334FE1EL, 0xAA0363CFL,
449 0xB5735C90L, 0x4C70A239L, 0xD59E9E0BL, 0xCBAADE14L,
450 0xEECC86BCL, 0x60622CA7L, 0x9CAB5CABL, 0xB2F3846EL,
451
452 0x648B1EAFL, 0x19BDF0CAL, 0xA02369B9L, 0x655ABB50L,
453 0x40685A32L, 0x3C2AB4B3L, 0x319EE9D5L, 0xC021B8F7L,
454 0x9B540B19L, 0x875FA099L, 0x95F7997EL, 0x623D7DA8L,
455 0xF837889AL, 0x97E32D77L, 0x11ED935FL, 0x16681281L,
456
457 0x0E358829L, 0xC7E61FD6L, 0x96DEDFA1L, 0x7858BA99L,
458 0x57F584A5L, 0x1B227263L, 0x9B83C3FFL, 0x1AC24696L,
459 0xCDB30AEBL, 0x532E3054L, 0x8FD948E4L, 0x6DBC3128L,
460 0x58EBF2EFL, 0x34C6FFEAL, 0xFE28ED61L, 0xEE7C3C73L,
461
462 0x5D4A14D9L, 0xE864B7E3L, 0x42105D14L, 0x203E13E0L,
463 0x45EEE2B6L, 0xA3AAABEAL, 0xDB6C4F15L, 0xFACB4FD0L,
464 0xC742F442L, 0xEF6ABBB5L, 0x654F3B1DL, 0x41CD2105L,
465 0xD81E799EL, 0x86854DC7L, 0xE44B476AL, 0x3D816250L,
466
467 0xCF62A1F2L, 0x5B8D2646L, 0xFC8883A0L, 0xC1C7B6A3L,
468 0x7F1524C3L, 0x69CB7492L, 0x47848A0BL, 0x5692B285L,
469 0x095BBF00L, 0xAD19489DL, 0x1462B174L, 0x23820E00L,
470 0x58428D2AL, 0x0C55F5EAL, 0x1DADF43EL, 0x233F7061L,
471
472 0x3372F092L, 0x8D937E41L, 0xD65FECF1L, 0x6C223BDBL,
473 0x7CDE3759L, 0xCBEE7460L, 0x4085F2A7L, 0xCE77326EL,
474 0xA6078084L, 0x19F8509EL, 0xE8EFD855L, 0x61D99735L,
475 0xA969A7AAL, 0xC50C06C2L, 0x5A04ABFCL, 0x800BCADCL,
476
477 0x9E447A2EL, 0xC3453484L, 0xFDD56705L, 0x0E1E9EC9L,
478 0xDB73DBD3L, 0x105588CDL, 0x675FDA79L, 0xE3674340L,
479 0xC5C43465L, 0x713E38D8L, 0x3D28F89EL, 0xF16DFF20L,
480 0x153E21E7L, 0x8FB03D4AL, 0xE6E39F2BL, 0xDB83ADF7L
481 },
482
483 /* S[2] */
484 {
485 0xE93D5A68L, 0x948140F7L, 0xF64C261CL, 0x94692934L,
486 0x411520F7L, 0x7602D4F7L, 0xBCF46B2EL, 0xD4A20068L,
487 0xD4082471L, 0x3320F46AL, 0x43B7D4B7L, 0x500061AFL,
488 0x1E39F62EL, 0x97244546L, 0x14214F74L, 0xBF8B8840L,
489
490 0x4D95FC1DL, 0x96B591AFL, 0x70F4DDD3L, 0x66A02F45L,
491 0xBFBC09ECL, 0x03BD9785L, 0x7FAC6DD0L, 0x31CB8504L,
492 0x96EB27B3L, 0x55FD3941L, 0xDA2547E6L, 0xABCA0A9AL,
493 0x28507825L, 0x530429F4L, 0x0A2C86DAL, 0xE9B66DFBL,
494
495 0x68DC1462L, 0xD7486900L, 0x680EC0A4L, 0x27A18DEEL,
496 0x4F3FFEA2L, 0xE887AD8CL, 0xB58CE006L, 0x7AF4D6B6L,
497 0xAACE1E7CL, 0xD3375FECL, 0xCE78A399L, 0x406B2A42L,
498 0x20FE9E35L, 0xD9F385B9L, 0xEE39D7ABL, 0x3B124E8BL,
499
500 0x1DC9FAF7L, 0x4B6D1856L, 0x26A36631L, 0xEAE397B2L,
501 0x3A6EFA74L, 0xDD5B4332L, 0x6841E7F7L, 0xCA7820FBL,
502 0xFB0AF54EL, 0xD8FEB397L, 0x454056ACL, 0xBA489527L,
503 0x55533A3AL, 0x20838D87L, 0xFE6BA9B7L, 0xD096954BL,
504
505 0x55A867BCL, 0xA1159A58L, 0xCCA92963L, 0x99E1DB33L,
506 0xA62A4A56L, 0x3F3125F9L, 0x5EF47E1CL, 0x9029317CL,
507 0xFDF8E802L, 0x04272F70L, 0x80BB155CL, 0x05282CE3L,
508 0x95C11548L, 0xE4C66D22L, 0x48C1133FL, 0xC70F86DCL,
509
510 0x07F9C9EEL, 0x41041F0FL, 0x404779A4L, 0x5D886E17L,
511 0x325F51EBL, 0xD59BC0D1L, 0xF2BCC18FL, 0x41113564L,
512 0x257B7834L, 0x602A9C60L, 0xDFF8E8A3L, 0x1F636C1BL,
513 0x0E12B4C2L, 0x02E1329EL, 0xAF664FD1L, 0xCAD18115L,
514
515 0x6B2395E0L, 0x333E92E1L, 0x3B240B62L, 0xEEBEB922L,
516 0x85B2A20EL, 0xE6BA0D99L, 0xDE720C8CL, 0x2DA2F728L,
517 0xD0127845L, 0x95B794FDL, 0x647D0862L, 0xE7CCF5F0L,
518 0x5449A36FL, 0x877D48FAL, 0xC39DFD27L, 0xF33E8D1EL,
519
520 0x0A476341L, 0x992EFF74L, 0x3A6F6EABL, 0xF4F8FD37L,
521 0xA812DC60L, 0xA1EBDDF8L, 0x991BE14CL, 0xDB6E6B0DL,
522 0xC67B5510L, 0x6D672C37L, 0x2765D43BL, 0xDCD0E804L,
523 0xF1290DC7L, 0xCC00FFA3L, 0xB5390F92L, 0x690FED0BL,
524
525 0x667B9FFBL, 0xCEDB7D9CL, 0xA091CF0BL, 0xD9155EA3L,
526 0xBB132F88L, 0x515BAD24L, 0x7B9479BFL, 0x763BD6EBL,
527 0x37392EB3L, 0xCC115979L, 0x8026E297L, 0xF42E312DL,
528 0x6842ADA7L, 0xC66A2B3BL, 0x12754CCCL, 0x782EF11CL,
529
530 0x6A124237L, 0xB79251E7L, 0x06A1BBE6L, 0x4BFB6350L,
531 0x1A6B1018L, 0x11CAEDFAL, 0x3D25BDD8L, 0xE2E1C3C9L,
532 0x44421659L, 0x0A121386L, 0xD90CEC6EL, 0xD5ABEA2AL,
533 0x64AF674EL, 0xDA86A85FL, 0xBEBFE988L, 0x64E4C3FEL,
534
535 0x9DBC8057L, 0xF0F7C086L, 0x60787BF8L, 0x6003604DL,
536 0xD1FD8346L, 0xF6381FB0L, 0x7745AE04L, 0xD736FCCCL,
537 0x83426B33L, 0xF01EAB71L, 0xB0804187L, 0x3C005E5FL,
538 0x77A057BEL, 0xBDE8AE24L, 0x55464299L, 0xBF582E61L,
539
540 0x4E58F48FL, 0xF2DDFDA2L, 0xF474EF38L, 0x8789BDC2L,
541 0x5366F9C3L, 0xC8B38E74L, 0xB475F255L, 0x46FCD9B9L,
542 0x7AEB2661L, 0x8B1DDF84L, 0x846A0E79L, 0x915F95E2L,
543 0x466E598EL, 0x20B45770L, 0x8CD55591L, 0xC902DE4CL,
544
545 0xB90BACE1L, 0xBB8205D0L, 0x11A86248L, 0x7574A99EL,
546 0xB77F19B6L, 0xE0A9DC09L, 0x662D09A1L, 0xC4324633L,
547 0xE85A1F02L, 0x09F0BE8CL, 0x4A99A025L, 0x1D6EFE10L,
548 0x1AB93D1DL, 0x0BA5A4DFL, 0xA186F20FL, 0x2868F169L,
549
550 0xDCB7DA83L, 0x573906FEL, 0xA1E2CE9BL, 0x4FCD7F52L,
551 0x50115E01L, 0xA70683FAL, 0xA002B5C4L, 0x0DE6D027L,
552 0x9AF88C27L, 0x773F8641L, 0xC3604C06L, 0x61A806B5L,
553 0xF0177A28L, 0xC0F586E0L, 0x006058AAL, 0x30DC7D62L,
554
555 0x11E69ED7L, 0x2338EA63L, 0x53C2DD94L, 0xC2C21634L,
556 0xBBCBEE56L, 0x90BCB6DEL, 0xEBFC7DA1L, 0xCE591D76L,
557 0x6F05E409L, 0x4B7C0188L, 0x39720A3DL, 0x7C927C24L,
558 0x86E3725FL, 0x724D9DB9L, 0x1AC15BB4L, 0xD39EB8FCL,
559
560 0xED545578L, 0x08FCA5B5L, 0xD83D7CD3L, 0x4DAD0FC4L,
561 0x1E50EF5EL, 0xB161E6F8L, 0xA28514D9L, 0x6C51133CL,
562 0x6FD5C7E7L, 0x56E14EC4L, 0x362ABFCEL, 0xDDC6C837L,
563 0xD79A3234L, 0x92638212L, 0x670EFA8EL, 0x406000E0L
564 },
565
566 /* S[3] */
567 {
568 0x3A39CE37L, 0xD3FAF5CFL, 0xABC27737L, 0x5AC52D1BL,
569 0x5CB0679EL, 0x4FA33742L, 0xD3822740L, 0x99BC9BBEL,
570 0xD5118E9DL, 0xBF0F7315L, 0xD62D1C7EL, 0xC700C47BL,
571 0xB78C1B6BL, 0x21A19045L, 0xB26EB1BEL, 0x6A366EB4L,
572
573 0x5748AB2FL, 0xBC946E79L, 0xC6A376D2L, 0x6549C2C8L,
574 0x530FF8EEL, 0x468DDE7DL, 0xD5730A1DL, 0x4CD04DC6L,
575 0x2939BBDBL, 0xA9BA4650L, 0xAC9526E8L, 0xBE5EE304L,
576 0xA1FAD5F0L, 0x6A2D519AL, 0x63EF8CE2L, 0x9A86EE22L,
577
578 0xC089C2B8L, 0x43242EF6L, 0xA51E03AAL, 0x9CF2D0A4L,
579 0x83C061BAL, 0x9BE96A4DL, 0x8FE51550L, 0xBA645BD6L,
580 0x2826A2F9L, 0xA73A3AE1L, 0x4BA99586L, 0xEF5562E9L,
581 0xC72FEFD3L, 0xF752F7DAL, 0x3F046F69L, 0x77FA0A59L,
582
583 0x80E4A915L, 0x87B08601L, 0x9B09E6ADL, 0x3B3EE593L,
584 0xE990FD5AL, 0x9E34D797L, 0x2CF0B7D9L, 0x022B8B51L,
585 0x96D5AC3AL, 0x017DA67DL, 0xD1CF3ED6L, 0x7C7D2D28L,
586 0x1F9F25CFL, 0xADF2B89BL, 0x5AD6B472L, 0x5A88F54CL,
587
588 0xE029AC71L, 0xE019A5E6L, 0x47B0ACFDL, 0xED93FA9BL,
589 0xE8D3C48DL, 0x283B57CCL, 0xF8D56629L, 0x79132E28L,
590 0x785F0191L, 0xED756055L, 0xF7960E44L, 0xE3D35E8CL,
591 0x15056DD4L, 0x88F46DBAL, 0x03A16125L, 0x0564F0BDL,
592
593 0xC3EB9E15L, 0x3C9057A2L, 0x97271AECL, 0xA93A072AL,
594 0x1B3F6D9BL, 0x1E6321F5L, 0xF59C66FBL, 0x26DCF319L,
595 0x7533D928L, 0xB155FDF5L, 0x03563482L, 0x8ABA3CBBL,
596 0x28517711L, 0xC20AD9F8L, 0xABCC5167L, 0xCCAD925FL,
597
598 0x4DE81751L, 0x3830DC8EL, 0x379D5862L, 0x9320F991L,
599 0xEA7A90C2L, 0xFB3E7BCEL, 0x5121CE64L, 0x774FBE32L,
600 0xA8B6E37EL, 0xC3293D46L, 0x48DE5369L, 0x6413E680L,
601 0xA2AE0810L, 0xDD6DB224L, 0x69852DFDL, 0x09072166L,
602
603 0xB39A460AL, 0x6445C0DDL, 0x586CDECFL, 0x1C20C8AEL,
604 0x5BBEF7DDL, 0x1B588D40L, 0xCCD2017FL, 0x6BB4E3BBL,
605 0xDDA26A7EL, 0x3A59FF45L, 0x3E350A44L, 0xBCB4CDD5L,
606 0x72EACEA8L, 0xFA6484BBL, 0x8D6612AEL, 0xBF3C6F47L,
607
608 0xD29BE463L, 0x542F5D9EL, 0xAEC2771BL, 0xF64E6370L,
609 0x740E0D8DL, 0xE75B1357L, 0xF8721671L, 0xAF537D5DL,
610 0x4040CB08L, 0x4EB4E2CCL, 0x34D2466AL, 0x0115AF84L,
611 0xE1B00428L, 0x95983A1DL, 0x06B89FB4L, 0xCE6EA048L,
612
613 0x6F3F3B82L, 0x3520AB82L, 0x011A1D4BL, 0x277227F8L,
614 0x611560B1L, 0xE7933FDCL, 0xBB3A792BL, 0x344525BDL,
615 0xA08839E1L, 0x51CE794BL, 0x2F32C9B7L, 0xA01FBAC9L,
616 0xE01CC87EL, 0xBCC7D1F6L, 0xCF0111C3L, 0xA1E8AAC7L,
617
618 0x1A908749L, 0xD44FBD9AL, 0xD0DADECBL, 0xD50ADA38L,
619 0x0339C32AL, 0xC6913667L, 0x8DF9317CL, 0xE0B12B4FL,
620 0xF79E59B7L, 0x43F5BB3AL, 0xF2D519FFL, 0x27D9459CL,
621 0xBF97222CL, 0x15E6FC2AL, 0x0F91FC71L, 0x9B941525L,
622
623 0xFAE59361L, 0xCEB69CEBL, 0xC2A86459L, 0x12BAA8D1L,
624 0xB6C1075EL, 0xE3056A0CL, 0x10D25065L, 0xCB03A442L,
625 0xE0EC6E0EL, 0x1698DB3BL, 0x4C98A0BEL, 0x3278E964L,
626 0x9F1F9532L, 0xE0D392DFL, 0xD3A0342BL, 0x8971F21EL,
627
628 0x1B0A7441L, 0x4BA3348CL, 0xC5BE7120L, 0xC37632D8L,
629 0xDF359F8DL, 0x9B992F2EL, 0xE60B6F47L, 0x0FE3F11DL,
630 0xE54CDA54L, 0x1EDAD891L, 0xCE6279CFL, 0xCD3E7E6FL,
631 0x1618B166L, 0xFD2C1D05L, 0x848FD2C5L, 0xF6FB2299L,
632
633 0xF523F357L, 0xA6327623L, 0x93A83531L, 0x56CCCD02L,
634 0xACF08162L, 0x5A75EBB5L, 0x6E163697L, 0x88D273CCL,
635 0xDE966292L, 0x81B949D0L, 0x4C50901BL, 0x71C65614L,
636 0xE6C6C7BDL, 0x327A140AL, 0x45E1D006L, 0xC3F27B9AL,
637
638 0xC9AA53FDL, 0x62A80F00L, 0xBB25BFE2L, 0x35BDD2F6L,
639 0x71126905L, 0xB2040222L, 0xB6CBCF7CL, 0xCD769C2BL,
640 0x53113EC0L, 0x1640E3D3L, 0x38ABBD60L, 0x2547ADF0L,
641 0xBA38209CL, 0xF746CE76L, 0x77AFA1C5L, 0x20756060L,
642
643 0x85CBFE4EL, 0x8AE88DD8L, 0x7AAAF9B0L, 0x4CF9AA7EL,
644 0x1948C25CL, 0x02FB8A8CL, 0x01C36AE4L, 0xD6EBE1F9L,
645 0x90D4F869L, 0xA65CDEA0L, 0x3F09252DL, 0xC208E69FL,
646 0xB74E6132L, 0xCE77E25BL, 0x578FDFE3L, 0x3AC372E6L
647 }
648 },
649
650 /* P */
651 {
652 0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L,
653 0xA4093822L, 0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L,
654 0x452821E6L, 0x38D01377L, 0xBE5466CFL, 0x34E90C6CL,
655 0xC0AC29B7L, 0xC97C50DDL, 0x3F84D5B5L, 0xB5470917L,
656 0x9216D5D9L, 0x8979FB1BL
657 }
658 };
659
660 /*
661 * __rtl_cipherBF_init.
662 */
663 static rtlCipherError __rtl_cipherBF_init (
664 CipherContextBF *ctx,
665 rtlCipherMode eMode,
666 const sal_uInt8 *pKeyData, sal_Size nKeyLen,
667 const sal_uInt8 *pArgData, sal_Size nArgLen)
668 {
669 CipherKeyBF *key;
670 sal_uInt32 D, DL, DR;
671 sal_uInt16 i, j, k;
672
673 key = &(ctx->m_key);
674
675 rtl_copyMemory (key, &__rtl_cipherBF_key, sizeof (CipherKeyBF));
676 rtl_zeroMemory (&(ctx->m_iv), sizeof(ctx->m_iv));
677 ctx->m_offset = 0;
678
679 for (i = 0, k = 0; i < CIPHER_ROUNDS_BF + 2; ++i)
680 {
681 D = 0;
682 for (j = 0; j < 4; ++j)
683 {
684 D = ((D << 8) | pKeyData[k]);
685 k++;
686 if (k >= nKeyLen)
687 k = 0;
688 }
689 key->m_P[i] ^= D;
690 }
691
692 DL = 0;
693 DR = 0;
694
695 for (i = 0; i < CIPHER_ROUNDS_BF + 2; i += 2)
696 {
697 __rtl_cipherBF_encode (key, &DL, &DR);
698 key->m_P[i ] = DL;
699 key->m_P[i + 1] = DR;
700 }
701
702 for (i = 0; i < 4; ++i)
703 {
704 for (k = 0; k < 256; k += 2)
705 {
706 __rtl_cipherBF_encode (key, &DL, &DR);
707 key->m_S[i][k ] = DL;
708 key->m_S[i][k + 1] = DR;
709 }
710 }
711
712 if (pArgData && nArgLen)
713 {
714 nArgLen = ((nArgLen < 8) ? nArgLen : 8);
715 if (eMode == rtl_Cipher_ModeStream)
716 {
717 rtl_copyMemory (ctx->m_iv.m_byte, pArgData, nArgLen);
718 }
719 else
720 {
721 RTL_CIPHER_NTOHL64 (pArgData, DL, DR, nArgLen);
722 ctx->m_iv.m_long[0] = DL;
723 ctx->m_iv.m_long[1] = DR;
724 }
725 }
726
727 D = DL = DR = 0;
728 return rtl_Cipher_E_None;
729 }
730
731 /*
732 * __rtl_cipherBF_update.
733 */
734 static rtlCipherError __rtl_cipherBF_update (
735 CipherContextBF *ctx,
736 rtlCipherMode eMode,
737 rtlCipherDirection eDirection,
738 const sal_uInt8 *pData, sal_Size nDatLen,
739 sal_uInt8 *pBuffer, sal_Size nBufLen)
740 {
741 /* Check arguments. */
742 if ((pData == NULL) || (pBuffer == NULL))
743 return rtl_Cipher_E_Argument;
744
745 if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
746 return rtl_Cipher_E_BufferSize;
747
748 /* Update. */
749 if (eMode == rtl_Cipher_ModeECB)
750 {
751 /* Block mode. */
752 while (nDatLen > 8)
753 {
754 __rtl_cipherBF_updateECB (ctx, eDirection, pData, pBuffer, 8);
755 nDatLen -= 8;
756 pData += 8;
757 pBuffer += 8;
758 }
759 __rtl_cipherBF_updateECB (ctx, eDirection, pData, pBuffer, nDatLen);
760 }
761 else if (eMode == rtl_Cipher_ModeCBC)
762 {
763 /* Block mode. */
764 while (nDatLen > 8)
765 {
766 __rtl_cipherBF_updateCBC (ctx, eDirection, pData, pBuffer, 8);
767 nDatLen -= 8;
768 pData += 8;
769 pBuffer += 8;
770 }
771 __rtl_cipherBF_updateCBC (ctx, eDirection, pData, pBuffer, nDatLen);
772 }
773 else
774 {
775 /* Stream mode. */
776 while (nDatLen > 0)
777 {
778 __rtl_cipherBF_updateCFB (ctx, eDirection, pData, pBuffer);
779 nDatLen -= 1;
780 pData += 1;
781 pBuffer += 1;
782 }
783 }
784 return rtl_Cipher_E_None;
785 }
786
787 /*
788 * __rtl_cipherBF_updateECB.
789 */
790 static void __rtl_cipherBF_updateECB (
791 CipherContextBF *ctx,
792 rtlCipherDirection direction,
793 const sal_uInt8 *pData,
794 sal_uInt8 *pBuffer,
795 sal_Size nLength)
796 {
797 CipherKeyBF *key;
798 sal_uInt32 DL, DR;
799
800 key = &(ctx->m_key);
801 if (direction == rtl_Cipher_DirectionEncode)
802 {
803 RTL_CIPHER_NTOHL64(pData, DL, DR, nLength);
804
805 __rtl_cipherBF_encode (key, &DL, &DR);
806
807 RTL_CIPHER_HTONL(DL, pBuffer);
808 RTL_CIPHER_HTONL(DR, pBuffer);
809 }
810 else
811 {
812 RTL_CIPHER_NTOHL(pData, DL);
813 RTL_CIPHER_NTOHL(pData, DR);
814
815 __rtl_cipherBF_decode (key, &DL, &DR);
816
817 RTL_CIPHER_HTONL64(DL, DR, pBuffer, nLength);
818 }
819 DL = DR = 0;
820 }
821
822 /*
823 * __rtl_cipherBF_updateCBC.
824 */
825 static void __rtl_cipherBF_updateCBC (
826 CipherContextBF *ctx,
827 rtlCipherDirection direction,
828 const sal_uInt8 *pData,
829 sal_uInt8 *pBuffer,
830 sal_Size nLength)
831 {
832 CipherKeyBF *key;
833 sal_uInt32 DL, DR;
834
835 key = &(ctx->m_key);
836 if (direction == rtl_Cipher_DirectionEncode)
837 {
838 RTL_CIPHER_NTOHL64(pData, DL, DR, nLength);
839
840 DL ^= ctx->m_iv.m_long[0];
841 DR ^= ctx->m_iv.m_long[1];
842
843 __rtl_cipherBF_encode (key, &DL, &DR);
844
845 ctx->m_iv.m_long[0] = DL;
846 ctx->m_iv.m_long[1] = DR;
847
848 RTL_CIPHER_HTONL(DL, pBuffer);
849 RTL_CIPHER_HTONL(DR, pBuffer);
850 }
851 else
852 {
853 sal_uInt32 IVL, IVR;
854
855 RTL_CIPHER_NTOHL(pData, DL);
856 RTL_CIPHER_NTOHL(pData, DR);
857
858 IVL = DL;
859 IVR = DR;
860
861 __rtl_cipherBF_decode (key, &DL, &DR);
862
863 DL ^= ctx->m_iv.m_long[0];
864 DR ^= ctx->m_iv.m_long[1];
865
866 ctx->m_iv.m_long[0] = IVL;
867 ctx->m_iv.m_long[1] = IVR;
868
869 RTL_CIPHER_HTONL64(DL, DR, pBuffer, nLength);
870 IVL = IVR = 0;
871 }
872 DL = DR = 0;
873 }
874
875 /*
876 * __rtl_cipherBF_updateCFB.
877 */
878 static void __rtl_cipherBF_updateCFB (
879 CipherContextBF *ctx,
880 rtlCipherDirection direction,
881 const sal_uInt8 *pData,
882 sal_uInt8 *pBuffer)
883 {
884 sal_uInt8 *iv;
885 sal_uInt32 k;
886
887 iv = ctx->m_iv.m_byte;
888 k = ctx->m_offset;
889
890 if (k == 0)
891 {
892 sal_uInt32 IVL, IVR;
893
894 RTL_CIPHER_NTOHL64(iv, IVL, IVR, 8);
895 __rtl_cipherBF_encode (&(ctx->m_key), &IVL, &IVR);
896 RTL_CIPHER_HTONL64(IVL, IVR, iv, 8);
897
898 IVL = IVR = 0;
899 }
900
901 if (direction == rtl_Cipher_DirectionEncode)
902 {
903 iv[k] ^= *pData;
904 *pBuffer = iv[k];
905 }
906 else
907 {
908 sal_uInt8 c = iv[k];
909 iv[k] = *pData;
910 *pBuffer = *pData ^ c;
911 c = 0;
912 }
913
914 ctx->m_offset = ((k + 1) & 0x07);
915 iv = NULL;
916 }
917
918 /*
919 * __rtl_cipherBF_encode.
920 */
921 static void __rtl_cipherBF_encode (
922 CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr)
923 {
924 sal_uInt32 t, XL, XR;
925 sal_uInt16 i;
926
927 XL = *xl;
928 XR = *xr;
929
930 for (i = 0; i < CIPHER_ROUNDS_BF; ++i)
931 {
932 XL ^= key->m_P[i];
933 XR ^= __rtl_cipherBF (key, XL);
934
935 t = XL;
936 XL = XR;
937 XR = t;
938 }
939
940 t = XL;
941 XL = XR;
942 XR = t;
943
944 XR ^= key->m_P[CIPHER_ROUNDS_BF ];
945 XL ^= key->m_P[CIPHER_ROUNDS_BF + 1];
946
947 *xl = XL;
948 *xr = XR;
949
950 t = XL = XR = 0;
951 }
952
953 /*
954 * __rtl_cipherBF_decode.
955 */
956 static void __rtl_cipherBF_decode (
957 CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr)
958 {
959 sal_uInt32 t, XL, XR;
960 sal_uInt16 i;
961
962 XL = *xl;
963 XR = *xr;
964
965 for (i = CIPHER_ROUNDS_BF + 1; i > 1; --i)
966 {
967 XL ^= key->m_P[i];
968 XR ^= __rtl_cipherBF (key, XL);
969
970 t = XL;
971 XL = XR;
972 XR = t;
973 }
974
975 t = XL;
976 XL = XR;
977 XR = t;
978
979 XR ^= key->m_P[1];
980 XL ^= key->m_P[0];
981
982 *xl = XL;
983 *xr = XR;
984
985 t = XL = XR = 0;
986 }
987
988 /*
989 * __rtl_cipherBF.
990 */
991 static sal_uInt32 __rtl_cipherBF (CipherKeyBF *key, sal_uInt32 x)
992 {
993 sal_uInt16 a, b, c, d;
994 sal_uInt32 y;
995
996 d = (sal_uInt16)(x & 0x00ff);
997 x >>= 8;
998 c = (sal_uInt16)(x & 0x00ff);
999 x >>= 8;
1000 b = (sal_uInt16)(x & 0x00ff);
1001 x >>= 8;
1002 a = (sal_uInt16)(x & 0x00ff);
1003
1004 y = key->m_S[0][a];
1005 y += key->m_S[1][b];
1006 y ^= key->m_S[2][c];
1007 y += key->m_S[3][d];
1008
1009 return y;
1010 }
1011
1012 /*========================================================================
1013 *
1014 * rtl_cipherBF (Blowfish) implementation.
1015 *
1016 * Reference:
1017 * Bruce Schneier: Applied Cryptography, 2nd edition, ch. 14.3
1018 *
1019 *======================================================================*/
1020 /*
1021 * rtl_cipher_createBF.
1022 */
1023 rtlCipher SAL_CALL rtl_cipher_createBF (rtlCipherMode Mode)
1024 {
1025 CipherBF_Impl *pImpl = (CipherBF_Impl*)NULL;
1026
1027 if (Mode == rtl_Cipher_ModeInvalid)
1028 return ((rtlCipher)NULL);
1029
1030 pImpl = ((CipherBF_Impl*)rtl_allocateZeroMemory (sizeof (CipherBF_Impl)));
1031 if (pImpl)
1032 {
1033 pImpl->m_cipher.m_algorithm = rtl_Cipher_AlgorithmBF;
1034 pImpl->m_cipher.m_direction = rtl_Cipher_DirectionInvalid;
1035 pImpl->m_cipher.m_mode = Mode;
1036
1037 pImpl->m_cipher.m_init = rtl_cipher_initBF;
1038 pImpl->m_cipher.m_encode = rtl_cipher_encodeBF;
1039 pImpl->m_cipher.m_decode = rtl_cipher_decodeBF;
1040 pImpl->m_cipher.m_delete = rtl_cipher_destroyBF;
1041 }
1042 return ((rtlCipher)pImpl);
1043 }
1044
1045 /*
1046 * rtl_cipher_initBF.
1047 */
1048 rtlCipherError SAL_CALL rtl_cipher_initBF (
1049 rtlCipher Cipher,
1050 rtlCipherDirection Direction,
1051 const sal_uInt8 *pKeyData, sal_Size nKeyLen,
1052 const sal_uInt8 *pArgData, sal_Size nArgLen)
1053 {
1054 CipherBF_Impl *pImpl = (CipherBF_Impl*)Cipher;
1055
1056 if ((pImpl == NULL) || (pKeyData == NULL))
1057 return rtl_Cipher_E_Argument;
1058
1059 if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
1060 return rtl_Cipher_E_Algorithm;
1061
1062 if (!(Direction == rtl_Cipher_DirectionInvalid))
1063 pImpl->m_cipher.m_direction = Direction;
1064 else
1065 return rtl_Cipher_E_Direction;
1066
1067 return __rtl_cipherBF_init (
1068 &(pImpl->m_context), pImpl->m_cipher.m_mode,
1069 pKeyData, nKeyLen, pArgData, nArgLen);
1070 }
1071
1072 /*
1073 * rtl_cipher_encodeBF.
1074 */
1075 rtlCipherError SAL_CALL rtl_cipher_encodeBF (
1076 rtlCipher Cipher,
1077 const void *pData, sal_Size nDatLen,
1078 sal_uInt8 *pBuffer, sal_Size nBufLen)
1079 {
1080 CipherBF_Impl *pImpl = (CipherBF_Impl*)Cipher;
1081 if (pImpl == NULL)
1082 return rtl_Cipher_E_Argument;
1083
1084 if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
1085 return rtl_Cipher_E_Algorithm;
1086
1087 if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1088 return rtl_Cipher_E_Direction;
1089 if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionDecode)
1090 return rtl_Cipher_E_Direction;
1091
1092 return __rtl_cipherBF_update (
1093 &(pImpl->m_context), pImpl->m_cipher.m_mode,
1094 rtl_Cipher_DirectionEncode,
1095 (const sal_uInt8*)pData, nDatLen, pBuffer, nBufLen);
1096 }
1097
1098 /*
1099 * rtl_cipher_decodeBF.
1100 */
1101 rtlCipherError SAL_CALL rtl_cipher_decodeBF (
1102 rtlCipher Cipher,
1103 const void *pData, sal_Size nDatLen,
1104 sal_uInt8 *pBuffer, sal_Size nBufLen)
1105 {
1106 CipherBF_Impl *pImpl = (CipherBF_Impl*)Cipher;
1107 if (pImpl == NULL)
1108 return rtl_Cipher_E_Argument;
1109
1110 if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
1111 return rtl_Cipher_E_Algorithm;
1112
1113 if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1114 return rtl_Cipher_E_Direction;
1115 if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionEncode)
1116 return rtl_Cipher_E_Direction;
1117
1118 return __rtl_cipherBF_update (
1119 &(pImpl->m_context), pImpl->m_cipher.m_mode,
1120 rtl_Cipher_DirectionDecode,
1121 (const sal_uInt8*)pData, nDatLen, pBuffer, nBufLen);
1122 }
1123
1124 /*
1125 * rtl_cipher_destroyBF.
1126 */
1127 void SAL_CALL rtl_cipher_destroyBF (rtlCipher Cipher)
1128 {
1129 CipherBF_Impl *pImpl = (CipherBF_Impl*)Cipher;
1130 if (pImpl)
1131 {
1132 if (pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF)
1133 rtl_freeZeroMemory (pImpl, sizeof (CipherBF_Impl));
1134 else
1135 rtl_freeMemory (pImpl);
1136 }
1137 }
1138
1139 /*========================================================================
1140 *
1141 * rtl_cipher_ARCFOUR (RC4) internals.
1142 *
1143 *======================================================================*/
1144 #define CIPHER_CBLOCK_ARCFOUR 256
1145
1146 typedef struct cipherARCFOUR_context_st
1147 {
1148 unsigned int m_S[CIPHER_CBLOCK_ARCFOUR];
1149 unsigned int m_X, m_Y;
1150 } ContextARCFOUR_Impl;
1151
1152 typedef struct cipherARCFOUR_impl_st
1153 {
1154 Cipher_Impl m_cipher;
1155 ContextARCFOUR_Impl m_context;
1156 } CipherARCFOUR_Impl;
1157
1158 /** rtl_cipherARCFOUR_update_Impl.
1159 */
1160 static rtlCipherError rtl_cipherARCFOUR_update_Impl (
1161 ContextARCFOUR_Impl *ctx,
1162 const sal_uInt8 *pData, sal_Size nDatLen,
1163 sal_uInt8 *pBuffer, sal_Size nBufLen);
1164
1165 /*
1166 * rtl_cipherARCFOUR_init_Impl.
1167 */
1168 static rtlCipherError rtl_cipherARCFOUR_init_Impl (
1169 ContextARCFOUR_Impl *ctx,
1170 const sal_uInt8 *pKeyData, sal_Size nKeyLen)
1171 {
1172 unsigned int K[CIPHER_CBLOCK_ARCFOUR];
1173 unsigned int *L, *S;
1174 unsigned int x, y, t;
1175 sal_Size n, k;
1176
1177 S = &(ctx->m_S[0]);
1178
1179 /* Initialize S linearly. */
1180 for (x = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
1181 S[x] = x;
1182
1183 /* Initialize K with key, repeat key as necessary. */
1184 for (L = K, n = CIPHER_CBLOCK_ARCFOUR; n > nKeyLen; n -= nKeyLen)
1185 {
1186 for (k = 0; k < nKeyLen; k++) L[k] = pKeyData[k];
1187 L += nKeyLen;
1188 }
1189 for (k = 0; k < n; k++) L[k] = pKeyData[k];
1190
1191 /* Initialize S with K. */
1192 for (x = 0, y = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
1193 {
1194 y = (y + S[x] + K[x]) % CIPHER_CBLOCK_ARCFOUR;
1195 t = S[x], S[x] = S[y], S[y] = t; /* swap S[x] and S[y] */
1196 }
1197
1198 /* Initialize counters X and Y. */
1199 ctx->m_X = 0;
1200 ctx->m_Y = 0;
1201
1202 return rtl_Cipher_E_None;
1203 }
1204
1205 /*
1206 * rtl_cipherARCFOUR_update_Impl.
1207 */
1208 static rtlCipherError rtl_cipherARCFOUR_update_Impl (
1209 ContextARCFOUR_Impl *ctx,
1210 const sal_uInt8 *pData, sal_Size nDatLen,
1211 sal_uInt8 *pBuffer, sal_Size nBufLen)
1212 {
1213 register unsigned int *S;
1214 register unsigned int x, y, t;
1215 sal_Size k;
1216
1217 /* Check arguments. */
1218 if ((pData == NULL) || (pBuffer == NULL))
1219 return rtl_Cipher_E_Argument;
1220
1221 if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
1222 return rtl_Cipher_E_BufferSize;
1223
1224 /* Update. */
1225 S = &(ctx->m_S[0]);
1226 for (k = 0; k < nDatLen; k++)
1227 {
1228 /* Update counters X and Y. */
1229 x = ctx->m_X;
1230 y = ctx->m_Y;
1231 x = (x + 1 ) % CIPHER_CBLOCK_ARCFOUR;
1232 y = (y + S[x]) % CIPHER_CBLOCK_ARCFOUR;
1233 ctx->m_X = x;
1234 ctx->m_Y = y;
1235
1236 /* Swap S[x] and S[y]. */
1237 t = S[x], S[x] = S[y], S[y] = t;
1238
1239 /* Evaluate next key byte S[t]. */
1240 t = (S[x] + S[y]) % CIPHER_CBLOCK_ARCFOUR;
1241 pBuffer[k] = pData[k] ^ ((sal_uInt8)(S[t] & 0xff));
1242 }
1243
1244 return rtl_Cipher_E_None;
1245 }
1246
1247 /*========================================================================
1248 *
1249 * rtl_cipher_ARCFOUR (RC4) implementation.
1250 *
1251 * Reference:
1252 * Bruce Schneier: Applied Cryptography, 2nd edition, ch. 17.1
1253 *
1254 *======================================================================*/
1255 /*
1256 * rtl_cipher_createARCFOUR.
1257 */
1258 rtlCipher SAL_CALL rtl_cipher_createARCFOUR (rtlCipherMode Mode)
1259 {
1260 CipherARCFOUR_Impl *pImpl = (CipherARCFOUR_Impl*)NULL;
1261
1262 if (!(Mode == rtl_Cipher_ModeStream))
1263 return ((rtlCipher)NULL);
1264
1265 pImpl = ((CipherARCFOUR_Impl*)rtl_allocateZeroMemory (sizeof (CipherARCFOUR_Impl)));
1266 if (pImpl)
1267 {
1268 pImpl->m_cipher.m_algorithm = rtl_Cipher_AlgorithmARCFOUR;
1269 pImpl->m_cipher.m_direction = rtl_Cipher_DirectionInvalid;
1270 pImpl->m_cipher.m_mode = rtl_Cipher_ModeStream;
1271
1272 pImpl->m_cipher.m_init = rtl_cipher_initARCFOUR;
1273 pImpl->m_cipher.m_encode = rtl_cipher_encodeARCFOUR;
1274 pImpl->m_cipher.m_decode = rtl_cipher_decodeARCFOUR;
1275 pImpl->m_cipher.m_delete = rtl_cipher_destroyARCFOUR;
1276 }
1277 return ((rtlCipher)pImpl);
1278 }
1279
1280 /*
1281 * rtl_cipher_initARCFOUR.
1282 */
1283 rtlCipherError SAL_CALL rtl_cipher_initARCFOUR (
1284 rtlCipher Cipher,
1285 rtlCipherDirection Direction,
1286 const sal_uInt8 *pKeyData, sal_Size nKeyLen,
1287 const sal_uInt8 *pArgData, sal_Size nArgLen)
1288 {
1289 CipherARCFOUR_Impl *pImpl = (CipherARCFOUR_Impl*)Cipher;
1290 (void) pArgData; // avoid warning
1291 (void) nArgLen; // avoid warning
1292
1293 if ((pImpl == NULL) || (pKeyData == NULL))
1294 return rtl_Cipher_E_Argument;
1295
1296 if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
1297 return rtl_Cipher_E_Algorithm;
1298
1299 if (!(Direction == rtl_Cipher_DirectionInvalid))
1300 pImpl->m_cipher.m_direction = Direction;
1301 else
1302 return rtl_Cipher_E_Direction;
1303
1304 return rtl_cipherARCFOUR_init_Impl (&(pImpl->m_context), pKeyData, nKeyLen);
1305 }
1306
1307 /*
1308 * rtl_cipher_encodeARCFOUR.
1309 */
1310 rtlCipherError SAL_CALL rtl_cipher_encodeARCFOUR (
1311 rtlCipher Cipher,
1312 const void *pData, sal_Size nDatLen,
1313 sal_uInt8 *pBuffer, sal_Size nBufLen)
1314 {
1315 CipherARCFOUR_Impl *pImpl = (CipherARCFOUR_Impl*)Cipher;
1316 if (pImpl == NULL)
1317 return rtl_Cipher_E_Argument;
1318
1319 if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
1320 return rtl_Cipher_E_Algorithm;
1321
1322 if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1323 return rtl_Cipher_E_Direction;
1324
1325 return rtl_cipherARCFOUR_update_Impl (
1326 &(pImpl->m_context),
1327 (const sal_uInt8*)pData, nDatLen, pBuffer, nBufLen);
1328 }
1329
1330 /*
1331 * rtl_cipher_decodeARCFOUR.
1332 */
1333 rtlCipherError SAL_CALL rtl_cipher_decodeARCFOUR (
1334 rtlCipher Cipher,
1335 const void *pData, sal_Size nDatLen,
1336 sal_uInt8 *pBuffer, sal_Size nBufLen)
1337 {
1338 CipherARCFOUR_Impl *pImpl = (CipherARCFOUR_Impl*)Cipher;
1339 if (pImpl == NULL)
1340 return rtl_Cipher_E_Argument;
1341
1342 if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
1343 return rtl_Cipher_E_Algorithm;
1344
1345 if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1346 return rtl_Cipher_E_Direction;
1347
1348 return rtl_cipherARCFOUR_update_Impl (
1349 &(pImpl->m_context),
1350 (const sal_uInt8*)pData, nDatLen, pBuffer, nBufLen);
1351 }
1352
1353 /*
1354 * rtl_cipher_destroyARCFOUR.
1355 */
1356 void SAL_CALL rtl_cipher_destroyARCFOUR (rtlCipher Cipher)
1357 {
1358 CipherARCFOUR_Impl *pImpl = (CipherARCFOUR_Impl*)Cipher;
1359 if (pImpl)
1360 {
1361 if (pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR)
1362 rtl_freeZeroMemory (pImpl, sizeof (CipherARCFOUR_Impl));
1363 else
1364 rtl_freeMemory (pImpl);
1365 }
1366 }
vba interoperability for OOo