Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include <string.h>
30 : :
31 : : #include <sal/types.h>
32 : : #include <sal/macros.h>
33 : : #include <osl/endian.h>
34 : : #include <rtl/alloc.h>
35 : : #include <rtl/memory.h>
36 : : #include <rtl/digest.h>
37 : :
38 : : /*========================================================================
39 : : *
40 : : * rtlDigest internals.
41 : : *
42 : : *======================================================================*/
43 : : #define RTL_DIGEST_CREATE(T) ((T*)(rtl_allocateZeroMemory(sizeof(T))))
44 : :
45 : : #define RTL_DIGEST_ROTL(a,n) (((a) << (n)) | ((a) >> (32 - (n))))
46 : :
47 : : #define RTL_DIGEST_HTONL(l,c) \
48 : : (*((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff), \
49 : : *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
50 : : *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
51 : : *((c)++) = (sal_uInt8)(((l) ) & 0xff))
52 : :
53 : : #define RTL_DIGEST_LTOC(l,c) \
54 : : (*((c)++) = (sal_uInt8)(((l) ) & 0xff), \
55 : : *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
56 : : *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
57 : : *((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff))
58 : :
59 : : typedef rtlDigestError (SAL_CALL Digest_init_t) (
60 : : void *ctx, const sal_uInt8 *Data, sal_uInt32 DatLen);
61 : :
62 : : typedef void (SAL_CALL Digest_delete_t) (void *ctx);
63 : :
64 : : typedef rtlDigestError (SAL_CALL Digest_update_t) (
65 : : void *ctx, const void *Data, sal_uInt32 DatLen);
66 : :
67 : : typedef rtlDigestError (SAL_CALL Digest_get_t) (
68 : : void *ctx, sal_uInt8 *Buffer, sal_uInt32 BufLen);
69 : :
70 : : struct Digest_Impl
71 : : {
72 : : rtlDigestAlgorithm m_algorithm;
73 : : sal_uInt32 m_length;
74 : :
75 : : Digest_init_t *m_init;
76 : : Digest_delete_t *m_delete;
77 : : Digest_update_t *m_update;
78 : : Digest_get_t *m_get;
79 : : };
80 : :
81 : : /*
82 : : * __rtl_digest_swapLong.
83 : : */
84 : 492081 : static void __rtl_digest_swapLong (sal_uInt32 *pData, sal_uInt32 nDatLen)
85 : : {
86 : : sal_uInt32 *X;
87 : : int i, n;
88 : :
89 : 492081 : X = pData;
90 : 492081 : n = nDatLen;
91 : :
92 [ + + ]: 5907210 : for (i = 0; i < n; i++)
93 : 5415129 : X[i] = OSL_SWAPDWORD(X[i]);
94 : 492081 : }
95 : :
96 : : /*========================================================================
97 : : *
98 : : * rtlDigest implementation.
99 : : *
100 : : *======================================================================*/
101 : : /*
102 : : * rtl_digest_create.
103 : : */
104 : 1388 : rtlDigest SAL_CALL rtl_digest_create (rtlDigestAlgorithm Algorithm)
105 : : SAL_THROW_EXTERN_C()
106 : : {
107 : 1388 : rtlDigest Digest = (rtlDigest)NULL;
108 [ - + - + : 1388 : switch (Algorithm)
- - - ]
109 : : {
110 : : case rtl_Digest_AlgorithmMD2:
111 : 0 : Digest = rtl_digest_createMD2();
112 : 0 : break;
113 : :
114 : : case rtl_Digest_AlgorithmMD5:
115 : 1332 : Digest = rtl_digest_createMD5();
116 : 1332 : break;
117 : :
118 : : case rtl_Digest_AlgorithmSHA:
119 : 0 : Digest = rtl_digest_createSHA();
120 : 0 : break;
121 : :
122 : : case rtl_Digest_AlgorithmSHA1:
123 : 56 : Digest = rtl_digest_createSHA1();
124 : 56 : break;
125 : :
126 : : case rtl_Digest_AlgorithmHMAC_MD5:
127 : 0 : Digest = rtl_digest_createHMAC_MD5();
128 : 0 : break;
129 : :
130 : : case rtl_Digest_AlgorithmHMAC_SHA1:
131 : 0 : Digest = rtl_digest_createHMAC_SHA1();
132 : 0 : break;
133 : :
134 : : default: /* rtl_Digest_AlgorithmInvalid */
135 : 0 : break;
136 : : }
137 : 1388 : return Digest;
138 : : }
139 : :
140 : : /*
141 : : * rtl_digest_queryAlgorithm.
142 : : */
143 : 0 : rtlDigestAlgorithm SAL_CALL rtl_digest_queryAlgorithm (rtlDigest Digest)
144 : : SAL_THROW_EXTERN_C()
145 : : {
146 : 0 : Digest_Impl *pImpl = (Digest_Impl *)Digest;
147 [ # # ]: 0 : if (pImpl)
148 : 0 : return pImpl->m_algorithm;
149 : : else
150 : 0 : return rtl_Digest_AlgorithmInvalid;
151 : : }
152 : :
153 : : /*
154 : : * rtl_digest_queryLength.
155 : : */
156 : 257 : sal_uInt32 SAL_CALL rtl_digest_queryLength (rtlDigest Digest)
157 : : SAL_THROW_EXTERN_C()
158 : : {
159 : 257 : Digest_Impl *pImpl = (Digest_Impl *)Digest;
160 [ + - ]: 257 : if (pImpl)
161 : 257 : return pImpl->m_length;
162 : : else
163 : 257 : return 0;
164 : : }
165 : :
166 : : /*
167 : : * rtl_digest_init.
168 : : */
169 : 257 : rtlDigestError SAL_CALL rtl_digest_init (
170 : : rtlDigest Digest, const sal_uInt8 *pData, sal_uInt32 nDatLen)
171 : : SAL_THROW_EXTERN_C()
172 : : {
173 : 257 : Digest_Impl *pImpl = (Digest_Impl *)Digest;
174 [ + - ]: 257 : if (pImpl)
175 : : {
176 [ - + ]: 257 : if (pImpl->m_init)
177 : 0 : return pImpl->m_init (Digest, pData, nDatLen);
178 : : else
179 : 257 : return rtl_Digest_E_None;
180 : : }
181 : 257 : return rtl_Digest_E_Argument;
182 : : }
183 : :
184 : : /*
185 : : * rtl_digest_update.
186 : : */
187 : 452009 : rtlDigestError SAL_CALL rtl_digest_update (
188 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
189 : : SAL_THROW_EXTERN_C()
190 : : {
191 : 452009 : Digest_Impl *pImpl = (Digest_Impl *)Digest;
192 [ + - ][ + - ]: 452009 : if (pImpl && pImpl->m_update)
193 : 452009 : return pImpl->m_update (Digest, pData, nDatLen);
194 : : else
195 : 452009 : return rtl_Digest_E_Argument;
196 : : }
197 : :
198 : : /*
199 : : * rtl_digest_get.
200 : : */
201 : 156788 : rtlDigestError SAL_CALL rtl_digest_get (
202 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
203 : : SAL_THROW_EXTERN_C()
204 : : {
205 : 156788 : Digest_Impl *pImpl = (Digest_Impl *)Digest;
206 [ + - ][ + - ]: 156788 : if (pImpl && pImpl->m_get)
207 : 156788 : return pImpl->m_get (Digest, pBuffer, nBufLen);
208 : : else
209 : 156788 : return rtl_Digest_E_Argument;
210 : : }
211 : :
212 : : /*
213 : : * rtl_digest_destroy.
214 : : */
215 : 912 : void SAL_CALL rtl_digest_destroy (rtlDigest Digest) SAL_THROW_EXTERN_C()
216 : : {
217 : 912 : Digest_Impl *pImpl = (Digest_Impl *)Digest;
218 [ + - ][ + - ]: 912 : if (pImpl && pImpl->m_delete)
219 : 912 : pImpl->m_delete (Digest);
220 : 912 : }
221 : :
222 : : /*========================================================================
223 : : *
224 : : * rtl_digest_MD2 internals.
225 : : *
226 : : *======================================================================*/
227 : : #define DIGEST_CBLOCK_MD2 16
228 : : #define DIGEST_LBLOCK_MD2 16
229 : :
230 : : struct DigestContextMD2
231 : : {
232 : : sal_uInt32 m_nDatLen;
233 : : sal_uInt8 m_pData[DIGEST_CBLOCK_MD2];
234 : : sal_uInt32 m_state[DIGEST_LBLOCK_MD2];
235 : : sal_uInt32 m_chksum[DIGEST_LBLOCK_MD2];
236 : : };
237 : :
238 : : struct DigestMD2_Impl
239 : : {
240 : : Digest_Impl m_digest;
241 : : DigestContextMD2 m_context;
242 : : };
243 : :
244 : : static void __rtl_digest_initMD2 (DigestContextMD2 *ctx);
245 : : static void __rtl_digest_updateMD2 (DigestContextMD2 *ctx);
246 : : static void __rtl_digest_endMD2 (DigestContextMD2 *ctx);
247 : :
248 : : static const sal_uInt32 S[256] =
249 : : {
250 : : 0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01,
251 : : 0x3D, 0x36, 0x54, 0xA1, 0xEC, 0xF0, 0x06, 0x13,
252 : : 0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C,
253 : : 0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA,
254 : : 0x1E, 0x9B, 0x57, 0x3C, 0xFD, 0xD4, 0xE0, 0x16,
255 : : 0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12,
256 : : 0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49,
257 : : 0xA0, 0xFB, 0xF5, 0x8E, 0xBB, 0x2F, 0xEE, 0x7A,
258 : : 0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F,
259 : : 0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21,
260 : : 0x80, 0x7F, 0x5D, 0x9A, 0x5A, 0x90, 0x32, 0x27,
261 : : 0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03,
262 : : 0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1,
263 : : 0xD7, 0x5E, 0x92, 0x2A, 0xAC, 0x56, 0xAA, 0xC6,
264 : : 0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,
265 : : 0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1,
266 : : 0x45, 0x9D, 0x70, 0x59, 0x64, 0x71, 0x87, 0x20,
267 : : 0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02,
268 : : 0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6,
269 : : 0x1C, 0x46, 0x61, 0x69, 0x34, 0x40, 0x7E, 0x0F,
270 : : 0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A,
271 : : 0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26,
272 : : 0x2C, 0x53, 0x0D, 0x6E, 0x85, 0x28, 0x84, 0x09,
273 : : 0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52,
274 : : 0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA,
275 : : 0x24, 0xE1, 0x7B, 0x08, 0x0C, 0xBD, 0xB1, 0x4A,
276 : : 0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D,
277 : : 0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39,
278 : : 0xF2, 0xEF, 0xB7, 0x0E, 0x66, 0x58, 0xD0, 0xE4,
279 : : 0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,
280 : : 0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A,
281 : : 0xDB, 0x99, 0x8D, 0x33, 0x9F, 0x11, 0x83, 0x14,
282 : : };
283 : :
284 : : /*
285 : : * __rtl_digest_MD2.
286 : : */
287 : : static const Digest_Impl __rtl_digest_MD2 =
288 : : {
289 : : rtl_Digest_AlgorithmMD2,
290 : : RTL_DIGEST_LENGTH_MD2,
291 : :
292 : : NULL,
293 : : rtl_digest_destroyMD2,
294 : : rtl_digest_updateMD2,
295 : : rtl_digest_getMD2
296 : : };
297 : :
298 : : /*
299 : : * __rtl_digest_initMD2.
300 : : */
301 : 0 : static void __rtl_digest_initMD2 (DigestContextMD2 *ctx)
302 : : {
303 : 0 : memset (ctx, 0, sizeof (DigestContextMD2));
304 : 0 : }
305 : :
306 : : /*
307 : : * __rtl_digest_updateMD2.
308 : : */
309 : 0 : static void __rtl_digest_updateMD2 (DigestContextMD2 *ctx)
310 : : {
311 : : sal_uInt8 *X;
312 : : sal_uInt32 *sp1, *sp2;
313 : : sal_uInt32 i, k, t;
314 : :
315 : : sal_uInt32 state[48];
316 : :
317 : 0 : X = ctx->m_pData;
318 : 0 : sp1 = ctx->m_state;
319 : 0 : sp2 = ctx->m_chksum;
320 : :
321 : 0 : k = sp2[DIGEST_LBLOCK_MD2 - 1];
322 [ # # ]: 0 : for (i = 0; i < 16; i++)
323 : : {
324 : 0 : state[i + 0] = sp1[i];
325 : 0 : state[i + 16] = t = X[i];
326 : 0 : state[i + 32] = t ^ sp1[i];
327 : 0 : k = sp2[i] ^= S[t^k];
328 : : }
329 : :
330 : 0 : t = 0;
331 [ # # ]: 0 : for (i = 0; i < 18; i++)
332 : : {
333 [ # # ]: 0 : for (k = 0; k < 48; k += 8)
334 : : {
335 : 0 : t = state[k + 0] ^= S[t];
336 : 0 : t = state[k + 1] ^= S[t];
337 : 0 : t = state[k + 2] ^= S[t];
338 : 0 : t = state[k + 3] ^= S[t];
339 : 0 : t = state[k + 4] ^= S[t];
340 : 0 : t = state[k + 5] ^= S[t];
341 : 0 : t = state[k + 6] ^= S[t];
342 : 0 : t = state[k + 7] ^= S[t];
343 : : }
344 : 0 : t = ((t + i) & 0xff);
345 : : }
346 : :
347 : 0 : memcpy (sp1, state, 16 * sizeof(sal_uInt32));
348 : 0 : memset (state, 0, 48 * sizeof(sal_uInt32));
349 : 0 : }
350 : :
351 : : /*
352 : : * __rtl_digest_endMD2.
353 : : */
354 : 0 : static void __rtl_digest_endMD2 (DigestContextMD2 *ctx)
355 : : {
356 : : sal_uInt8 *X;
357 : : sal_uInt32 *C;
358 : : sal_uInt32 i, n;
359 : :
360 : 0 : X = ctx->m_pData;
361 : 0 : C = ctx->m_chksum;
362 : 0 : n = DIGEST_CBLOCK_MD2 - ctx->m_nDatLen;
363 : :
364 [ # # ]: 0 : for (i = ctx->m_nDatLen; i < DIGEST_CBLOCK_MD2; i++)
365 : 0 : X[i] = (sal_uInt8)(n & 0xff);
366 : 0 : __rtl_digest_updateMD2 (ctx);
367 : :
368 [ # # ]: 0 : for (i = 0; i < DIGEST_CBLOCK_MD2; i++)
369 : 0 : X[i] = (sal_uInt8)(C[i] & 0xff);
370 : 0 : __rtl_digest_updateMD2 (ctx);
371 : 0 : }
372 : :
373 : : /*========================================================================
374 : : *
375 : : * rtl_digest_MD2 implementation.
376 : : *
377 : : *======================================================================*/
378 : : /*
379 : : * rtl_digest_MD2.
380 : : */
381 : 0 : rtlDigestError SAL_CALL rtl_digest_MD2 (
382 : : const void *pData, sal_uInt32 nDatLen,
383 : : sal_uInt8 *pBuffer, sal_uInt32 nBufLen) SAL_THROW_EXTERN_C()
384 : : {
385 : : DigestMD2_Impl digest;
386 : : rtlDigestError result;
387 : :
388 : 0 : digest.m_digest = __rtl_digest_MD2;
389 : 0 : __rtl_digest_initMD2 (&(digest.m_context));
390 : :
391 : 0 : result = rtl_digest_updateMD2 (&digest, pData, nDatLen);
392 [ # # ]: 0 : if (result == rtl_Digest_E_None)
393 : 0 : result = rtl_digest_getMD2 (&digest, pBuffer, nBufLen);
394 : :
395 : 0 : memset (&digest, 0, sizeof (digest));
396 : 0 : return (result);
397 : : }
398 : :
399 : : /*
400 : : * rtl_digest_createMD2.
401 : : */
402 : 0 : rtlDigest SAL_CALL rtl_digest_createMD2() SAL_THROW_EXTERN_C()
403 : : {
404 : 0 : DigestMD2_Impl *pImpl = (DigestMD2_Impl*)NULL;
405 : 0 : pImpl = RTL_DIGEST_CREATE(DigestMD2_Impl);
406 [ # # ]: 0 : if (pImpl)
407 : : {
408 : 0 : pImpl->m_digest = __rtl_digest_MD2;
409 : 0 : __rtl_digest_initMD2 (&(pImpl->m_context));
410 : : }
411 : 0 : return ((rtlDigest)pImpl);
412 : : }
413 : :
414 : : /*
415 : : * rtl_digest_updateMD2.
416 : : */
417 : 0 : rtlDigestError SAL_CALL rtl_digest_updateMD2 (
418 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
419 : : SAL_THROW_EXTERN_C()
420 : : {
421 : 0 : DigestMD2_Impl *pImpl = (DigestMD2_Impl *)Digest;
422 : 0 : const sal_uInt8 *d = (const sal_uInt8 *)pData;
423 : :
424 : : DigestContextMD2 *ctx;
425 : :
426 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pData == NULL))
427 : 0 : return rtl_Digest_E_Argument;
428 : :
429 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD2))
430 : 0 : return rtl_Digest_E_Algorithm;
431 : :
432 [ # # ]: 0 : if (nDatLen == 0)
433 : 0 : return rtl_Digest_E_None;
434 : :
435 : 0 : ctx = &(pImpl->m_context);
436 : :
437 [ # # ]: 0 : if (ctx->m_nDatLen)
438 : : {
439 : 0 : sal_uInt8 *p = ctx->m_pData + ctx->m_nDatLen;
440 : 0 : sal_uInt32 n = DIGEST_CBLOCK_MD2 - ctx->m_nDatLen;
441 : :
442 [ # # ]: 0 : if (nDatLen < n)
443 : : {
444 : 0 : memcpy (p, d, nDatLen);
445 : 0 : ctx->m_nDatLen += nDatLen;
446 : :
447 : 0 : return rtl_Digest_E_None;
448 : : }
449 : :
450 : 0 : memcpy (p, d, n);
451 : 0 : d += n;
452 : 0 : nDatLen -= n;
453 : :
454 : 0 : __rtl_digest_updateMD2 (ctx);
455 : 0 : ctx->m_nDatLen = 0;
456 : : }
457 : :
458 [ # # ]: 0 : while (nDatLen >= DIGEST_CBLOCK_MD2)
459 : : {
460 : 0 : memcpy (ctx->m_pData, d, DIGEST_CBLOCK_MD2);
461 : 0 : d += DIGEST_CBLOCK_MD2;
462 : 0 : nDatLen -= DIGEST_CBLOCK_MD2;
463 : :
464 : 0 : __rtl_digest_updateMD2 (ctx);
465 : : }
466 : :
467 : 0 : memcpy (ctx->m_pData, d, nDatLen);
468 : 0 : ctx->m_nDatLen = nDatLen;
469 : :
470 : 0 : return rtl_Digest_E_None;
471 : : }
472 : :
473 : : /*
474 : : * rtl_digest_getMD2.
475 : : */
476 : 0 : rtlDigestError SAL_CALL rtl_digest_getMD2 (
477 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
478 : : SAL_THROW_EXTERN_C()
479 : : {
480 : 0 : DigestMD2_Impl *pImpl = (DigestMD2_Impl *)Digest;
481 : : sal_uInt32 i;
482 : :
483 : : DigestContextMD2 *ctx;
484 : :
485 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pBuffer == NULL))
486 : 0 : return rtl_Digest_E_Argument;
487 : :
488 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD2))
489 : 0 : return rtl_Digest_E_Algorithm;
490 : :
491 [ # # ]: 0 : if (!(pImpl->m_digest.m_length <= nBufLen))
492 : 0 : return rtl_Digest_E_BufferSize;
493 : :
494 : 0 : ctx = &(pImpl->m_context);
495 : :
496 : 0 : __rtl_digest_endMD2 (ctx);
497 [ # # ]: 0 : for (i = 0; i < DIGEST_CBLOCK_MD2; i++)
498 : 0 : pBuffer[i] = (sal_uInt8)(ctx->m_state[i] & 0xff);
499 : 0 : __rtl_digest_initMD2 (ctx);
500 : :
501 : 0 : return rtl_Digest_E_None;
502 : : }
503 : :
504 : : /*
505 : : * rtl_digest_destroyMD2.
506 : : */
507 : 0 : void SAL_CALL rtl_digest_destroyMD2 (rtlDigest Digest) SAL_THROW_EXTERN_C()
508 : : {
509 : 0 : DigestMD2_Impl *pImpl = (DigestMD2_Impl *)Digest;
510 [ # # ]: 0 : if (pImpl)
511 : : {
512 [ # # ]: 0 : if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD2)
513 : 0 : rtl_freeZeroMemory (pImpl, sizeof (DigestMD2_Impl));
514 : : else
515 : 0 : rtl_freeMemory (pImpl);
516 : : }
517 : 0 : }
518 : :
519 : : /*========================================================================
520 : : *
521 : : * rtl_digest_MD5 internals.
522 : : *
523 : : *======================================================================*/
524 : : #define DIGEST_CBLOCK_MD5 64
525 : : #define DIGEST_LBLOCK_MD5 16
526 : :
527 : : struct DigestContextMD5
528 : : {
529 : : sal_uInt32 m_nDatLen;
530 : : sal_uInt32 m_pData[DIGEST_LBLOCK_MD5];
531 : : sal_uInt32 m_nA, m_nB, m_nC, m_nD;
532 : : sal_uInt32 m_nL, m_nH;
533 : : };
534 : :
535 : : struct DigestMD5_Impl
536 : : {
537 : : Digest_Impl m_digest;
538 : : DigestContextMD5 m_context;
539 : : };
540 : :
541 : : static void __rtl_digest_initMD5 (DigestContextMD5 *ctx);
542 : : static void __rtl_digest_updateMD5 (DigestContextMD5 *ctx);
543 : : static void __rtl_digest_endMD5 (DigestContextMD5 *ctx);
544 : :
545 : : #define F(x,y,z) ((((y) ^ (z)) & (x)) ^ (z))
546 : : #define G(x,y,z) ((((x) ^ (y)) & (z)) ^ (y))
547 : : #define H(x,y,z) ((x) ^ (y) ^ (z))
548 : : #define I(x,y,z) (((x) | (~(z))) ^ (y))
549 : :
550 : : #define R0(a,b,c,d,k,s,t) { \
551 : : a += ((k) + (t) + F((b), (c), (d))); \
552 : : a = RTL_DIGEST_ROTL(a, s); \
553 : : a += b; }
554 : :
555 : : #define R1(a,b,c,d,k,s,t) { \
556 : : a += ((k) + (t) + G((b), (c), (d))); \
557 : : a = RTL_DIGEST_ROTL(a, s); \
558 : : a += b; }
559 : :
560 : : #define R2(a,b,c,d,k,s,t) { \
561 : : a += ((k) + (t) + H((b), (c), (d))); \
562 : : a = RTL_DIGEST_ROTL(a, s); \
563 : : a += b; }
564 : :
565 : : #define R3(a,b,c,d,k,s,t) { \
566 : : a += ((k) + (t) + I((b), (c), (d))); \
567 : : a = RTL_DIGEST_ROTL(a, s); \
568 : : a += b; }
569 : :
570 : : /*
571 : : * __rtl_digest_MD5.
572 : : */
573 : : static const Digest_Impl __rtl_digest_MD5 =
574 : : {
575 : : rtl_Digest_AlgorithmMD5,
576 : : RTL_DIGEST_LENGTH_MD5,
577 : :
578 : : NULL,
579 : : rtl_digest_destroyMD5,
580 : : rtl_digest_updateMD5,
581 : : rtl_digest_getMD5
582 : : };
583 : :
584 : : /*
585 : : * __rtl_digest_initMD5.
586 : : */
587 : 158064 : static void __rtl_digest_initMD5 (DigestContextMD5 *ctx)
588 : : {
589 : 158064 : memset (ctx, 0, sizeof (DigestContextMD5));
590 : :
591 : 158064 : ctx->m_nA = (sal_uInt32)0x67452301L;
592 : 158064 : ctx->m_nB = (sal_uInt32)0xefcdab89L;
593 : 158064 : ctx->m_nC = (sal_uInt32)0x98badcfeL;
594 : 158064 : ctx->m_nD = (sal_uInt32)0x10325476L;
595 : 158064 : }
596 : :
597 : : /*
598 : : * __rtl_digest_updateMD5.
599 : : */
600 : 157252 : static void __rtl_digest_updateMD5 (DigestContextMD5 *ctx)
601 : : {
602 : : sal_uInt32 A, B, C, D;
603 : : sal_uInt32 *X;
604 : :
605 : 157252 : A = ctx->m_nA;
606 : 157252 : B = ctx->m_nB;
607 : 157252 : C = ctx->m_nC;
608 : 157252 : D = ctx->m_nD;
609 : 157252 : X = ctx->m_pData;
610 : :
611 : 157252 : R0 (A, B, C, D, X[ 0], 7, 0xd76aa478L);
612 : 157252 : R0 (D, A, B, C, X[ 1], 12, 0xe8c7b756L);
613 : 157252 : R0 (C, D, A, B, X[ 2], 17, 0x242070dbL);
614 : 157252 : R0 (B, C, D, A, X[ 3], 22, 0xc1bdceeeL);
615 : 157252 : R0 (A, B, C, D, X[ 4], 7, 0xf57c0fafL);
616 : 157252 : R0 (D, A, B, C, X[ 5], 12, 0x4787c62aL);
617 : 157252 : R0 (C, D, A, B, X[ 6], 17, 0xa8304613L);
618 : 157252 : R0 (B, C, D, A, X[ 7], 22, 0xfd469501L);
619 : 157252 : R0 (A, B, C, D, X[ 8], 7, 0x698098d8L);
620 : 157252 : R0 (D, A, B, C, X[ 9], 12, 0x8b44f7afL);
621 : 157252 : R0 (C, D, A, B, X[10], 17, 0xffff5bb1L);
622 : 157252 : R0 (B, C, D, A, X[11], 22, 0x895cd7beL);
623 : 157252 : R0 (A, B, C, D, X[12], 7, 0x6b901122L);
624 : 157252 : R0 (D, A, B, C, X[13], 12, 0xfd987193L);
625 : 157252 : R0 (C, D, A, B, X[14], 17, 0xa679438eL);
626 : 157252 : R0 (B, C, D, A, X[15], 22, 0x49b40821L);
627 : :
628 : 157252 : R1 (A, B, C, D, X[ 1], 5, 0xf61e2562L);
629 : 157252 : R1 (D, A, B, C, X[ 6], 9, 0xc040b340L);
630 : 157252 : R1 (C, D, A, B, X[11], 14, 0x265e5a51L);
631 : 157252 : R1 (B, C, D, A, X[ 0], 20, 0xe9b6c7aaL);
632 : 157252 : R1 (A, B, C, D, X[ 5], 5, 0xd62f105dL);
633 : 157252 : R1 (D, A, B, C, X[10], 9, 0x02441453L);
634 : 157252 : R1 (C, D, A, B, X[15], 14, 0xd8a1e681L);
635 : 157252 : R1 (B, C, D, A, X[ 4], 20, 0xe7d3fbc8L);
636 : 157252 : R1 (A, B, C, D, X[ 9], 5, 0x21e1cde6L);
637 : 157252 : R1 (D, A, B, C, X[14], 9, 0xc33707d6L);
638 : 157252 : R1 (C, D, A, B, X[ 3], 14, 0xf4d50d87L);
639 : 157252 : R1 (B, C, D, A, X[ 8], 20, 0x455a14edL);
640 : 157252 : R1 (A, B, C, D, X[13], 5, 0xa9e3e905L);
641 : 157252 : R1 (D, A, B, C, X[ 2], 9, 0xfcefa3f8L);
642 : 157252 : R1 (C, D, A, B, X[ 7], 14, 0x676f02d9L);
643 : 157252 : R1 (B, C, D, A, X[12], 20, 0x8d2a4c8aL);
644 : :
645 : 157252 : R2 (A, B, C, D, X[ 5], 4, 0xfffa3942L);
646 : 157252 : R2 (D, A, B, C, X[ 8], 11, 0x8771f681L);
647 : 157252 : R2 (C, D, A, B, X[11], 16, 0x6d9d6122L);
648 : 157252 : R2 (B, C, D, A, X[14], 23, 0xfde5380cL);
649 : 157252 : R2 (A, B, C, D, X[ 1], 4, 0xa4beea44L);
650 : 157252 : R2 (D, A, B, C, X[ 4], 11, 0x4bdecfa9L);
651 : 157252 : R2 (C, D, A, B, X[ 7], 16, 0xf6bb4b60L);
652 : 157252 : R2 (B, C, D, A, X[10], 23, 0xbebfbc70L);
653 : 157252 : R2 (A, B, C, D, X[13], 4, 0x289b7ec6L);
654 : 157252 : R2 (D, A, B, C, X[ 0], 11, 0xeaa127faL);
655 : 157252 : R2 (C, D, A, B, X[ 3], 16, 0xd4ef3085L);
656 : 157252 : R2 (B, C, D, A, X[ 6], 23, 0x04881d05L);
657 : 157252 : R2 (A, B, C, D, X[ 9], 4, 0xd9d4d039L);
658 : 157252 : R2 (D, A, B, C, X[12], 11, 0xe6db99e5L);
659 : 157252 : R2 (C, D, A, B, X[15], 16, 0x1fa27cf8L);
660 : 157252 : R2 (B, C, D, A, X[ 2], 23, 0xc4ac5665L);
661 : :
662 : 157252 : R3 (A, B, C, D, X[ 0], 6, 0xf4292244L);
663 : 157252 : R3 (D, A, B, C, X[ 7], 10, 0x432aff97L);
664 : 157252 : R3 (C, D, A, B, X[14], 15, 0xab9423a7L);
665 : 157252 : R3 (B, C, D, A, X[ 5], 21, 0xfc93a039L);
666 : 157252 : R3 (A, B, C, D, X[12], 6, 0x655b59c3L);
667 : 157252 : R3 (D, A, B, C, X[ 3], 10, 0x8f0ccc92L);
668 : 157252 : R3 (C, D, A, B, X[10], 15, 0xffeff47dL);
669 : 157252 : R3 (B, C, D, A, X[ 1], 21, 0x85845dd1L);
670 : 157252 : R3 (A, B, C, D, X[ 8], 6, 0x6fa87e4fL);
671 : 157252 : R3 (D, A, B, C, X[15], 10, 0xfe2ce6e0L);
672 : 157252 : R3 (C, D, A, B, X[ 6], 15, 0xa3014314L);
673 : 157252 : R3 (B, C, D, A, X[13], 21, 0x4e0811a1L);
674 : 157252 : R3 (A, B, C, D, X[ 4], 6, 0xf7537e82L);
675 : 157252 : R3 (D, A, B, C, X[11], 10, 0xbd3af235L);
676 : 157252 : R3 (C, D, A, B, X[ 2], 15, 0x2ad7d2bbL);
677 : 157252 : R3 (B, C, D, A, X[ 9], 21, 0xeb86d391L);
678 : :
679 : 157252 : ctx->m_nA += A;
680 : 157252 : ctx->m_nB += B;
681 : 157252 : ctx->m_nC += C;
682 : 157252 : ctx->m_nD += D;
683 : 157252 : }
684 : :
685 : : /*
686 : : * __rtl_digest_endMD5.
687 : : */
688 : 156732 : static void __rtl_digest_endMD5 (DigestContextMD5 *ctx)
689 : : {
690 : : static const sal_uInt8 end[4] =
691 : : {
692 : : 0x80, 0x00, 0x00, 0x00
693 : : };
694 : 156732 : const sal_uInt8 *p = end;
695 : :
696 : : sal_uInt32 *X;
697 : : int i;
698 : :
699 : 156732 : X = ctx->m_pData;
700 : 156732 : i = (ctx->m_nDatLen >> 2);
701 : :
702 : : #ifdef OSL_BIGENDIAN
703 : : __rtl_digest_swapLong (X, i + 1);
704 : : #endif /* OSL_BIGENDIAN */
705 : :
706 [ - + - + ]: 156732 : switch (ctx->m_nDatLen & 0x03)
707 : : {
708 : 0 : case 1: X[i] &= 0x000000ff; break;
709 : 91 : case 2: X[i] &= 0x0000ffff; break;
710 : 0 : case 3: X[i] &= 0x00ffffff; break;
711 : : }
712 : :
713 [ + - + - : 156732 : switch (ctx->m_nDatLen & 0x03)
- ]
714 : : {
715 : 156641 : case 0: X[i] = ((sal_uInt32)(*(p++))) << 0L;
716 : 156641 : case 1: X[i] |= ((sal_uInt32)(*(p++))) << 8L;
717 : 156732 : case 2: X[i] |= ((sal_uInt32)(*(p++))) << 16L;
718 : 156732 : case 3: X[i] |= ((sal_uInt32)(*p)) << 24L;
719 : : }
720 : :
721 : 156732 : i += 1;
722 : :
723 [ + + ]: 156732 : if (i >= (DIGEST_LBLOCK_MD5 - 2))
724 : : {
725 [ + + ]: 18 : for (; i < DIGEST_LBLOCK_MD5; i++)
726 : 12 : X[i] = 0;
727 : 6 : __rtl_digest_updateMD5 (ctx);
728 : 6 : i = 0;
729 : : }
730 : :
731 [ + + ]: 1015458 : for (; i < (DIGEST_LBLOCK_MD5 - 2); i++)
732 : 858726 : X[i] = 0;
733 : :
734 : 156732 : X[DIGEST_LBLOCK_MD5 - 2] = ctx->m_nL;
735 : 156732 : X[DIGEST_LBLOCK_MD5 - 1] = ctx->m_nH;
736 : :
737 : 156732 : __rtl_digest_updateMD5 (ctx);
738 : 156732 : }
739 : :
740 : : /*========================================================================
741 : : *
742 : : * rtl_digest_MD5 implementation.
743 : : *
744 : : *======================================================================*/
745 : : /*
746 : : * rtl_digest_MD5.
747 : : */
748 : 0 : rtlDigestError SAL_CALL rtl_digest_MD5 (
749 : : const void *pData, sal_uInt32 nDatLen,
750 : : sal_uInt8 *pBuffer, sal_uInt32 nBufLen) SAL_THROW_EXTERN_C()
751 : : {
752 : : DigestMD5_Impl digest;
753 : : rtlDigestError result;
754 : :
755 : 0 : digest.m_digest = __rtl_digest_MD5;
756 : 0 : __rtl_digest_initMD5 (&(digest.m_context));
757 : :
758 : 0 : result = rtl_digest_update (&digest, pData, nDatLen);
759 [ # # ]: 0 : if (result == rtl_Digest_E_None)
760 : 0 : result = rtl_digest_getMD5 (&digest, pBuffer, nBufLen);
761 : :
762 : 0 : memset (&digest, 0, sizeof (digest));
763 : 0 : return (result);
764 : : }
765 : :
766 : : /*
767 : : * rtl_digest_createMD5.
768 : : */
769 : 1332 : rtlDigest SAL_CALL rtl_digest_createMD5() SAL_THROW_EXTERN_C()
770 : : {
771 : 1332 : DigestMD5_Impl *pImpl = (DigestMD5_Impl*)NULL;
772 : 1332 : pImpl = RTL_DIGEST_CREATE(DigestMD5_Impl);
773 [ + - ]: 1332 : if (pImpl)
774 : : {
775 : 1332 : pImpl->m_digest = __rtl_digest_MD5;
776 : 1332 : __rtl_digest_initMD5 (&(pImpl->m_context));
777 : : }
778 : 1332 : return ((rtlDigest)pImpl);
779 : : }
780 : :
781 : : /*
782 : : * rtl_digest_updateMD5.
783 : : */
784 : 451491 : rtlDigestError SAL_CALL rtl_digest_updateMD5 (
785 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
786 : : SAL_THROW_EXTERN_C()
787 : : {
788 : 451491 : DigestMD5_Impl *pImpl = (DigestMD5_Impl *)Digest;
789 : 451491 : const sal_uInt8 *d = (const sal_uInt8 *)pData;
790 : :
791 : : DigestContextMD5 *ctx;
792 : : sal_uInt32 len;
793 : :
794 [ + - ][ - + ]: 451491 : if ((pImpl == NULL) || (pData == NULL))
795 : 0 : return rtl_Digest_E_Argument;
796 : :
797 [ - + ]: 451491 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD5))
798 : 0 : return rtl_Digest_E_Algorithm;
799 : :
800 [ - + ]: 451491 : if (nDatLen == 0)
801 : 0 : return rtl_Digest_E_None;
802 : :
803 : 451491 : ctx = &(pImpl->m_context);
804 : :
805 : 451491 : len = ctx->m_nL + (nDatLen << 3);
806 [ - + ]: 451491 : if (len < ctx->m_nL) ctx->m_nH += 1;
807 : 451491 : ctx->m_nH += (nDatLen >> 29);
808 : 451491 : ctx->m_nL = len;
809 : :
810 [ + + ]: 451491 : if (ctx->m_nDatLen)
811 : : {
812 : 294759 : sal_uInt8 *p = (sal_uInt8 *)(ctx->m_pData) + ctx->m_nDatLen;
813 : 294759 : sal_uInt32 n = DIGEST_CBLOCK_MD5 - ctx->m_nDatLen;
814 : :
815 [ + - ]: 294759 : if (nDatLen < n)
816 : : {
817 : 294759 : memcpy (p, d, nDatLen);
818 : 294759 : ctx->m_nDatLen += nDatLen;
819 : :
820 : 294759 : return rtl_Digest_E_None;
821 : : }
822 : :
823 : 0 : memcpy (p, d, n);
824 : 0 : d += n;
825 : 0 : nDatLen -= n;
826 : :
827 : : #ifdef OSL_BIGENDIAN
828 : : __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_MD5);
829 : : #endif /* OSL_BIGENDIAN */
830 : :
831 : 0 : __rtl_digest_updateMD5 (ctx);
832 : 0 : ctx->m_nDatLen = 0;
833 : : }
834 : :
835 [ + + ]: 157246 : while (nDatLen >= DIGEST_CBLOCK_MD5)
836 : : {
837 : 514 : memcpy (ctx->m_pData, d, DIGEST_CBLOCK_MD5);
838 : 514 : d += DIGEST_CBLOCK_MD5;
839 : 514 : nDatLen -= DIGEST_CBLOCK_MD5;
840 : :
841 : : #ifdef OSL_BIGENDIAN
842 : : __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_MD5);
843 : : #endif /* OSL_BIGENDIAN */
844 : :
845 : 514 : __rtl_digest_updateMD5 (ctx);
846 : : }
847 : :
848 : 156732 : memcpy (ctx->m_pData, d, nDatLen);
849 : 156732 : ctx->m_nDatLen = nDatLen;
850 : :
851 : 451491 : return rtl_Digest_E_None;
852 : : }
853 : :
854 : : /*
855 : : * rtl_digest_getMD5.
856 : : */
857 : 156732 : rtlDigestError SAL_CALL rtl_digest_getMD5 (
858 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
859 : : SAL_THROW_EXTERN_C()
860 : : {
861 : 156732 : DigestMD5_Impl *pImpl = (DigestMD5_Impl *)Digest;
862 : 156732 : sal_uInt8 *p = pBuffer;
863 : :
864 : : DigestContextMD5 *ctx;
865 : :
866 [ + - ][ - + ]: 156732 : if ((pImpl == NULL) || (pBuffer == NULL))
867 : 0 : return rtl_Digest_E_Argument;
868 : :
869 [ - + ]: 156732 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD5))
870 : 0 : return rtl_Digest_E_Algorithm;
871 : :
872 [ - + ]: 156732 : if (!(pImpl->m_digest.m_length <= nBufLen))
873 : 0 : return rtl_Digest_E_BufferSize;
874 : :
875 : 156732 : ctx = &(pImpl->m_context);
876 : :
877 : 156732 : __rtl_digest_endMD5 (ctx);
878 : 156732 : RTL_DIGEST_LTOC (ctx->m_nA, p);
879 : 156732 : RTL_DIGEST_LTOC (ctx->m_nB, p);
880 : 156732 : RTL_DIGEST_LTOC (ctx->m_nC, p);
881 : 156732 : RTL_DIGEST_LTOC (ctx->m_nD, p);
882 : 156732 : __rtl_digest_initMD5 (ctx);
883 : :
884 : 156732 : return rtl_Digest_E_None;
885 : : }
886 : :
887 : : /*
888 : : * rtl_digest_rawMD5.
889 : : */
890 : 0 : rtlDigestError SAL_CALL rtl_digest_rawMD5 (
891 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
892 : : SAL_THROW_EXTERN_C()
893 : : {
894 : 0 : DigestMD5_Impl *pImpl = (DigestMD5_Impl *)Digest;
895 : 0 : sal_uInt8 *p = pBuffer;
896 : :
897 : : DigestContextMD5 *ctx;
898 : :
899 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pBuffer == NULL))
900 : 0 : return rtl_Digest_E_Argument;
901 : :
902 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD5))
903 : 0 : return rtl_Digest_E_Algorithm;
904 : :
905 [ # # ]: 0 : if (!(pImpl->m_digest.m_length <= nBufLen))
906 : 0 : return rtl_Digest_E_BufferSize;
907 : :
908 : 0 : ctx = &(pImpl->m_context);
909 : :
910 : : /* __rtl_digest_endMD5 (ctx); *//* not finalized */
911 : 0 : RTL_DIGEST_LTOC (ctx->m_nA, p);
912 : 0 : RTL_DIGEST_LTOC (ctx->m_nB, p);
913 : 0 : RTL_DIGEST_LTOC (ctx->m_nC, p);
914 : 0 : RTL_DIGEST_LTOC (ctx->m_nD, p);
915 : 0 : __rtl_digest_initMD5 (ctx);
916 : :
917 : 0 : return rtl_Digest_E_None;
918 : : }
919 : :
920 : : /*
921 : : * rtl_digest_destroyMD5.
922 : : */
923 : 856 : void SAL_CALL rtl_digest_destroyMD5 (rtlDigest Digest) SAL_THROW_EXTERN_C()
924 : : {
925 : 856 : DigestMD5_Impl *pImpl = (DigestMD5_Impl *)Digest;
926 [ + - ]: 856 : if (pImpl)
927 : : {
928 [ + - ]: 856 : if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmMD5)
929 : 856 : rtl_freeZeroMemory (pImpl, sizeof (DigestMD5_Impl));
930 : : else
931 : 0 : rtl_freeMemory (pImpl);
932 : : }
933 : 856 : }
934 : :
935 : : /*========================================================================
936 : : *
937 : : * rtl_digest_(SHA|SHA1) common internals.
938 : : *
939 : : *======================================================================*/
940 : : #define DIGEST_CBLOCK_SHA 64
941 : : #define DIGEST_LBLOCK_SHA 16
942 : :
943 : : typedef sal_uInt32 DigestSHA_update_t (sal_uInt32 x);
944 : :
945 : : static sal_uInt32 __rtl_digest_updateSHA_0 (sal_uInt32 x);
946 : : static sal_uInt32 __rtl_digest_updateSHA_1 (sal_uInt32 x);
947 : :
948 : : struct DigestContextSHA
949 : : {
950 : : DigestSHA_update_t *m_update;
951 : : sal_uInt32 m_nDatLen;
952 : : sal_uInt32 m_pData[DIGEST_LBLOCK_SHA];
953 : : sal_uInt32 m_nA, m_nB, m_nC, m_nD, m_nE;
954 : : sal_uInt32 m_nL, m_nH;
955 : : };
956 : :
957 : : struct DigestSHA_Impl
958 : : {
959 : : Digest_Impl m_digest;
960 : : DigestContextSHA m_context;
961 : : };
962 : :
963 : : static void __rtl_digest_initSHA (
964 : : DigestContextSHA *ctx, DigestSHA_update_t *fct);
965 : :
966 : : static void __rtl_digest_updateSHA (DigestContextSHA *ctx);
967 : : static void __rtl_digest_endSHA (DigestContextSHA *ctx);
968 : :
969 : : #define K_00_19 (sal_uInt32)0x5a827999L
970 : : #define K_20_39 (sal_uInt32)0x6ed9eba1L
971 : : #define K_40_59 (sal_uInt32)0x8f1bbcdcL
972 : : #define K_60_79 (sal_uInt32)0xca62c1d6L
973 : :
974 : : #define F_00_19(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
975 : : #define F_20_39(b,c,d) ((b) ^ (c) ^ (d))
976 : : #define F_40_59(b,c,d) (((b) & (c)) | ((b) & (d)) | ((c) & (d)))
977 : : #define F_60_79(b,c,d) F_20_39(b,c,d)
978 : :
979 : : #define BODY_X(i) \
980 : : (X[(i)&0x0f] ^ X[((i)+2)&0x0f] ^ X[((i)+8)&0x0f] ^ X[((i)+13)&0x0f])
981 : :
982 : : #define BODY_00_15(u,i,a,b,c,d,e,f) \
983 : : (f) = X[i]; \
984 : : (f) += (e) + K_00_19 + RTL_DIGEST_ROTL((a), 5) + F_00_19((b), (c), (d)); \
985 : : (b) = RTL_DIGEST_ROTL((b), 30);
986 : :
987 : : #define BODY_16_19(u,i,a,b,c,d,e,f) \
988 : : (f) = BODY_X((i)); \
989 : : (f) = X[(i)&0x0f] = (u)((f)); \
990 : : (f) += (e) + K_00_19 + RTL_DIGEST_ROTL((a), 5) + F_00_19((b), (c), (d)); \
991 : : (b) = RTL_DIGEST_ROTL((b), 30);
992 : :
993 : : #define BODY_20_39(u,i,a,b,c,d,e,f) \
994 : : (f) = BODY_X((i)); \
995 : : (f) = X[(i)&0x0f] = (u)((f)); \
996 : : (f) += (e) + K_20_39 + RTL_DIGEST_ROTL((a), 5) + F_20_39((b), (c), (d)); \
997 : : (b) = RTL_DIGEST_ROTL((b), 30);
998 : :
999 : : #define BODY_40_59(u,i,a,b,c,d,e,f) \
1000 : : (f) = BODY_X((i)); \
1001 : : (f) = X[(i)&0x0f] = (u)((f)); \
1002 : : (f) += (e) + K_40_59 + RTL_DIGEST_ROTL((a), 5) + F_40_59((b), (c), (d)); \
1003 : : (b) = RTL_DIGEST_ROTL((b), 30);
1004 : :
1005 : : #define BODY_60_79(u,i,a,b,c,d,e,f) \
1006 : : (f) = BODY_X((i)); \
1007 : : (f) = X[(i)&0x0f] = (u)((f)); \
1008 : : (f) += (e) + K_60_79 + RTL_DIGEST_ROTL((a), 5) + F_60_79((b), (c), (d)); \
1009 : : (b) = RTL_DIGEST_ROTL((b), 30);
1010 : :
1011 : : /*
1012 : : * __rtl_digest_initSHA.
1013 : : */
1014 : 246032 : static void __rtl_digest_initSHA (
1015 : : DigestContextSHA *ctx, DigestSHA_update_t *fct)
1016 : : {
1017 : 246032 : memset (ctx, 0, sizeof (DigestContextSHA));
1018 : 246032 : ctx->m_update = fct;
1019 : :
1020 : 246032 : ctx->m_nA = (sal_uInt32)0x67452301L;
1021 : 246032 : ctx->m_nB = (sal_uInt32)0xefcdab89L;
1022 : 246032 : ctx->m_nC = (sal_uInt32)0x98badcfeL;
1023 : 246032 : ctx->m_nD = (sal_uInt32)0x10325476L;
1024 : 246032 : ctx->m_nE = (sal_uInt32)0xc3d2e1f0L;
1025 : 246032 : }
1026 : :
1027 : : /*
1028 : : * __rtl_digest_updateSHA.
1029 : : */
1030 : 492106 : static void __rtl_digest_updateSHA (DigestContextSHA *ctx)
1031 : : {
1032 : : sal_uInt32 A, B, C, D, E, T;
1033 : : sal_uInt32 *X;
1034 : :
1035 : : DigestSHA_update_t *U;
1036 : 492106 : U = ctx->m_update;
1037 : :
1038 : 492106 : A = ctx->m_nA;
1039 : 492106 : B = ctx->m_nB;
1040 : 492106 : C = ctx->m_nC;
1041 : 492106 : D = ctx->m_nD;
1042 : 492106 : E = ctx->m_nE;
1043 : 492106 : X = ctx->m_pData;
1044 : :
1045 : 492106 : BODY_00_15 (U, 0, A, B, C, D, E, T);
1046 : 492106 : BODY_00_15 (U, 1, T, A, B, C, D, E);
1047 : 492106 : BODY_00_15 (U, 2, E, T, A, B, C, D);
1048 : 492106 : BODY_00_15 (U, 3, D, E, T, A, B, C);
1049 : 492106 : BODY_00_15 (U, 4, C, D, E, T, A, B);
1050 : 492106 : BODY_00_15 (U, 5, B, C, D, E, T, A);
1051 : 492106 : BODY_00_15 (U, 6, A, B, C, D, E, T);
1052 : 492106 : BODY_00_15 (U, 7, T, A, B, C, D, E);
1053 : 492106 : BODY_00_15 (U, 8, E, T, A, B, C, D);
1054 : 492106 : BODY_00_15 (U, 9, D, E, T, A, B, C);
1055 : 492106 : BODY_00_15 (U, 10, C, D, E, T, A, B);
1056 : 492106 : BODY_00_15 (U, 11, B, C, D, E, T, A);
1057 : 492106 : BODY_00_15 (U, 12, A, B, C, D, E, T);
1058 : 492106 : BODY_00_15 (U, 13, T, A, B, C, D, E);
1059 : 492106 : BODY_00_15 (U, 14, E, T, A, B, C, D);
1060 : 492106 : BODY_00_15 (U, 15, D, E, T, A, B, C);
1061 : 492106 : BODY_16_19 (U, 16, C, D, E, T, A, B);
1062 : 492106 : BODY_16_19 (U, 17, B, C, D, E, T, A);
1063 : 492106 : BODY_16_19 (U, 18, A, B, C, D, E, T);
1064 : 492106 : BODY_16_19 (U, 19, T, A, B, C, D, E);
1065 : :
1066 : 492106 : BODY_20_39 (U, 20, E, T, A, B, C, D);
1067 : 492106 : BODY_20_39 (U, 21, D, E, T, A, B, C);
1068 : 492106 : BODY_20_39 (U, 22, C, D, E, T, A, B);
1069 : 492106 : BODY_20_39 (U, 23, B, C, D, E, T, A);
1070 : 492106 : BODY_20_39 (U, 24, A, B, C, D, E, T);
1071 : 492106 : BODY_20_39 (U, 25, T, A, B, C, D, E);
1072 : 492106 : BODY_20_39 (U, 26, E, T, A, B, C, D);
1073 : 492106 : BODY_20_39 (U, 27, D, E, T, A, B, C);
1074 : 492106 : BODY_20_39 (U, 28, C, D, E, T, A, B);
1075 : 492106 : BODY_20_39 (U, 29, B, C, D, E, T, A);
1076 : 492106 : BODY_20_39 (U, 30, A, B, C, D, E, T);
1077 : 492106 : BODY_20_39 (U, 31, T, A, B, C, D, E);
1078 : 492106 : BODY_20_39 (U, 32, E, T, A, B, C, D);
1079 : 492106 : BODY_20_39 (U, 33, D, E, T, A, B, C);
1080 : 492106 : BODY_20_39 (U, 34, C, D, E, T, A, B);
1081 : 492106 : BODY_20_39 (U, 35, B, C, D, E, T, A);
1082 : 492106 : BODY_20_39 (U, 36, A, B, C, D, E, T);
1083 : 492106 : BODY_20_39 (U, 37, T, A, B, C, D, E);
1084 : 492106 : BODY_20_39 (U, 38, E, T, A, B, C, D);
1085 : 492106 : BODY_20_39 (U, 39, D, E, T, A, B, C);
1086 : :
1087 : 492106 : BODY_40_59 (U, 40, C, D, E, T, A, B);
1088 : 492106 : BODY_40_59 (U, 41, B, C, D, E, T, A);
1089 : 492106 : BODY_40_59 (U, 42, A, B, C, D, E, T);
1090 : 492106 : BODY_40_59 (U, 43, T, A, B, C, D, E);
1091 : 492106 : BODY_40_59 (U, 44, E, T, A, B, C, D);
1092 : 492106 : BODY_40_59 (U, 45, D, E, T, A, B, C);
1093 : 492106 : BODY_40_59 (U, 46, C, D, E, T, A, B);
1094 : 492106 : BODY_40_59 (U, 47, B, C, D, E, T, A);
1095 : 492106 : BODY_40_59 (U, 48, A, B, C, D, E, T);
1096 : 492106 : BODY_40_59 (U, 49, T, A, B, C, D, E);
1097 : 492106 : BODY_40_59 (U, 50, E, T, A, B, C, D);
1098 : 492106 : BODY_40_59 (U, 51, D, E, T, A, B, C);
1099 : 492106 : BODY_40_59 (U, 52, C, D, E, T, A, B);
1100 : 492106 : BODY_40_59 (U, 53, B, C, D, E, T, A);
1101 : 492106 : BODY_40_59 (U, 54, A, B, C, D, E, T);
1102 : 492106 : BODY_40_59 (U, 55, T, A, B, C, D, E);
1103 : 492106 : BODY_40_59 (U, 56, E, T, A, B, C, D);
1104 : 492106 : BODY_40_59 (U, 57, D, E, T, A, B, C);
1105 : 492106 : BODY_40_59 (U, 58, C, D, E, T, A, B);
1106 : 492106 : BODY_40_59 (U, 59, B, C, D, E, T, A);
1107 : :
1108 : 492106 : BODY_60_79 (U, 60, A, B, C, D, E, T);
1109 : 492106 : BODY_60_79 (U, 61, T, A, B, C, D, E);
1110 : 492106 : BODY_60_79 (U, 62, E, T, A, B, C, D);
1111 : 492106 : BODY_60_79 (U, 63, D, E, T, A, B, C);
1112 : 492106 : BODY_60_79 (U, 64, C, D, E, T, A, B);
1113 : 492106 : BODY_60_79 (U, 65, B, C, D, E, T, A);
1114 : 492106 : BODY_60_79 (U, 66, A, B, C, D, E, T);
1115 : 492106 : BODY_60_79 (U, 67, T, A, B, C, D, E);
1116 : 492106 : BODY_60_79 (U, 68, E, T, A, B, C, D);
1117 : 492106 : BODY_60_79 (U, 69, D, E, T, A, B, C);
1118 : 492106 : BODY_60_79 (U, 70, C, D, E, T, A, B);
1119 : 492106 : BODY_60_79 (U, 71, B, C, D, E, T, A);
1120 : 492106 : BODY_60_79 (U, 72, A, B, C, D, E, T);
1121 : 492106 : BODY_60_79 (U, 73, T, A, B, C, D, E);
1122 : 492106 : BODY_60_79 (U, 74, E, T, A, B, C, D);
1123 : 492106 : BODY_60_79 (U, 75, D, E, T, A, B, C);
1124 : 492106 : BODY_60_79 (U, 76, C, D, E, T, A, B);
1125 : 492106 : BODY_60_79 (U, 77, B, C, D, E, T, A);
1126 : 492106 : BODY_60_79 (U, 78, A, B, C, D, E, T);
1127 : 492106 : BODY_60_79 (U, 79, T, A, B, C, D, E);
1128 : :
1129 : 492106 : ctx->m_nA += E;
1130 : 492106 : ctx->m_nB += T;
1131 : 492106 : ctx->m_nC += A;
1132 : 492106 : ctx->m_nD += B;
1133 : 492106 : ctx->m_nE += C;
1134 : 492106 : }
1135 : :
1136 : : /*
1137 : : * __rtl_digest_endSHA.
1138 : : */
1139 : 245856 : static void __rtl_digest_endSHA (DigestContextSHA *ctx)
1140 : : {
1141 : : static const sal_uInt8 end[4] =
1142 : : {
1143 : : 0x80, 0x00, 0x00, 0x00
1144 : : };
1145 : 245856 : const sal_uInt8 *p = end;
1146 : :
1147 : : sal_uInt32 *X;
1148 : : int i;
1149 : :
1150 : 245856 : X = ctx->m_pData;
1151 : 245856 : i = (ctx->m_nDatLen >> 2);
1152 : :
1153 : : #ifdef OSL_BIGENDIAN
1154 : : __rtl_digest_swapLong (X, i + 1);
1155 : : #endif /* OSL_BIGENDIAN */
1156 : :
1157 [ + + + + ]: 245856 : switch (ctx->m_nDatLen & 0x03)
1158 : : {
1159 : 10 : case 1: X[i] &= 0x000000ff; break;
1160 : 26 : case 2: X[i] &= 0x0000ffff; break;
1161 : 5 : case 3: X[i] &= 0x00ffffff; break;
1162 : : }
1163 : :
1164 [ + + + + : 245856 : switch (ctx->m_nDatLen & 0x03)
- ]
1165 : : {
1166 : 245815 : case 0: X[i] = ((sal_uInt32)(*(p++))) << 0L;
1167 : 245825 : case 1: X[i] |= ((sal_uInt32)(*(p++))) << 8L;
1168 : 245851 : case 2: X[i] |= ((sal_uInt32)(*(p++))) << 16L;
1169 : 245856 : case 3: X[i] |= ((sal_uInt32)(*(p++))) << 24L;
1170 : : }
1171 : :
1172 : 245856 : __rtl_digest_swapLong (X, i + 1);
1173 : :
1174 : 245856 : i += 1;
1175 : :
1176 [ + + ]: 245856 : if (i >= (DIGEST_LBLOCK_SHA - 2))
1177 : : {
1178 [ + + ]: 70 : for (; i < DIGEST_LBLOCK_SHA; i++)
1179 : 45 : X[i] = 0;
1180 : 25 : __rtl_digest_updateSHA (ctx);
1181 : 25 : i = 0;
1182 : : }
1183 : :
1184 [ + + ]: 2212666 : for (; i < (DIGEST_LBLOCK_SHA - 2); i++)
1185 : 1966810 : X[i] = 0;
1186 : :
1187 : 245856 : X[DIGEST_LBLOCK_SHA - 2] = ctx->m_nH;
1188 : 245856 : X[DIGEST_LBLOCK_SHA - 1] = ctx->m_nL;
1189 : :
1190 : 245856 : __rtl_digest_updateSHA (ctx);
1191 : 245856 : }
1192 : :
1193 : : /*========================================================================
1194 : : *
1195 : : * rtl_digest_SHA internals.
1196 : : *
1197 : : *======================================================================*/
1198 : : /*
1199 : : * __rtl_digest_SHA_0.
1200 : : */
1201 : : static const Digest_Impl __rtl_digest_SHA_0 =
1202 : : {
1203 : : rtl_Digest_AlgorithmSHA,
1204 : : RTL_DIGEST_LENGTH_SHA,
1205 : :
1206 : : NULL,
1207 : : rtl_digest_destroySHA,
1208 : : rtl_digest_updateSHA,
1209 : : rtl_digest_getSHA
1210 : : };
1211 : :
1212 : : /*
1213 : : * __rtl_digest_updateSHA_0.
1214 : : */
1215 : 0 : static sal_uInt32 __rtl_digest_updateSHA_0 (sal_uInt32 x)
1216 : : {
1217 : 0 : return x;
1218 : : }
1219 : :
1220 : : /*========================================================================
1221 : : *
1222 : : * rtl_digest_SHA implementation.
1223 : : *
1224 : : *======================================================================*/
1225 : : /*
1226 : : * rtl_digest_SHA.
1227 : : */
1228 : 0 : rtlDigestError SAL_CALL rtl_digest_SHA (
1229 : : const void *pData, sal_uInt32 nDatLen,
1230 : : sal_uInt8 *pBuffer, sal_uInt32 nBufLen) SAL_THROW_EXTERN_C()
1231 : : {
1232 : : DigestSHA_Impl digest;
1233 : : rtlDigestError result;
1234 : :
1235 : 0 : digest.m_digest = __rtl_digest_SHA_0;
1236 : 0 : __rtl_digest_initSHA (&(digest.m_context), __rtl_digest_updateSHA_0);
1237 : :
1238 : 0 : result = rtl_digest_updateSHA (&digest, pData, nDatLen);
1239 [ # # ]: 0 : if (result == rtl_Digest_E_None)
1240 : 0 : result = rtl_digest_getSHA (&digest, pBuffer, nBufLen);
1241 : :
1242 : 0 : memset (&digest, 0, sizeof (digest));
1243 : 0 : return (result);
1244 : : }
1245 : :
1246 : : /*
1247 : : * rtl_digest_createSHA.
1248 : : */
1249 : 0 : rtlDigest SAL_CALL rtl_digest_createSHA() SAL_THROW_EXTERN_C()
1250 : : {
1251 : 0 : DigestSHA_Impl *pImpl = (DigestSHA_Impl*)NULL;
1252 : 0 : pImpl = RTL_DIGEST_CREATE(DigestSHA_Impl);
1253 [ # # ]: 0 : if (pImpl)
1254 : : {
1255 : 0 : pImpl->m_digest = __rtl_digest_SHA_0;
1256 : 0 : __rtl_digest_initSHA (&(pImpl->m_context), __rtl_digest_updateSHA_0);
1257 : : }
1258 : 0 : return ((rtlDigest)pImpl);
1259 : : }
1260 : :
1261 : : /*
1262 : : * rtl_digest_updateSHA.
1263 : : */
1264 : 0 : rtlDigestError SAL_CALL rtl_digest_updateSHA (
1265 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
1266 : : SAL_THROW_EXTERN_C()
1267 : : {
1268 : 0 : DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
1269 : 0 : const sal_uInt8 *d = (const sal_uInt8 *)pData;
1270 : :
1271 : : DigestContextSHA *ctx;
1272 : : sal_uInt32 len;
1273 : :
1274 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pData == NULL))
1275 : 0 : return rtl_Digest_E_Argument;
1276 : :
1277 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA))
1278 : 0 : return rtl_Digest_E_Algorithm;
1279 : :
1280 [ # # ]: 0 : if (nDatLen == 0)
1281 : 0 : return rtl_Digest_E_None;
1282 : :
1283 : 0 : ctx = &(pImpl->m_context);
1284 : :
1285 : 0 : len = ctx->m_nL + (nDatLen << 3);
1286 [ # # ]: 0 : if (len < ctx->m_nL) ctx->m_nH += 1;
1287 : 0 : ctx->m_nH += (nDatLen >> 29);
1288 : 0 : ctx->m_nL = len;
1289 : :
1290 [ # # ]: 0 : if (ctx->m_nDatLen)
1291 : : {
1292 : 0 : sal_uInt8 *p = (sal_uInt8 *)(ctx->m_pData) + ctx->m_nDatLen;
1293 : 0 : sal_uInt32 n = DIGEST_CBLOCK_SHA - ctx->m_nDatLen;
1294 : :
1295 [ # # ]: 0 : if (nDatLen < n)
1296 : : {
1297 : 0 : memcpy (p, d, nDatLen);
1298 : 0 : ctx->m_nDatLen += nDatLen;
1299 : :
1300 : 0 : return rtl_Digest_E_None;
1301 : : }
1302 : :
1303 : 0 : memcpy (p, d, n);
1304 : 0 : d += n;
1305 : 0 : nDatLen -= n;
1306 : :
1307 : : #ifndef OSL_BIGENDIAN
1308 : 0 : __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
1309 : : #endif /* OSL_BIGENDIAN */
1310 : :
1311 : 0 : __rtl_digest_updateSHA (ctx);
1312 : 0 : ctx->m_nDatLen = 0;
1313 : : }
1314 : :
1315 [ # # ]: 0 : while (nDatLen >= DIGEST_CBLOCK_SHA)
1316 : : {
1317 : 0 : memcpy (ctx->m_pData, d, DIGEST_CBLOCK_SHA);
1318 : 0 : d += DIGEST_CBLOCK_SHA;
1319 : 0 : nDatLen -= DIGEST_CBLOCK_SHA;
1320 : :
1321 : : #ifndef OSL_BIGENDIAN
1322 : 0 : __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
1323 : : #endif /* OSL_BIGENDIAN */
1324 : :
1325 : 0 : __rtl_digest_updateSHA (ctx);
1326 : : }
1327 : :
1328 : 0 : memcpy (ctx->m_pData, d, nDatLen);
1329 : 0 : ctx->m_nDatLen = nDatLen;
1330 : :
1331 : 0 : return rtl_Digest_E_None;
1332 : : }
1333 : :
1334 : : /*
1335 : : * rtl_digest_getSHA.
1336 : : */
1337 : 0 : rtlDigestError SAL_CALL rtl_digest_getSHA (
1338 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
1339 : : SAL_THROW_EXTERN_C()
1340 : : {
1341 : 0 : DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
1342 : 0 : sal_uInt8 *p = pBuffer;
1343 : :
1344 : : DigestContextSHA *ctx;
1345 : :
1346 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pBuffer == NULL))
1347 : 0 : return rtl_Digest_E_Argument;
1348 : :
1349 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA))
1350 : 0 : return rtl_Digest_E_Algorithm;
1351 : :
1352 [ # # ]: 0 : if (!(pImpl->m_digest.m_length <= nBufLen))
1353 : 0 : return rtl_Digest_E_BufferSize;
1354 : :
1355 : 0 : ctx = &(pImpl->m_context);
1356 : :
1357 : 0 : __rtl_digest_endSHA (ctx);
1358 : 0 : RTL_DIGEST_HTONL (ctx->m_nA, p);
1359 : 0 : RTL_DIGEST_HTONL (ctx->m_nB, p);
1360 : 0 : RTL_DIGEST_HTONL (ctx->m_nC, p);
1361 : 0 : RTL_DIGEST_HTONL (ctx->m_nD, p);
1362 : 0 : RTL_DIGEST_HTONL (ctx->m_nE, p);
1363 : 0 : __rtl_digest_initSHA (ctx, __rtl_digest_updateSHA_0);
1364 : :
1365 : 0 : return rtl_Digest_E_None;
1366 : : }
1367 : :
1368 : : /*
1369 : : * rtl_digest_destroySHA.
1370 : : */
1371 : 0 : void SAL_CALL rtl_digest_destroySHA (rtlDigest Digest) SAL_THROW_EXTERN_C()
1372 : : {
1373 : 0 : DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
1374 [ # # ]: 0 : if (pImpl)
1375 : : {
1376 [ # # ]: 0 : if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA)
1377 : 0 : rtl_freeZeroMemory (pImpl, sizeof (DigestSHA_Impl));
1378 : : else
1379 : 0 : rtl_freeMemory (pImpl);
1380 : : }
1381 : 0 : }
1382 : :
1383 : : /*========================================================================
1384 : : *
1385 : : * rtl_digest_SHA1 internals.
1386 : : *
1387 : : *======================================================================*/
1388 : : /*
1389 : : * __rtl_digest_SHA_1.
1390 : : */
1391 : : static const Digest_Impl __rtl_digest_SHA_1 =
1392 : : {
1393 : : rtl_Digest_AlgorithmSHA1,
1394 : : RTL_DIGEST_LENGTH_SHA1,
1395 : :
1396 : : NULL,
1397 : : rtl_digest_destroySHA1,
1398 : : rtl_digest_updateSHA1,
1399 : : rtl_digest_getSHA1
1400 : : };
1401 : :
1402 : : /*
1403 : : * __rtl_digest_updateSHA_1.
1404 : : */
1405 : 31494784 : static sal_uInt32 __rtl_digest_updateSHA_1 (sal_uInt32 x)
1406 : : {
1407 : 31494784 : return RTL_DIGEST_ROTL (x, 1);
1408 : : }
1409 : :
1410 : : /*========================================================================
1411 : : *
1412 : : * rtl_digest_SHA1 implementation.
1413 : : *
1414 : : *======================================================================*/
1415 : : /*
1416 : : * rtl_digest_SHA1.
1417 : : */
1418 : 20 : rtlDigestError SAL_CALL rtl_digest_SHA1 (
1419 : : const void *pData, sal_uInt32 nDatLen,
1420 : : sal_uInt8 *pBuffer, sal_uInt32 nBufLen) SAL_THROW_EXTERN_C()
1421 : : {
1422 : : DigestSHA_Impl digest;
1423 : : rtlDigestError result;
1424 : :
1425 : 20 : digest.m_digest = __rtl_digest_SHA_1;
1426 : 20 : __rtl_digest_initSHA (&(digest.m_context), __rtl_digest_updateSHA_1);
1427 : :
1428 : 20 : result = rtl_digest_updateSHA1 (&digest, pData, nDatLen);
1429 [ + - ]: 20 : if (result == rtl_Digest_E_None)
1430 : 20 : result = rtl_digest_getSHA1 (&digest, pBuffer, nBufLen);
1431 : :
1432 : 20 : memset (&digest, 0, sizeof (digest));
1433 : 20 : return (result);
1434 : : }
1435 : :
1436 : : /*
1437 : : * rtl_digest_createSHA1.
1438 : : */
1439 : 76 : rtlDigest SAL_CALL rtl_digest_createSHA1() SAL_THROW_EXTERN_C()
1440 : : {
1441 : 76 : DigestSHA_Impl *pImpl = (DigestSHA_Impl*)NULL;
1442 : 76 : pImpl = RTL_DIGEST_CREATE(DigestSHA_Impl);
1443 [ + - ]: 76 : if (pImpl)
1444 : : {
1445 : 76 : pImpl->m_digest = __rtl_digest_SHA_1;
1446 : 76 : __rtl_digest_initSHA (&(pImpl->m_context), __rtl_digest_updateSHA_1);
1447 : : }
1448 : 76 : return ((rtlDigest)pImpl);
1449 : : }
1450 : :
1451 : : /*
1452 : : * rtl_digest_updateSHA1.
1453 : : */
1454 : 492278 : rtlDigestError SAL_CALL rtl_digest_updateSHA1 (
1455 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
1456 : : SAL_THROW_EXTERN_C()
1457 : : {
1458 : 492278 : DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
1459 : 492278 : const sal_uInt8 *d = (const sal_uInt8 *)pData;
1460 : :
1461 : : DigestContextSHA *ctx;
1462 : : sal_uInt32 len;
1463 : :
1464 [ + - ][ - + ]: 492278 : if ((pImpl == NULL) || (pData == NULL))
1465 : 0 : return rtl_Digest_E_Argument;
1466 : :
1467 [ - + ]: 492278 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1))
1468 : 0 : return rtl_Digest_E_Algorithm;
1469 : :
1470 [ - + ]: 492278 : if (nDatLen == 0)
1471 : 0 : return rtl_Digest_E_None;
1472 : :
1473 : 492278 : ctx = &(pImpl->m_context);
1474 : :
1475 : 492278 : len = ctx->m_nL + (nDatLen << 3);
1476 [ - + ]: 492278 : if (len < ctx->m_nL) ctx->m_nH += 1;
1477 : 492278 : ctx->m_nH += (nDatLen >> 29);
1478 : 492278 : ctx->m_nL = len;
1479 : :
1480 [ + + ]: 492278 : if (ctx->m_nDatLen)
1481 : : {
1482 : 582 : sal_uInt8 *p = (sal_uInt8 *)(ctx->m_pData) + ctx->m_nDatLen;
1483 : 582 : sal_uInt32 n = DIGEST_CBLOCK_SHA - ctx->m_nDatLen;
1484 : :
1485 [ + - ]: 582 : if (nDatLen < n)
1486 : : {
1487 : 582 : memcpy (p, d, nDatLen);
1488 : 582 : ctx->m_nDatLen += nDatLen;
1489 : :
1490 : 582 : return rtl_Digest_E_None;
1491 : : }
1492 : :
1493 : 0 : memcpy (p, d, n);
1494 : 0 : d += n;
1495 : 0 : nDatLen -= n;
1496 : :
1497 : : #ifndef OSL_BIGENDIAN
1498 : 0 : __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
1499 : : #endif /* OSL_BIGENDIAN */
1500 : :
1501 : 0 : __rtl_digest_updateSHA (ctx);
1502 : 0 : ctx->m_nDatLen = 0;
1503 : : }
1504 : :
1505 [ + + ]: 737921 : while (nDatLen >= DIGEST_CBLOCK_SHA)
1506 : : {
1507 : 246225 : memcpy (ctx->m_pData, d, DIGEST_CBLOCK_SHA);
1508 : 246225 : d += DIGEST_CBLOCK_SHA;
1509 : 246225 : nDatLen -= DIGEST_CBLOCK_SHA;
1510 : :
1511 : : #ifndef OSL_BIGENDIAN
1512 : 246225 : __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
1513 : : #endif /* OSL_BIGENDIAN */
1514 : :
1515 : 246225 : __rtl_digest_updateSHA (ctx);
1516 : : }
1517 : :
1518 : 491696 : memcpy (ctx->m_pData, d, nDatLen);
1519 : 491696 : ctx->m_nDatLen = nDatLen;
1520 : :
1521 : 492278 : return rtl_Digest_E_None;
1522 : : }
1523 : :
1524 : : /*
1525 : : * rtl_digest_getSHA1.
1526 : : */
1527 : 245856 : rtlDigestError SAL_CALL rtl_digest_getSHA1 (
1528 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
1529 : : SAL_THROW_EXTERN_C()
1530 : : {
1531 : 245856 : DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
1532 : 245856 : sal_uInt8 *p = pBuffer;
1533 : :
1534 : : DigestContextSHA *ctx;
1535 : :
1536 [ + - ][ - + ]: 245856 : if ((pImpl == NULL) || (pBuffer == NULL))
1537 : 0 : return rtl_Digest_E_Argument;
1538 : :
1539 [ - + ]: 245856 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1))
1540 : 0 : return rtl_Digest_E_Algorithm;
1541 : :
1542 [ - + ]: 245856 : if (!(pImpl->m_digest.m_length <= nBufLen))
1543 : 0 : return rtl_Digest_E_BufferSize;
1544 : :
1545 : 245856 : ctx = &(pImpl->m_context);
1546 : :
1547 : 245856 : __rtl_digest_endSHA (ctx);
1548 : 245856 : RTL_DIGEST_HTONL (ctx->m_nA, p);
1549 : 245856 : RTL_DIGEST_HTONL (ctx->m_nB, p);
1550 : 245856 : RTL_DIGEST_HTONL (ctx->m_nC, p);
1551 : 245856 : RTL_DIGEST_HTONL (ctx->m_nD, p);
1552 : 245856 : RTL_DIGEST_HTONL (ctx->m_nE, p);
1553 : 245856 : __rtl_digest_initSHA (ctx, __rtl_digest_updateSHA_1);
1554 : :
1555 : 245856 : return rtl_Digest_E_None;
1556 : : }
1557 : :
1558 : : /*
1559 : : * rtl_digest_destroySHA1.
1560 : : */
1561 : 76 : void SAL_CALL rtl_digest_destroySHA1 (rtlDigest Digest) SAL_THROW_EXTERN_C()
1562 : : {
1563 : 76 : DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
1564 [ + - ]: 76 : if (pImpl)
1565 : : {
1566 [ + - ]: 76 : if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1)
1567 : 76 : rtl_freeZeroMemory (pImpl, sizeof (DigestSHA_Impl));
1568 : : else
1569 : 0 : rtl_freeMemory (pImpl);
1570 : : }
1571 : 76 : }
1572 : :
1573 : : /*========================================================================
1574 : : *
1575 : : * rtl_digest_HMAC_MD5 internals.
1576 : : *
1577 : : *======================================================================*/
1578 : : #define DIGEST_CBLOCK_HMAC_MD5 64
1579 : :
1580 : : struct ContextHMAC_MD5
1581 : : {
1582 : : DigestMD5_Impl m_hash;
1583 : : sal_uInt8 m_opad[DIGEST_CBLOCK_HMAC_MD5];
1584 : : };
1585 : :
1586 : : struct DigestHMAC_MD5_Impl
1587 : : {
1588 : : Digest_Impl m_digest;
1589 : : ContextHMAC_MD5 m_context;
1590 : : };
1591 : :
1592 : : static void __rtl_digest_initHMAC_MD5 (ContextHMAC_MD5 * ctx);
1593 : : static void __rtl_digest_ipadHMAC_MD5 (ContextHMAC_MD5 * ctx);
1594 : : static void __rtl_digest_opadHMAC_MD5 (ContextHMAC_MD5 * ctx);
1595 : :
1596 : : /*
1597 : : * __rtl_digest_HMAC_MD5.
1598 : : */
1599 : : static const Digest_Impl __rtl_digest_HMAC_MD5 =
1600 : : {
1601 : : rtl_Digest_AlgorithmHMAC_MD5,
1602 : : RTL_DIGEST_LENGTH_MD5,
1603 : :
1604 : : rtl_digest_initHMAC_MD5,
1605 : : rtl_digest_destroyHMAC_MD5,
1606 : : rtl_digest_updateHMAC_MD5,
1607 : : rtl_digest_getHMAC_MD5
1608 : : };
1609 : :
1610 : : /*
1611 : : * __rtl_digest_initHMAC_MD5.
1612 : : */
1613 : 0 : static void __rtl_digest_initHMAC_MD5 (ContextHMAC_MD5 * ctx)
1614 : : {
1615 : 0 : DigestMD5_Impl *pImpl = &(ctx->m_hash);
1616 : :
1617 : 0 : pImpl->m_digest = __rtl_digest_MD5;
1618 : 0 : __rtl_digest_initMD5 (&(pImpl->m_context));
1619 : :
1620 : 0 : memset (ctx->m_opad, 0, DIGEST_CBLOCK_HMAC_MD5);
1621 : 0 : }
1622 : :
1623 : : /*
1624 : : * __rtl_digest_ipadHMAC_MD5.
1625 : : */
1626 : 0 : static void __rtl_digest_ipadHMAC_MD5 (ContextHMAC_MD5 * ctx)
1627 : : {
1628 : : sal_uInt32 i;
1629 : :
1630 [ # # ]: 0 : for (i = 0; i < DIGEST_CBLOCK_HMAC_MD5; i++)
1631 : 0 : ctx->m_opad[i] ^= 0x36;
1632 : : rtl_digest_updateMD5 (
1633 : 0 : &(ctx->m_hash), ctx->m_opad, DIGEST_CBLOCK_HMAC_MD5);
1634 [ # # ]: 0 : for (i = 0; i < DIGEST_CBLOCK_HMAC_MD5; i++)
1635 : 0 : ctx->m_opad[i] ^= 0x36;
1636 : 0 : }
1637 : :
1638 : : /*
1639 : : * __rtl_digest_opadHMAC_MD5.
1640 : : */
1641 : 0 : static void __rtl_digest_opadHMAC_MD5 (ContextHMAC_MD5 * ctx)
1642 : : {
1643 : : sal_uInt32 i;
1644 : :
1645 [ # # ]: 0 : for (i = 0; i < DIGEST_CBLOCK_HMAC_MD5; i++)
1646 : 0 : ctx->m_opad[i] ^= 0x5c;
1647 : 0 : }
1648 : :
1649 : : /*========================================================================
1650 : : *
1651 : : * rtl_digest_HMAC_MD5 implementation.
1652 : : *
1653 : : *======================================================================*/
1654 : : /*
1655 : : * rtl_digest_HMAC_MD5.
1656 : : */
1657 : 0 : rtlDigestError SAL_CALL rtl_digest_HMAC_MD5 (
1658 : : const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen,
1659 : : const void *pData, sal_uInt32 nDatLen,
1660 : : sal_uInt8 *pBuffer, sal_uInt32 nBufLen) SAL_THROW_EXTERN_C()
1661 : : {
1662 : : DigestHMAC_MD5_Impl digest;
1663 : : rtlDigestError result;
1664 : :
1665 : 0 : digest.m_digest = __rtl_digest_HMAC_MD5;
1666 : :
1667 : 0 : result = rtl_digest_initHMAC_MD5 (&digest, pKeyData, nKeyLen);
1668 [ # # ]: 0 : if (result == rtl_Digest_E_None)
1669 : : {
1670 : 0 : result = rtl_digest_updateHMAC_MD5 (&digest, pData, nDatLen);
1671 [ # # ]: 0 : if (result == rtl_Digest_E_None)
1672 : 0 : result = rtl_digest_getHMAC_MD5 (&digest, pBuffer, nBufLen);
1673 : : }
1674 : :
1675 : 0 : memset (&digest, 0, sizeof (digest));
1676 : 0 : return (result);
1677 : : }
1678 : :
1679 : : /*
1680 : : * rtl_digest_createHMAC_MD5.
1681 : : */
1682 : 0 : rtlDigest SAL_CALL rtl_digest_createHMAC_MD5() SAL_THROW_EXTERN_C()
1683 : : {
1684 : 0 : DigestHMAC_MD5_Impl *pImpl = (DigestHMAC_MD5_Impl*)NULL;
1685 : 0 : pImpl = RTL_DIGEST_CREATE(DigestHMAC_MD5_Impl);
1686 [ # # ]: 0 : if (pImpl)
1687 : : {
1688 : 0 : pImpl->m_digest = __rtl_digest_HMAC_MD5;
1689 : 0 : __rtl_digest_initHMAC_MD5 (&(pImpl->m_context));
1690 : : }
1691 : 0 : return ((rtlDigest)pImpl);
1692 : : }
1693 : :
1694 : : /*
1695 : : * rtl_digest_initHMAC_MD5.
1696 : : */
1697 : 0 : rtlDigestError SAL_CALL rtl_digest_initHMAC_MD5 (
1698 : : rtlDigest Digest, const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen)
1699 : : SAL_THROW_EXTERN_C()
1700 : : {
1701 : 0 : DigestHMAC_MD5_Impl *pImpl = (DigestHMAC_MD5_Impl*)Digest;
1702 : : ContextHMAC_MD5 *ctx;
1703 : :
1704 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pKeyData == NULL))
1705 : 0 : return rtl_Digest_E_Argument;
1706 : :
1707 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_MD5))
1708 : 0 : return rtl_Digest_E_Algorithm;
1709 : :
1710 : 0 : ctx = &(pImpl->m_context);
1711 : 0 : __rtl_digest_initHMAC_MD5 (ctx);
1712 : :
1713 [ # # ]: 0 : if (nKeyLen > DIGEST_CBLOCK_HMAC_MD5)
1714 : : {
1715 : : /* Initialize 'opad' with hashed 'KeyData' */
1716 : : rtl_digest_updateMD5 (
1717 : 0 : &(ctx->m_hash), pKeyData, nKeyLen);
1718 : : rtl_digest_getMD5 (
1719 : 0 : &(ctx->m_hash), ctx->m_opad, RTL_DIGEST_LENGTH_MD5);
1720 : : }
1721 : : else
1722 : : {
1723 : : /* Initialize 'opad' with plain 'KeyData' */
1724 : 0 : memcpy (ctx->m_opad, pKeyData, nKeyLen);
1725 : : }
1726 : :
1727 : 0 : __rtl_digest_ipadHMAC_MD5 (ctx);
1728 : 0 : __rtl_digest_opadHMAC_MD5 (ctx);
1729 : :
1730 : 0 : return rtl_Digest_E_None;
1731 : : }
1732 : :
1733 : : /*
1734 : : * rtl_digest_updateHMAC_MD5.
1735 : : */
1736 : 0 : rtlDigestError SAL_CALL rtl_digest_updateHMAC_MD5 (
1737 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
1738 : : SAL_THROW_EXTERN_C()
1739 : : {
1740 : 0 : DigestHMAC_MD5_Impl *pImpl = (DigestHMAC_MD5_Impl*)Digest;
1741 : : ContextHMAC_MD5 *ctx;
1742 : :
1743 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pData == NULL))
1744 : 0 : return rtl_Digest_E_Argument;
1745 : :
1746 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_MD5))
1747 : 0 : return rtl_Digest_E_Algorithm;
1748 : :
1749 : 0 : ctx = &(pImpl->m_context);
1750 : 0 : rtl_digest_updateMD5 (&(ctx->m_hash), pData, nDatLen);
1751 : :
1752 : 0 : return rtl_Digest_E_None;
1753 : : }
1754 : :
1755 : : /*
1756 : : * rtl_digest_getHMAC_MD5.
1757 : : */
1758 : 0 : rtlDigestError SAL_CALL rtl_digest_getHMAC_MD5 (
1759 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
1760 : : SAL_THROW_EXTERN_C()
1761 : : {
1762 : 0 : DigestHMAC_MD5_Impl *pImpl = (DigestHMAC_MD5_Impl*)Digest;
1763 : : ContextHMAC_MD5 *ctx;
1764 : :
1765 [ # # ][ # # ]: 0 : if ((pImpl == NULL) || (pBuffer == NULL))
1766 : 0 : return rtl_Digest_E_Argument;
1767 : :
1768 [ # # ]: 0 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_MD5))
1769 : 0 : return rtl_Digest_E_Algorithm;
1770 : :
1771 [ # # ]: 0 : if (!(pImpl->m_digest.m_length <= nBufLen))
1772 : 0 : return rtl_Digest_E_BufferSize;
1773 : :
1774 : 0 : nBufLen = pImpl->m_digest.m_length;
1775 : :
1776 : 0 : ctx = &(pImpl->m_context);
1777 : 0 : rtl_digest_getMD5 (&(ctx->m_hash), pBuffer, nBufLen);
1778 : :
1779 : 0 : rtl_digest_updateMD5 (&(ctx->m_hash), ctx->m_opad, 64);
1780 : 0 : rtl_digest_updateMD5 (&(ctx->m_hash), pBuffer, nBufLen);
1781 : 0 : rtl_digest_getMD5 (&(ctx->m_hash), pBuffer, nBufLen);
1782 : :
1783 : 0 : __rtl_digest_opadHMAC_MD5 (ctx);
1784 : 0 : __rtl_digest_ipadHMAC_MD5 (ctx);
1785 : 0 : __rtl_digest_opadHMAC_MD5 (ctx);
1786 : :
1787 : 0 : return rtl_Digest_E_None;
1788 : : }
1789 : :
1790 : : /*
1791 : : * rtl_digest_destroyHMAC_MD5.
1792 : : */
1793 : 0 : void SAL_CALL rtl_digest_destroyHMAC_MD5 (rtlDigest Digest) SAL_THROW_EXTERN_C()
1794 : : {
1795 : 0 : DigestHMAC_MD5_Impl *pImpl = (DigestHMAC_MD5_Impl*)Digest;
1796 [ # # ]: 0 : if (pImpl)
1797 : : {
1798 [ # # ]: 0 : if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_MD5)
1799 : 0 : rtl_freeZeroMemory (pImpl, sizeof (DigestHMAC_MD5_Impl));
1800 : : else
1801 : 0 : rtl_freeMemory (pImpl);
1802 : : }
1803 : 0 : }
1804 : :
1805 : : /*========================================================================
1806 : : *
1807 : : * rtl_digest_HMAC_SHA1 internals.
1808 : : *
1809 : : *======================================================================*/
1810 : : #define DIGEST_CBLOCK_HMAC_SHA1 64
1811 : :
1812 : : struct ContextHMAC_SHA1
1813 : : {
1814 : : DigestSHA_Impl m_hash;
1815 : : sal_uInt8 m_opad[DIGEST_CBLOCK_HMAC_SHA1];
1816 : : };
1817 : :
1818 : : struct DigestHMAC_SHA1_Impl
1819 : : {
1820 : : Digest_Impl m_digest;
1821 : : ContextHMAC_SHA1 m_context;
1822 : : };
1823 : :
1824 : : static void __rtl_digest_initHMAC_SHA1 (ContextHMAC_SHA1 * ctx);
1825 : : static void __rtl_digest_ipadHMAC_SHA1 (ContextHMAC_SHA1 * ctx);
1826 : : static void __rtl_digest_opadHMAC_SHA1 (ContextHMAC_SHA1 * ctx);
1827 : :
1828 : : /*
1829 : : * __rtl_digest_HMAC_SHA1.
1830 : : */
1831 : : static const Digest_Impl __rtl_digest_HMAC_SHA1 =
1832 : : {
1833 : : rtl_Digest_AlgorithmHMAC_SHA1,
1834 : : RTL_DIGEST_LENGTH_SHA1,
1835 : :
1836 : : rtl_digest_initHMAC_SHA1,
1837 : : rtl_digest_destroyHMAC_SHA1,
1838 : : rtl_digest_updateHMAC_SHA1,
1839 : : rtl_digest_getHMAC_SHA1
1840 : : };
1841 : :
1842 : : /*
1843 : : * __rtl_digest_initHMAC_SHA1.
1844 : : */
1845 : 80 : static void __rtl_digest_initHMAC_SHA1 (ContextHMAC_SHA1 * ctx)
1846 : : {
1847 : 80 : DigestSHA_Impl *pImpl = &(ctx->m_hash);
1848 : :
1849 : 80 : pImpl->m_digest = __rtl_digest_SHA_1;
1850 : 80 : __rtl_digest_initSHA (&(pImpl->m_context), __rtl_digest_updateSHA_1);
1851 : :
1852 : 80 : memset (ctx->m_opad, 0, DIGEST_CBLOCK_HMAC_SHA1);
1853 : 80 : }
1854 : :
1855 : : /*
1856 : : * __rtl_digest_ipadHMAC_SHA1.
1857 : : */
1858 : 122960 : static void __rtl_digest_ipadHMAC_SHA1 (ContextHMAC_SHA1 * ctx)
1859 : : {
1860 : : sal_uInt32 i;
1861 : :
1862 [ + + ]: 7992400 : for (i = 0; i < DIGEST_CBLOCK_HMAC_SHA1; i++)
1863 : 7869440 : ctx->m_opad[i] ^= 0x36;
1864 : : rtl_digest_updateSHA1 (
1865 : 122960 : &(ctx->m_hash), ctx->m_opad, DIGEST_CBLOCK_HMAC_SHA1);
1866 [ + + ]: 7992400 : for (i = 0; i < DIGEST_CBLOCK_HMAC_SHA1; i++)
1867 : 7869440 : ctx->m_opad[i] ^= 0x36;
1868 : 122960 : }
1869 : :
1870 : : /*
1871 : : * __rtl_digest_opadHMAC_SHA1.
1872 : : */
1873 : 245840 : static void __rtl_digest_opadHMAC_SHA1 (ContextHMAC_SHA1 * ctx)
1874 : : {
1875 : : sal_uInt32 i;
1876 : :
1877 [ + + ]: 15979600 : for (i = 0; i < DIGEST_CBLOCK_HMAC_SHA1; i++)
1878 : 15733760 : ctx->m_opad[i] ^= 0x5c;
1879 : 245840 : }
1880 : :
1881 : : /*========================================================================
1882 : : *
1883 : : * rtl_digest_HMAC_SHA1 implementation.
1884 : : *
1885 : : *======================================================================*/
1886 : : /*
1887 : : * rtl_digest_HMAC_SHA1.
1888 : : */
1889 : 0 : rtlDigestError SAL_CALL rtl_digest_HMAC_SHA1 (
1890 : : const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen,
1891 : : const void *pData, sal_uInt32 nDatLen,
1892 : : sal_uInt8 *pBuffer, sal_uInt32 nBufLen) SAL_THROW_EXTERN_C()
1893 : : {
1894 : : DigestHMAC_SHA1_Impl digest;
1895 : : rtlDigestError result;
1896 : :
1897 : 0 : digest.m_digest = __rtl_digest_HMAC_SHA1;
1898 : :
1899 : 0 : result = rtl_digest_initHMAC_SHA1 (&digest, pKeyData, nKeyLen);
1900 [ # # ]: 0 : if (result == rtl_Digest_E_None)
1901 : : {
1902 : 0 : result = rtl_digest_updateHMAC_SHA1 (&digest, pData, nDatLen);
1903 [ # # ]: 0 : if (result == rtl_Digest_E_None)
1904 : 0 : result = rtl_digest_getHMAC_SHA1 (&digest, pBuffer, nBufLen);
1905 : : }
1906 : :
1907 : 0 : memset (&digest, 0, sizeof (digest));
1908 : 0 : return (result);
1909 : : }
1910 : :
1911 : : /*
1912 : : * rtl_digest_createHMAC_SHA1.
1913 : : */
1914 : 0 : rtlDigest SAL_CALL rtl_digest_createHMAC_SHA1() SAL_THROW_EXTERN_C()
1915 : : {
1916 : 0 : DigestHMAC_SHA1_Impl *pImpl = (DigestHMAC_SHA1_Impl*)NULL;
1917 : 0 : pImpl = RTL_DIGEST_CREATE(DigestHMAC_SHA1_Impl);
1918 [ # # ]: 0 : if (pImpl)
1919 : : {
1920 : 0 : pImpl->m_digest = __rtl_digest_HMAC_SHA1;
1921 : 0 : __rtl_digest_initHMAC_SHA1 (&(pImpl->m_context));
1922 : : }
1923 : 0 : return ((rtlDigest)pImpl);
1924 : : }
1925 : :
1926 : : /*
1927 : : * rtl_digest_initHMAC_SHA1.
1928 : : */
1929 : 80 : rtlDigestError SAL_CALL rtl_digest_initHMAC_SHA1 (
1930 : : rtlDigest Digest, const sal_uInt8 *pKeyData, sal_uInt32 nKeyLen)
1931 : : SAL_THROW_EXTERN_C()
1932 : : {
1933 : 80 : DigestHMAC_SHA1_Impl *pImpl = (DigestHMAC_SHA1_Impl*)Digest;
1934 : : ContextHMAC_SHA1 *ctx;
1935 : :
1936 [ + - ][ - + ]: 80 : if ((pImpl == NULL) || (pKeyData == NULL))
1937 : 0 : return rtl_Digest_E_Argument;
1938 : :
1939 [ - + ]: 80 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_SHA1))
1940 : 0 : return rtl_Digest_E_Algorithm;
1941 : :
1942 : 80 : ctx = &(pImpl->m_context);
1943 : 80 : __rtl_digest_initHMAC_SHA1 (ctx);
1944 : :
1945 [ - + ]: 80 : if (nKeyLen > DIGEST_CBLOCK_HMAC_SHA1)
1946 : : {
1947 : : /* Initialize 'opad' with hashed 'KeyData' */
1948 : : rtl_digest_updateSHA1 (
1949 : 0 : &(ctx->m_hash), pKeyData, nKeyLen);
1950 : : rtl_digest_getSHA1 (
1951 : 0 : &(ctx->m_hash), ctx->m_opad, RTL_DIGEST_LENGTH_SHA1);
1952 : : }
1953 : : else
1954 : : {
1955 : : /* Initialize 'opad' with plain 'KeyData' */
1956 : 80 : memcpy (ctx->m_opad, pKeyData, nKeyLen);
1957 : : }
1958 : :
1959 : 80 : __rtl_digest_ipadHMAC_SHA1 (ctx);
1960 : 80 : __rtl_digest_opadHMAC_SHA1 (ctx);
1961 : :
1962 : 80 : return rtl_Digest_E_None;
1963 : : }
1964 : :
1965 : : /*
1966 : : * rtl_digest_updateHMAC_SHA1.
1967 : : */
1968 : 123000 : rtlDigestError SAL_CALL rtl_digest_updateHMAC_SHA1 (
1969 : : rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
1970 : : SAL_THROW_EXTERN_C()
1971 : : {
1972 : 123000 : DigestHMAC_SHA1_Impl *pImpl = (DigestHMAC_SHA1_Impl*)Digest;
1973 : : ContextHMAC_SHA1 *ctx;
1974 : :
1975 [ + - ][ - + ]: 123000 : if ((pImpl == NULL) || (pData == NULL))
1976 : 0 : return rtl_Digest_E_Argument;
1977 : :
1978 [ - + ]: 123000 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_SHA1))
1979 : 0 : return rtl_Digest_E_Algorithm;
1980 : :
1981 : 123000 : ctx = &(pImpl->m_context);
1982 : 123000 : rtl_digest_updateSHA1 (&(ctx->m_hash), pData, nDatLen);
1983 : :
1984 : 123000 : return rtl_Digest_E_None;
1985 : : }
1986 : :
1987 : : /*
1988 : : * rtl_digest_getHMAC_SHA1.
1989 : : */
1990 : 122880 : rtlDigestError SAL_CALL rtl_digest_getHMAC_SHA1 (
1991 : : rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
1992 : : SAL_THROW_EXTERN_C()
1993 : : {
1994 : 122880 : DigestHMAC_SHA1_Impl *pImpl = (DigestHMAC_SHA1_Impl*)Digest;
1995 : : ContextHMAC_SHA1 *ctx;
1996 : :
1997 [ + - ][ - + ]: 122880 : if ((pImpl == NULL) || (pBuffer == NULL))
1998 : 0 : return rtl_Digest_E_Argument;
1999 : :
2000 [ - + ]: 122880 : if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_SHA1))
2001 : 0 : return rtl_Digest_E_Algorithm;
2002 : :
2003 [ - + ]: 122880 : if (!(pImpl->m_digest.m_length <= nBufLen))
2004 : 0 : return rtl_Digest_E_BufferSize;
2005 : :
2006 : 122880 : nBufLen = pImpl->m_digest.m_length;
2007 : :
2008 : 122880 : ctx = &(pImpl->m_context);
2009 : 122880 : rtl_digest_getSHA1 (&(ctx->m_hash), pBuffer, nBufLen);
2010 : :
2011 : 122880 : rtl_digest_updateSHA1 (&(ctx->m_hash), ctx->m_opad, sizeof(ctx->m_opad));
2012 : 122880 : rtl_digest_updateSHA1 (&(ctx->m_hash), pBuffer, nBufLen);
2013 : 122880 : rtl_digest_getSHA1 (&(ctx->m_hash), pBuffer, nBufLen);
2014 : :
2015 : 122880 : __rtl_digest_opadHMAC_SHA1 (ctx);
2016 : 122880 : __rtl_digest_ipadHMAC_SHA1 (ctx);
2017 : 122880 : __rtl_digest_opadHMAC_SHA1 (ctx);
2018 : :
2019 : 122880 : return rtl_Digest_E_None;
2020 : : }
2021 : :
2022 : : /*
2023 : : * rtl_digest_destroyHMAC_SHA1.
2024 : : */
2025 : 0 : void SAL_CALL rtl_digest_destroyHMAC_SHA1 (rtlDigest Digest)
2026 : : SAL_THROW_EXTERN_C()
2027 : : {
2028 : 0 : DigestHMAC_SHA1_Impl *pImpl = (DigestHMAC_SHA1_Impl*)Digest;
2029 [ # # ]: 0 : if (pImpl)
2030 : : {
2031 [ # # ]: 0 : if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmHMAC_SHA1)
2032 : 0 : rtl_freeZeroMemory (pImpl, sizeof (DigestHMAC_SHA1_Impl));
2033 : : else
2034 : 0 : rtl_freeMemory (pImpl);
2035 : : }
2036 : 0 : }
2037 : :
2038 : : /*========================================================================
2039 : : *
2040 : : * rtl_digest_PBKDF2 internals.
2041 : : *
2042 : : *======================================================================*/
2043 : : #define DIGEST_CBLOCK_PBKDF2 RTL_DIGEST_LENGTH_HMAC_SHA1
2044 : :
2045 : : /*
2046 : : * __rtl_digest_updatePBKDF2.
2047 : : */
2048 : 120 : static void __rtl_digest_updatePBKDF2 (
2049 : : rtlDigest hDigest,
2050 : : sal_uInt8 T[DIGEST_CBLOCK_PBKDF2],
2051 : : const sal_uInt8 *pSaltData, sal_uInt32 nSaltLen,
2052 : : sal_uInt32 nCount, sal_uInt32 nIndex)
2053 : : {
2054 : : /* T_i = F (P, S, c, i) */
2055 : : sal_uInt8 U[DIGEST_CBLOCK_PBKDF2];
2056 : : sal_uInt32 i, k;
2057 : :
2058 : : /* U_(1) = PRF (P, S || INDEX) */
2059 : 120 : rtl_digest_updateHMAC_SHA1 (hDigest, pSaltData, nSaltLen);
2060 : 120 : rtl_digest_updateHMAC_SHA1 (hDigest, &nIndex, sizeof(nIndex));
2061 : 120 : rtl_digest_getHMAC_SHA1 (hDigest, U, DIGEST_CBLOCK_PBKDF2);
2062 : :
2063 : : /* T = U_(1) */
2064 [ + + ]: 2520 : for (k = 0; k < DIGEST_CBLOCK_PBKDF2; k++) T[k] = U[k];
2065 : :
2066 : : /* T ^= U_(2) ^ ... ^ U_(c) */
2067 [ + + ]: 122880 : for (i = 1; i < nCount; i++)
2068 : : {
2069 : : /* U_(i) = PRF (P, U_(i-1)) */
2070 : 122760 : rtl_digest_updateHMAC_SHA1 (hDigest, U, DIGEST_CBLOCK_PBKDF2);
2071 : 122760 : rtl_digest_getHMAC_SHA1 (hDigest, U, DIGEST_CBLOCK_PBKDF2);
2072 : :
2073 : : /* T ^= U_(i) */
2074 [ + + ]: 2577960 : for (k = 0; k < DIGEST_CBLOCK_PBKDF2; k++) T[k] ^= U[k];
2075 : : }
2076 : :
2077 : 120 : memset (U, 0, DIGEST_CBLOCK_PBKDF2);
2078 : 120 : }
2079 : :
2080 : : /*========================================================================
2081 : : *
2082 : : * rtl_digest_PBKDF2 implementation.
2083 : : *
2084 : : *======================================================================*/
2085 : : /*
2086 : : * rtl_digest_PBKDF2.
2087 : : */
2088 : 80 : rtlDigestError SAL_CALL rtl_digest_PBKDF2 (
2089 : : sal_uInt8 *pKeyData , sal_uInt32 nKeyLen,
2090 : : const sal_uInt8 *pPassData, sal_uInt32 nPassLen,
2091 : : const sal_uInt8 *pSaltData, sal_uInt32 nSaltLen,
2092 : : sal_uInt32 nCount) SAL_THROW_EXTERN_C()
2093 : : {
2094 : : DigestHMAC_SHA1_Impl digest;
2095 : 80 : sal_uInt32 i = 1;
2096 : :
2097 [ + - ][ + - ]: 80 : if ((pKeyData == NULL) || (pPassData == NULL) || (pSaltData == NULL))
[ - + ]
2098 : 0 : return rtl_Digest_E_Argument;
2099 : :
2100 : 80 : digest.m_digest = __rtl_digest_HMAC_SHA1;
2101 : 80 : rtl_digest_initHMAC_SHA1 (&digest, pPassData, nPassLen);
2102 : :
2103 : : /* DK = T_(1) || T_(2) || ... || T_(l) */
2104 [ + + ]: 120 : while (nKeyLen >= DIGEST_CBLOCK_PBKDF2)
2105 : : {
2106 : : /* T_(i) = F (P, S, c, i); DK ||= T_(i) */
2107 : : __rtl_digest_updatePBKDF2 (
2108 : : &digest, pKeyData,
2109 : : pSaltData, nSaltLen,
2110 : 40 : nCount, OSL_NETDWORD(i));
2111 : :
2112 : : /* Next 'KeyData' block */
2113 : 40 : pKeyData += DIGEST_CBLOCK_PBKDF2;
2114 : 40 : nKeyLen -= DIGEST_CBLOCK_PBKDF2;
2115 : 40 : i += 1;
2116 : : }
2117 [ + - ]: 80 : if (nKeyLen > 0)
2118 : : {
2119 : : /* Last 'KeyData' block */
2120 : : sal_uInt8 T[DIGEST_CBLOCK_PBKDF2];
2121 : :
2122 : : /* T_i = F (P, S, c, i) */
2123 : : __rtl_digest_updatePBKDF2 (
2124 : : &digest, T,
2125 : : pSaltData, nSaltLen,
2126 : 80 : nCount, OSL_NETDWORD(i));
2127 : :
2128 : : /* DK ||= T_(i) */
2129 : 80 : memcpy (pKeyData, T, nKeyLen);
2130 : 80 : memset (T, 0, DIGEST_CBLOCK_PBKDF2);
2131 : : }
2132 : :
2133 : 80 : memset (&digest, 0, sizeof (digest));
2134 : 80 : return rtl_Digest_E_None;
2135 : : }
2136 : :
2137 : : /*========================================================================
2138 : : *
2139 : : * The End.
2140 : : *
2141 : : *======================================================================*/
2142 : :
2143 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
