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