Line data Source code
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 285 : rtlCipher SAL_CALL rtl_cipher_create (
112 : rtlCipherAlgorithm Algorithm,
113 : rtlCipherMode Mode) SAL_THROW_EXTERN_C()
114 : {
115 285 : rtlCipher Cipher = nullptr;
116 285 : switch (Algorithm)
117 : {
118 : case rtl_Cipher_AlgorithmBF:
119 80 : Cipher = rtl_cipher_createBF (Mode);
120 80 : break;
121 :
122 : case rtl_Cipher_AlgorithmARCFOUR:
123 201 : Cipher = rtl_cipher_createARCFOUR (Mode);
124 201 : break;
125 :
126 : default: /* rtl_Cipher_AlgorithmInvalid */
127 4 : break;
128 : }
129 285 : return Cipher;
130 : }
131 :
132 : /*
133 : * rtl_cipher_init.
134 : */
135 244 : 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 244 : Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
142 244 : if (pImpl == NULL)
143 0 : return rtl_Cipher_E_Argument;
144 244 : if (pImpl->m_init == NULL)
145 0 : return rtl_Cipher_E_Unknown;
146 :
147 : return (pImpl->m_init)(
148 244 : Cipher, Direction, pKeyData, nKeyLen, pArgData, nArgLen);
149 : }
150 :
151 : /*
152 : * rtl_cipher_encode.
153 : */
154 43 : 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 43 : Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
160 43 : if (pImpl == NULL)
161 0 : return rtl_Cipher_E_Argument;
162 43 : if (pImpl->m_encode == NULL)
163 0 : return rtl_Cipher_E_Unknown;
164 :
165 43 : return (pImpl->m_encode)(Cipher, pData, nDatLen, pBuffer, nBufLen);
166 : }
167 :
168 : /*
169 : * rtl_cipher_decode.
170 : */
171 4170 : 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 4170 : Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
177 4170 : if (pImpl == NULL)
178 0 : return rtl_Cipher_E_Argument;
179 4170 : if (pImpl->m_decode == NULL)
180 0 : return rtl_Cipher_E_Unknown;
181 :
182 4170 : return (pImpl->m_decode)(Cipher, pData, nDatLen, pBuffer, nBufLen);
183 : }
184 :
185 : /*
186 : * rtl_cipher_destroy.
187 : */
188 283 : void SAL_CALL rtl_cipher_destroy (rtlCipher Cipher) SAL_THROW_EXTERN_C()
189 : {
190 283 : Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
191 283 : if (pImpl && pImpl->m_delete)
192 283 : pImpl->m_delete (Cipher);
193 283 : }
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 75 : 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 75 : key = &(ctx->m_key);
662 :
663 75 : memcpy (key, &__rtl_cipherBF_key, sizeof (CipherKeyBF));
664 75 : memset (&(ctx->m_iv), 0, sizeof(ctx->m_iv));
665 75 : ctx->m_offset = 0;
666 :
667 1425 : for (i = 0, k = 0; i < CIPHER_ROUNDS_BF + 2; ++i)
668 : {
669 1350 : D = 0;
670 6750 : for (j = 0; j < 4; ++j)
671 : {
672 5400 : D = ((D << 8) | pKeyData[k]);
673 5400 : k++;
674 5400 : if (k >= nKeyLen)
675 300 : k = 0;
676 : }
677 1350 : key->m_P[i] ^= D;
678 : }
679 :
680 75 : DL = 0;
681 75 : DR = 0;
682 :
683 750 : for (i = 0; i < CIPHER_ROUNDS_BF + 2; i += 2)
684 : {
685 675 : __rtl_cipherBF_encode (key, &DL, &DR);
686 675 : key->m_P[i ] = DL;
687 675 : key->m_P[i + 1] = DR;
688 : }
689 :
690 375 : for (i = 0; i < 4; ++i)
691 : {
692 38700 : for (k = 0; k < 256; k += 2)
693 : {
694 38400 : __rtl_cipherBF_encode (key, &DL, &DR);
695 38400 : key->m_S[i][k ] = DL;
696 38400 : key->m_S[i][k + 1] = DR;
697 : }
698 : }
699 :
700 75 : if (pArgData && nArgLen)
701 : {
702 28 : nArgLen = ((nArgLen < 8) ? nArgLen : 8);
703 28 : if (eMode == rtl_Cipher_ModeStream)
704 : {
705 8 : memcpy (ctx->m_iv.m_byte, pArgData, nArgLen);
706 : }
707 : else
708 : {
709 20 : RTL_CIPHER_NTOHL64 (pArgData, DL, DR, nArgLen);
710 20 : ctx->m_iv.m_long[0] = DL;
711 20 : ctx->m_iv.m_long[1] = DR;
712 : }
713 : }
714 :
715 75 : return rtl_Cipher_E_None;
716 : }
717 :
718 : /*
719 : * __rtl_cipherBF_update.
720 : */
721 75 : 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 75 : if ((pData == NULL) || (pBuffer == NULL))
730 0 : return rtl_Cipher_E_Argument;
731 :
732 75 : if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
733 0 : return rtl_Cipher_E_BufferSize;
734 :
735 : /* Update. */
736 75 : if (eMode == rtl_Cipher_ModeECB)
737 : {
738 : /* Block mode. */
739 60 : while (nDatLen > 8)
740 : {
741 20 : __rtl_cipherBF_updateECB (ctx, eDirection, pData, pBuffer, 8);
742 20 : nDatLen -= 8;
743 20 : pData += 8;
744 20 : pBuffer += 8;
745 : }
746 20 : __rtl_cipherBF_updateECB (ctx, eDirection, pData, pBuffer, nDatLen);
747 : }
748 55 : else if (eMode == rtl_Cipher_ModeCBC)
749 : {
750 : /* Block mode. */
751 0 : while (nDatLen > 8)
752 : {
753 0 : __rtl_cipherBF_updateCBC (ctx, eDirection, pData, pBuffer, 8);
754 0 : nDatLen -= 8;
755 0 : pData += 8;
756 0 : pBuffer += 8;
757 : }
758 0 : __rtl_cipherBF_updateCBC (ctx, eDirection, pData, pBuffer, nDatLen);
759 : }
760 : else
761 : {
762 : /* Stream mode. */
763 8004 : while (nDatLen > 0)
764 : {
765 7894 : __rtl_cipherBF_updateCFB (ctx, eDirection, pData, pBuffer);
766 7894 : nDatLen -= 1;
767 7894 : pData += 1;
768 7894 : pBuffer += 1;
769 : }
770 : }
771 75 : return rtl_Cipher_E_None;
772 : }
773 :
774 : /*
775 : * __rtl_cipherBF_updateECB.
776 : */
777 40 : 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 40 : key = &(ctx->m_key);
788 40 : if (direction == rtl_Cipher_DirectionEncode)
789 : {
790 32 : RTL_CIPHER_NTOHL64(pData, DL, DR, nLength);
791 :
792 32 : __rtl_cipherBF_encode (key, &DL, &DR);
793 :
794 32 : RTL_CIPHER_HTONL(DL, pBuffer);
795 32 : RTL_CIPHER_HTONL(DR, pBuffer);
796 : }
797 : else
798 : {
799 8 : RTL_CIPHER_NTOHL(pData, DL);
800 8 : RTL_CIPHER_NTOHL(pData, DR);
801 :
802 8 : __rtl_cipherBF_decode (key, &DL, &DR);
803 :
804 8 : RTL_CIPHER_HTONL64(DL, DR, pBuffer, nLength);
805 : }
806 40 : DL = DR = 0;
807 40 : }
808 :
809 : /*
810 : * __rtl_cipherBF_updateCBC.
811 : */
812 0 : 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 0 : key = &(ctx->m_key);
823 0 : if (direction == rtl_Cipher_DirectionEncode)
824 : {
825 0 : RTL_CIPHER_NTOHL64(pData, DL, DR, nLength);
826 :
827 0 : DL ^= ctx->m_iv.m_long[0];
828 0 : DR ^= ctx->m_iv.m_long[1];
829 :
830 0 : __rtl_cipherBF_encode (key, &DL, &DR);
831 :
832 0 : ctx->m_iv.m_long[0] = DL;
833 0 : ctx->m_iv.m_long[1] = DR;
834 :
835 0 : RTL_CIPHER_HTONL(DL, pBuffer);
836 0 : RTL_CIPHER_HTONL(DR, pBuffer);
837 : }
838 : else
839 : {
840 : sal_uInt32 IVL, IVR;
841 :
842 0 : RTL_CIPHER_NTOHL(pData, DL);
843 0 : RTL_CIPHER_NTOHL(pData, DR);
844 :
845 0 : IVL = DL;
846 0 : IVR = DR;
847 :
848 0 : __rtl_cipherBF_decode (key, &DL, &DR);
849 :
850 0 : DL ^= ctx->m_iv.m_long[0];
851 0 : DR ^= ctx->m_iv.m_long[1];
852 :
853 0 : ctx->m_iv.m_long[0] = IVL;
854 0 : ctx->m_iv.m_long[1] = IVR;
855 :
856 0 : RTL_CIPHER_HTONL64(DL, DR, pBuffer, nLength);
857 : }
858 0 : DL = DR = 0;
859 0 : }
860 :
861 : /*
862 : * __rtl_cipherBF_updateCFB.
863 : */
864 7894 : 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 7894 : iv = ctx->m_iv.m_byte;
874 7894 : k = ctx->m_offset;
875 :
876 7894 : if (k == 0)
877 : {
878 : sal_uInt32 IVL, IVR;
879 :
880 1032 : RTL_CIPHER_NTOHL64(iv, IVL, IVR, 8);
881 1032 : __rtl_cipherBF_encode (&(ctx->m_key), &IVL, &IVR);
882 1032 : RTL_CIPHER_HTONL64(IVL, IVR, iv, 8);
883 :
884 1032 : IVL = IVR = 0;
885 : }
886 :
887 7894 : if (direction == rtl_Cipher_DirectionEncode)
888 : {
889 491 : iv[k] ^= *pData;
890 491 : *pBuffer = iv[k];
891 : }
892 : else
893 : {
894 7403 : sal_uInt8 c = iv[k];
895 7403 : iv[k] = *pData;
896 7403 : *pBuffer = *pData ^ c;
897 : }
898 :
899 7894 : ctx->m_offset = ((k + 1) & 0x07);
900 7894 : iv = NULL;
901 7894 : }
902 :
903 : /*
904 : * __rtl_cipherBF_encode.
905 : */
906 40139 : 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 40139 : XL = *xl;
913 40139 : XR = *xr;
914 :
915 682363 : for (i = 0; i < CIPHER_ROUNDS_BF; ++i)
916 : {
917 642224 : XL ^= key->m_P[i];
918 642224 : XR ^= __rtl_cipherBF (key, XL);
919 :
920 642224 : t = XL;
921 642224 : XL = XR;
922 642224 : XR = t;
923 : }
924 :
925 40139 : t = XL;
926 40139 : XL = XR;
927 40139 : XR = t;
928 :
929 40139 : XR ^= key->m_P[CIPHER_ROUNDS_BF ];
930 40139 : XL ^= key->m_P[CIPHER_ROUNDS_BF + 1];
931 :
932 40139 : *xl = XL;
933 40139 : *xr = XR;
934 :
935 40139 : }
936 :
937 : /*
938 : * __rtl_cipherBF_decode.
939 : */
940 8 : 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 8 : XL = *xl;
947 8 : XR = *xr;
948 :
949 136 : for (i = CIPHER_ROUNDS_BF + 1; i > 1; --i)
950 : {
951 128 : XL ^= key->m_P[i];
952 128 : XR ^= __rtl_cipherBF (key, XL);
953 :
954 128 : t = XL;
955 128 : XL = XR;
956 128 : XR = t;
957 : }
958 :
959 8 : t = XL;
960 8 : XL = XR;
961 8 : XR = t;
962 :
963 8 : XR ^= key->m_P[1];
964 8 : XL ^= key->m_P[0];
965 :
966 8 : *xl = XL;
967 8 : *xr = XR;
968 :
969 8 : }
970 :
971 : /*
972 : * __rtl_cipherBF.
973 : */
974 642352 : static sal_uInt32 __rtl_cipherBF (CipherKeyBF *key, sal_uInt32 x)
975 : {
976 : sal_uInt16 a, b, c, d;
977 : sal_uInt32 y;
978 :
979 642352 : d = (sal_uInt16)(x & 0x00ff);
980 642352 : x >>= 8;
981 642352 : c = (sal_uInt16)(x & 0x00ff);
982 642352 : x >>= 8;
983 642352 : b = (sal_uInt16)(x & 0x00ff);
984 642352 : x >>= 8;
985 642352 : a = (sal_uInt16)(x & 0x00ff);
986 :
987 642352 : y = key->m_S[0][a];
988 642352 : y += key->m_S[1][b];
989 642352 : y ^= key->m_S[2][c];
990 642352 : y += key->m_S[3][d];
991 :
992 642352 : 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 85 : rtlCipher SAL_CALL rtl_cipher_createBF (rtlCipherMode Mode) SAL_THROW_EXTERN_C()
1007 : {
1008 85 : CipherBF_Impl *pImpl = nullptr;
1009 :
1010 85 : if (Mode == rtl_Cipher_ModeInvalid)
1011 2 : return (nullptr);
1012 :
1013 83 : pImpl = static_cast<CipherBF_Impl*>(rtl_allocateZeroMemory (sizeof (CipherBF_Impl)));
1014 83 : if (pImpl)
1015 : {
1016 83 : pImpl->m_cipher.m_algorithm = rtl_Cipher_AlgorithmBF;
1017 83 : pImpl->m_cipher.m_direction = rtl_Cipher_DirectionInvalid;
1018 83 : pImpl->m_cipher.m_mode = Mode;
1019 :
1020 83 : pImpl->m_cipher.m_init = rtl_cipher_initBF;
1021 83 : pImpl->m_cipher.m_encode = rtl_cipher_encodeBF;
1022 83 : pImpl->m_cipher.m_decode = rtl_cipher_decodeBF;
1023 83 : pImpl->m_cipher.m_delete = rtl_cipher_destroyBF;
1024 : }
1025 83 : return (static_cast<rtlCipher>(pImpl));
1026 : }
1027 :
1028 : /*
1029 : * rtl_cipher_initBF.
1030 : */
1031 75 : 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 75 : CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
1038 :
1039 75 : if ((pImpl == NULL) || (pKeyData == NULL))
1040 0 : return rtl_Cipher_E_Argument;
1041 :
1042 75 : if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
1043 0 : return rtl_Cipher_E_Algorithm;
1044 :
1045 75 : if (!(Direction == rtl_Cipher_DirectionInvalid))
1046 75 : pImpl->m_cipher.m_direction = Direction;
1047 : else
1048 0 : return rtl_Cipher_E_Direction;
1049 :
1050 : return __rtl_cipherBF_init (
1051 : &(pImpl->m_context), pImpl->m_cipher.m_mode,
1052 75 : pKeyData, nKeyLen, pArgData, nArgLen);
1053 : }
1054 :
1055 : /*
1056 : * rtl_cipher_encodeBF.
1057 : */
1058 43 : 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 43 : CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
1064 43 : if (pImpl == NULL)
1065 0 : return rtl_Cipher_E_Argument;
1066 :
1067 43 : if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
1068 0 : return rtl_Cipher_E_Algorithm;
1069 :
1070 43 : if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1071 0 : return rtl_Cipher_E_Direction;
1072 43 : if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionDecode)
1073 0 : 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 43 : static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
1079 : }
1080 :
1081 : /*
1082 : * rtl_cipher_decodeBF.
1083 : */
1084 36 : 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 36 : CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
1090 36 : if (pImpl == NULL)
1091 0 : return rtl_Cipher_E_Argument;
1092 :
1093 36 : if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
1094 0 : return rtl_Cipher_E_Algorithm;
1095 :
1096 36 : if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1097 0 : return rtl_Cipher_E_Direction;
1098 36 : if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionEncode)
1099 4 : 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 32 : static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
1105 : }
1106 :
1107 : /*
1108 : * rtl_cipher_destroyBF.
1109 : */
1110 83 : void SAL_CALL rtl_cipher_destroyBF (rtlCipher Cipher) SAL_THROW_EXTERN_C()
1111 : {
1112 83 : CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
1113 83 : if (pImpl)
1114 : {
1115 83 : if (pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF)
1116 83 : rtl_freeZeroMemory (pImpl, sizeof (CipherBF_Impl));
1117 : else
1118 0 : rtl_freeMemory (pImpl);
1119 : }
1120 83 : }
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 169 : 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 169 : S = &(ctx->m_S[0]);
1161 :
1162 : /* Initialize S linearly. */
1163 43433 : for (x = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
1164 43264 : S[x] = x;
1165 :
1166 : /* Initialize K with key, repeat key as necessary. */
1167 14534 : for (L = K, n = CIPHER_CBLOCK_ARCFOUR; n > nKeyLen; n -= nKeyLen)
1168 : {
1169 14365 : for (k = 0; k < nKeyLen; k++) L[k] = pKeyData[k];
1170 14365 : L += nKeyLen;
1171 : }
1172 169 : for (k = 0; k < n; k++) L[k] = pKeyData[k];
1173 :
1174 : /* Initialize S with K. */
1175 43433 : for (x = 0, y = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
1176 : {
1177 43264 : y = (y + S[x] + K[x]) % CIPHER_CBLOCK_ARCFOUR;
1178 43264 : 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 169 : ctx->m_X = 0;
1183 169 : ctx->m_Y = 0;
1184 :
1185 169 : return rtl_Cipher_E_None;
1186 : }
1187 :
1188 : /*
1189 : * rtl_cipherARCFOUR_update_Impl.
1190 : */
1191 4134 : 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 t;
1198 : sal_Size k;
1199 :
1200 : /* Check arguments. */
1201 4134 : if ((pData == NULL) || (pBuffer == NULL))
1202 0 : return rtl_Cipher_E_Argument;
1203 :
1204 4134 : if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
1205 0 : return rtl_Cipher_E_BufferSize;
1206 :
1207 : /* Update. */
1208 4134 : S = &(ctx->m_S[0]);
1209 33045170 : for (k = 0; k < nDatLen; k++)
1210 : {
1211 : /* Update counters X and Y. */
1212 33041036 : unsigned int x = ctx->m_X;
1213 33041036 : unsigned int y = ctx->m_Y;
1214 33041036 : x = (x + 1 ) % CIPHER_CBLOCK_ARCFOUR;
1215 33041036 : y = (y + S[x]) % CIPHER_CBLOCK_ARCFOUR;
1216 33041036 : ctx->m_X = x;
1217 33041036 : ctx->m_Y = y;
1218 :
1219 : /* Swap S[x] and S[y]. */
1220 33041036 : t = S[x], S[x] = S[y], S[y] = t;
1221 :
1222 : /* Evaluate next key byte S[t]. */
1223 33041036 : t = (S[x] + S[y]) % CIPHER_CBLOCK_ARCFOUR;
1224 33041036 : pBuffer[k] = pData[k] ^ ((sal_uInt8)(S[t] & 0xff));
1225 : }
1226 :
1227 4134 : 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 201 : rtlCipher SAL_CALL rtl_cipher_createARCFOUR (rtlCipherMode Mode)
1242 : SAL_THROW_EXTERN_C()
1243 : {
1244 201 : CipherARCFOUR_Impl *pImpl = nullptr;
1245 :
1246 201 : if (!(Mode == rtl_Cipher_ModeStream))
1247 0 : return (nullptr);
1248 :
1249 201 : pImpl = static_cast<CipherARCFOUR_Impl*>(rtl_allocateZeroMemory (sizeof (CipherARCFOUR_Impl)));
1250 201 : if (pImpl)
1251 : {
1252 201 : pImpl->m_cipher.m_algorithm = rtl_Cipher_AlgorithmARCFOUR;
1253 201 : pImpl->m_cipher.m_direction = rtl_Cipher_DirectionInvalid;
1254 201 : pImpl->m_cipher.m_mode = rtl_Cipher_ModeStream;
1255 :
1256 201 : pImpl->m_cipher.m_init = rtl_cipher_initARCFOUR;
1257 201 : pImpl->m_cipher.m_encode = rtl_cipher_encodeARCFOUR;
1258 201 : pImpl->m_cipher.m_decode = rtl_cipher_decodeARCFOUR;
1259 201 : pImpl->m_cipher.m_delete = rtl_cipher_destroyARCFOUR;
1260 : }
1261 201 : return (static_cast<rtlCipher>(pImpl));
1262 : }
1263 :
1264 : /*
1265 : * rtl_cipher_initARCFOUR.
1266 : */
1267 169 : 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 169 : CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
1275 :
1276 169 : if ((pImpl == NULL) || (pKeyData == NULL))
1277 0 : return rtl_Cipher_E_Argument;
1278 :
1279 169 : if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
1280 0 : return rtl_Cipher_E_Algorithm;
1281 :
1282 169 : if (!(Direction == rtl_Cipher_DirectionInvalid))
1283 169 : pImpl->m_cipher.m_direction = Direction;
1284 : else
1285 0 : return rtl_Cipher_E_Direction;
1286 :
1287 169 : return rtl_cipherARCFOUR_init_Impl (&(pImpl->m_context), pKeyData, nKeyLen);
1288 : }
1289 :
1290 : /*
1291 : * rtl_cipher_encodeARCFOUR.
1292 : */
1293 0 : 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 0 : CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
1299 0 : if (pImpl == NULL)
1300 0 : return rtl_Cipher_E_Argument;
1301 :
1302 0 : if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
1303 0 : return rtl_Cipher_E_Algorithm;
1304 :
1305 0 : if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1306 0 : return rtl_Cipher_E_Direction;
1307 :
1308 : return rtl_cipherARCFOUR_update_Impl (
1309 : &(pImpl->m_context),
1310 0 : static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
1311 : }
1312 :
1313 : /*
1314 : * rtl_cipher_decodeARCFOUR.
1315 : */
1316 4134 : 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 4134 : CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
1322 4134 : if (pImpl == NULL)
1323 0 : return rtl_Cipher_E_Argument;
1324 :
1325 4134 : if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
1326 0 : return rtl_Cipher_E_Algorithm;
1327 :
1328 4134 : if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
1329 0 : return rtl_Cipher_E_Direction;
1330 :
1331 : return rtl_cipherARCFOUR_update_Impl (
1332 : &(pImpl->m_context),
1333 4134 : static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
1334 : }
1335 :
1336 : /*
1337 : * rtl_cipher_destroyARCFOUR.
1338 : */
1339 201 : void SAL_CALL rtl_cipher_destroyARCFOUR (rtlCipher Cipher) SAL_THROW_EXTERN_C()
1340 : {
1341 201 : CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
1342 201 : if (pImpl)
1343 : {
1344 201 : if (pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR)
1345 201 : rtl_freeZeroMemory (pImpl, sizeof (CipherARCFOUR_Impl));
1346 : else
1347 0 : rtl_freeMemory (pImpl);
1348 : }
1349 201 : }
1350 :
1351 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
