kspread

digest.cpp
1/*************************************************************************
2 * This implementation has been taken from the OpenOffice 1.0 and modified
3 * to use KSpread data types.
4 *
5 * The Initial Developer of the Original Code is: Sun Microsystems, Inc.
6 *
7 * Sun has made the contents of this file available subject to the
8 * terms of GNU Lesser General Public License Version 2.1 as
9 * specified in sal/rtl/source/digest.c in the OpenOffice package.
10 *
11 *
12 * Sun Microsystems Inc., October, 2000
13 *
14 * GNU Lesser General Public License Version 2.1
15 * =============================================
16 * Copyright 2000 by Sun Microsystems, Inc.
17 * 901 San Antonio Road, Palo Alto, CA 94303, USA
18 *
19 * This library is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU Lesser General Public
21 * License version 2.1, as published by the Free Software Foundation.
22 *
23 * This library is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 * Lesser General Public License for more details.
27 *
28 * You should have received a copy of the GNU Lesser General Public
29 * License along with this library; if not, write to the Free Software
30 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
31 * Boston, MA 02110-1301, USA
32 *
33 * All Rights Reserved.
34 *
35 * Contributor(s): Matthias Huetsch <matthias.huetsch@sun.com>
36 *
37 *
38 ************************************************************************/
39
40#include <stdlib.h>
41#include <string.h>
42
43#include "../config.h"
44#include "digest.h"
45#include <kdebug.h>
46#include <kmdcodec.h>
47
48typedef unsigned char sal_uInt8;
49typedef unsigned short sal_uInt16;
50
51#if SIZEOF_INT == 4
52typedef unsigned int sal_uInt32;
53#else
54typedef unsigned long sal_uInt32;
55#endif
56
57void rtl_freeZeroMemory(void * p, sal_uInt32 n);
58void rtl_freeMemory(void * p);
59void rtl_zeroMemory(void * Ptr, sal_uInt32 Bytes);
60void rtl_copyMemory(void *Dst, const void *Src, sal_uInt32 Bytes);
61
62#ifndef OSL_LOBYTE
63# define OSL_LOBYTE(w) ((sal_uInt8)((sal_uInt16)(w) & 0xFF))
64#endif
65#ifndef OSL_HIBYTE
66# define OSL_HIBYTE(w) ((sal_uInt8)(((sal_uInt16)(w) >> 8) & 0xFF))
67#endif
68#ifndef OSL_MAKEWORD
69# define OSL_MAKEWORD(bl, bh) ((sal_uInt16)((bl) & 0xFF) | (((sal_uInt16)(bh) & 0xFF) << 8))
70#endif
71#ifndef OSL_MAKEDWORD
72# define OSL_MAKEDWORD(wl, wh) ((sal_uInt32)((wl) & 0xFFFF) | (((sal_uInt32)(wh) & 0xFFFF) << 16))
73#endif
74#ifndef OSL_LOWORD
75# define OSL_LOWORD(d) ((sal_uInt16)((sal_uInt32)(d) & 0xFFFF))
76#endif
77#ifndef OSL_HIWORD
78# define OSL_HIWORD(d) ((sal_uInt16)(((sal_uInt32)(d) >> 16) & 0xFFFF))
79#endif
80
83#ifndef OSL_SWAPWORD
84# define OSL_SWAPWORD(w) OSL_MAKEWORD(OSL_HIBYTE(w),OSL_LOBYTE(w))
85#endif
86#ifndef OSL_SWAPDWORD
87# define OSL_SWAPDWORD(d) OSL_MAKEDWORD(OSL_SWAPWORD(OSL_HIWORD(d)),OSL_SWAPWORD(OSL_LOWORD(d)))
88#endif
89
90
91/*========================================================================
92 *
93 * rtlDigest.
94 *
95 *======================================================================*/
98typedef void* rtlDigest;
99
103enum __rtl_DigestAlgorithm
104{
105 rtl_Digest_AlgorithmMD2,
106 rtl_Digest_AlgorithmMD5,
107 rtl_Digest_AlgorithmSHA,
108 rtl_Digest_AlgorithmSHA1,
109
110 rtl_Digest_AlgorithmHMAC_MD5,
111 rtl_Digest_AlgorithmHMAC_SHA1,
112
113 rtl_Digest_AlgorithmInvalid,
114 rtl_Digest_Algorithm_FORCE_EQUAL_SIZE
115};
116
119typedef enum __rtl_DigestAlgorithm rtlDigestAlgorithm;
120
121
124enum __rtl_DigestError
125{
126 rtl_Digest_E_None,
127 rtl_Digest_E_Argument,
128 rtl_Digest_E_Algorithm,
129 rtl_Digest_E_BufferSize,
130 rtl_Digest_E_Memory,
131 rtl_Digest_E_Unknown,
132 rtl_Digest_E_FORCE_EQUAL_SIZE
133};
134
137typedef enum __rtl_DigestError rtlDigestError;
138
139typedef rtlDigestError Digest_init_t( void * ctx, const sal_uInt8 * Data, sal_uInt32 DatLen );
140
141typedef void Digest_delete_t( void *ctx );
142
143typedef rtlDigestError Digest_update_t( void * ctx, const void * Data, sal_uInt32 DatLen );
144
145typedef rtlDigestError Digest_get_t( void * ctx, sal_uInt8 * Buffer, sal_uInt32 BufLen );
146
147/*========================================================================
148 *
149 * rtl_digest_SHA1 interface.
150 *
151 *======================================================================*/
152#define RTL_DIGEST_LENGTH_SHA1 20
153
162rtlDigest rtl_digest_createSHA1 (void);
163
164
168void rtl_digest_destroySHA1( rtlDigest Digest );
169
170
174rtlDigestError rtl_digest_updateSHA1( rtlDigest Digest, const void * pData, uint nDatLen );
175
176
180rtlDigestError rtl_digest_getSHA1( rtlDigest Digest, sal_uInt8 * pBuffer, uint nBufLen );
181
182
197rtlDigestError rtl_digest_SHA1( const void * pData, uint nDatLen,
198 unsigned char * pBuffer, uint nBufLen );
199
200
201/*========================================================================
202 *
203 * rtlDigest internals.
204 *
205 *======================================================================*/
206
207void rtl_zeroMemory(void * Ptr, sal_uInt32 Bytes)
208{
209 memset(Ptr, 0, Bytes);
210}
211
212void rtl_copyMemory(void *Dst, const void *Src, sal_uInt32 Bytes)
213{
214 memcpy(Dst, Src, Bytes);
215}
216
217void rtl_freeMemory (void * p)
218{
219 free(p);
220}
221
222void rtl_freeZeroMemory (void * p, sal_uInt32 n)
223{
224 if (p)
225 {
226 memset(p, 0, n);
227 free(p);
228 }
229}
230
231#define RTL_DIGEST_CREATE(T) ((T*)(malloc(sizeof(T))))
232
233#define RTL_DIGEST_ROTL(a,n) (((a) << (n)) | ((a) >> (32 - (n))))
234
235#define RTL_DIGEST_HTONL(l,c) \
236 (*((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff), \
237 *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
238 *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
239 *((c)++) = (sal_uInt8)(((l) ) & 0xff))
240
241#define RTL_DIGEST_LTOC(l,c) \
242 (*((c)++) = (sal_uInt8)(((l) ) & 0xff), \
243 *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
244 *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
245 *((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff))
246
247typedef struct digest_impl_st
248{
249 rtlDigestAlgorithm m_algorithm;
250 sal_uInt32 m_length;
251 Digest_init_t *m_init;
252 Digest_delete_t *m_delete;
253 Digest_update_t *m_update;
254 Digest_get_t *m_get;
255} Digest_Impl;
256
257/*
258 * __rtl_digest_swapLong.
259 */
260static void __rtl_digest_swapLong (sal_uInt32 *pData, sal_uInt32 nDatLen)
261{
262 sal_uInt32 *X;
263 int i, n;
264
265 X = pData;
266 n = nDatLen;
267
268 for (i = 0; i < n; i++)
269 X[i] = OSL_SWAPDWORD(X[i]);
270}
271
272/*========================================================================
273 *
274 * rtlDigest implementation.
275 *
276 *======================================================================*/
277/*
278 * rtl_digest_create.
279
280rtlDigest rtl_digest_create (rtlDigestAlgorithm Algorithm)
281{
282 rtlDigest Digest = (rtlDigest)NULL;
283 switch (Algorithm)
284 {
285 case rtl_Digest_AlgorithmMD2:
286 Digest = rtl_digest_createMD2();
287 break;
288
289 case rtl_Digest_AlgorithmMD5:
290 Digest = rtl_digest_createMD5();
291 break;
292
293 case rtl_Digest_AlgorithmSHA:
294 Digest = rtl_digest_createSHA();
295 break;
296
297 case rtl_Digest_AlgorithmSHA1:
298 Digest = rtl_digest_createSHA1();
299 break;
300
301 case rtl_Digest_AlgorithmHMAC_MD5:
302 Digest = rtl_digest_createHMAC_MD5();
303 break;
304
305 case rtl_Digest_AlgorithmHMAC_SHA1:
306 Digest = rtl_digest_createHMAC_SHA1();
307 break;
308
309 default: // rtl_Digest_AlgorithmInvalid
310 break;
311 }
312 return Digest;
313}
314
315
316// rtl_digest_queryAlgorithm.
317
318rtlDigestAlgorithm rtl_digest_queryAlgorithm (rtlDigest Digest)
319{
320 Digest_Impl *pImpl = (Digest_Impl *)Digest;
321 if (pImpl)
322 return pImpl->m_algorithm;
323 else
324 return rtl_Digest_AlgorithmInvalid;
325}
326
327 // rtl_digest_queryLength.
328sal_uInt32 rtl_digest_queryLength (rtlDigest Digest)
329{
330 Digest_Impl *pImpl = (Digest_Impl *)Digest;
331 if (pImpl)
332 return pImpl->m_length;
333 else
334 return 0;
335}
336
337// * rtl_digest_init.
338rtlDigestError rtl_digest_init (
339 rtlDigest Digest, const sal_uInt8 *pData, sal_uInt32 nDatLen)
340{
341 Digest_Impl *pImpl = (Digest_Impl *)Digest;
342 if (pImpl)
343 {
344 if (pImpl->m_init)
345 return pImpl->m_init (Digest, pData, nDatLen);
346 else
347 return rtl_Digest_E_None;
348 }
349 return rtl_Digest_E_Argument;
350}
351
352// * rtl_digest_update.
353rtlDigestError rtl_digest_update (
354 rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
355{
356 Digest_Impl *pImpl = (Digest_Impl *)Digest;
357 if (pImpl && pImpl->m_update)
358 return pImpl->m_update (Digest, pData, nDatLen);
359 else
360 return rtl_Digest_E_Argument;
361}
362
363// * rtl_digest_get.
364rtlDigestError rtl_digest_get (
365 rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
366{
367 Digest_Impl *pImpl = (Digest_Impl *)Digest;
368 if (pImpl && pImpl->m_get)
369 return pImpl->m_get (Digest, pBuffer, nBufLen);
370 else
371 return rtl_Digest_E_Argument;
372}
373
374// * rtl_digest_destroy.
375void rtl_digest_destroy (rtlDigest Digest)
376{
377 Digest_Impl *pImpl = (Digest_Impl *)Digest;
378 if (pImpl && pImpl->m_delete)
379 pImpl->m_delete (Digest);
380}
381*/
382
383/*========================================================================
384 *
385 * rtl_digest_(SHA|SHA1) common internals.
386 *
387 *======================================================================*/
388#define DIGEST_CBLOCK_SHA 64
389#define DIGEST_LBLOCK_SHA 16
390
391typedef sal_uInt32 DigestSHA_update_t (sal_uInt32 x);
392
393static sal_uInt32 __rtl_digest_updateSHA_1 (sal_uInt32 x);
394
395typedef struct digestSHA_context_st
396{
397 DigestSHA_update_t *m_update;
398 sal_uInt32 m_nDatLen;
399 sal_uInt32 m_pData[DIGEST_LBLOCK_SHA];
400 sal_uInt32 m_nA, m_nB, m_nC, m_nD, m_nE;
401 sal_uInt32 m_nL, m_nH;
402} DigestContextSHA;
403
404typedef struct digestSHA_impl_st
405{
406 Digest_Impl m_digest;
407 DigestContextSHA m_context;
408} DigestSHA_Impl;
409
410static void __rtl_digest_initSHA (
411 DigestContextSHA *ctx, DigestSHA_update_t *fct);
412
413static void __rtl_digest_updateSHA (DigestContextSHA *ctx);
414static void __rtl_digest_endSHA (DigestContextSHA *ctx);
415
416#define K_00_19 (sal_uInt32)0x5a827999L
417#define K_20_39 (sal_uInt32)0x6ed9eba1L
418#define K_40_59 (sal_uInt32)0x8f1bbcdcL
419#define K_60_79 (sal_uInt32)0xca62c1d6L
420
421#define F_00_19(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
422#define F_20_39(b,c,d) ((b) ^ (c) ^ (d))
423#define F_40_59(b,c,d) (((b) & (c)) | ((b) & (d)) | ((c) & (d)))
424#define F_60_79(b,c,d) F_20_39(b,c,d)
425
426#define BODY_X(i) \
427 (X[(i)&0x0f] ^ X[((i)+2)&0x0f] ^ X[((i)+8)&0x0f] ^ X[((i)+13)&0x0f])
428
429#define BODY_00_15(u,i,a,b,c,d,e,f) \
430 (f) = X[i]; \
431 (f) += (e) + K_00_19 + RTL_DIGEST_ROTL((a), 5) + F_00_19((b), (c), (d)); \
432 (b) = RTL_DIGEST_ROTL((b), 30);
433
434#define BODY_16_19(u,i,a,b,c,d,e,f) \
435 (f) = BODY_X((i)); \
436 (f) = X[(i)&0x0f] = (u)((f)); \
437 (f) += (e) + K_00_19 + RTL_DIGEST_ROTL((a), 5) + F_00_19((b), (c), (d)); \
438 (b) = RTL_DIGEST_ROTL((b), 30);
439
440#define BODY_20_39(u,i,a,b,c,d,e,f) \
441 (f) = BODY_X((i)); \
442 (f) = X[(i)&0x0f] = (u)((f)); \
443 (f) += (e) + K_20_39 + RTL_DIGEST_ROTL((a), 5) + F_20_39((b), (c), (d)); \
444 (b) = RTL_DIGEST_ROTL((b), 30);
445
446#define BODY_40_59(u,i,a,b,c,d,e,f) \
447 (f) = BODY_X((i)); \
448 (f) = X[(i)&0x0f] = (u)((f)); \
449 (f) += (e) + K_40_59 + RTL_DIGEST_ROTL((a), 5) + F_40_59((b), (c), (d)); \
450 (b) = RTL_DIGEST_ROTL((b), 30);
451
452#define BODY_60_79(u,i,a,b,c,d,e,f) \
453 (f) = BODY_X((i)); \
454 (f) = X[(i)&0x0f] = (u)((f)); \
455 (f) += (e) + K_60_79 + RTL_DIGEST_ROTL((a), 5) + F_60_79((b), (c), (d)); \
456 (b) = RTL_DIGEST_ROTL((b), 30);
457
458/*
459 * __rtl_digest_initSHA.
460 */
461static void __rtl_digest_initSHA (
462 DigestContextSHA *ctx, DigestSHA_update_t *fct)
463{
464 rtl_zeroMemory (ctx, sizeof (DigestContextSHA));
465 ctx->m_update = fct;
466
467 ctx->m_nA = (sal_uInt32)0x67452301L;
468 ctx->m_nB = (sal_uInt32)0xefcdab89L;
469 ctx->m_nC = (sal_uInt32)0x98badcfeL;
470 ctx->m_nD = (sal_uInt32)0x10325476L;
471 ctx->m_nE = (sal_uInt32)0xc3d2e1f0L;
472}
473
474/*
475 * __rtl_digest_updateSHA.
476 */
477static void __rtl_digest_updateSHA (DigestContextSHA *ctx)
478{
479 sal_uInt32 A, B, C, D, E, T;
480 sal_uInt32 *X;
481
482 DigestSHA_update_t *U;
483 U = ctx->m_update;
484
485 A = ctx->m_nA;
486 B = ctx->m_nB;
487 C = ctx->m_nC;
488 D = ctx->m_nD;
489 E = ctx->m_nE;
490 X = ctx->m_pData;
491
492 BODY_00_15 (U, 0, A, B, C, D, E, T);
493 BODY_00_15 (U, 1, T, A, B, C, D, E);
494 BODY_00_15 (U, 2, E, T, A, B, C, D);
495 BODY_00_15 (U, 3, D, E, T, A, B, C);
496 BODY_00_15 (U, 4, C, D, E, T, A, B);
497 BODY_00_15 (U, 5, B, C, D, E, T, A);
498 BODY_00_15 (U, 6, A, B, C, D, E, T);
499 BODY_00_15 (U, 7, T, A, B, C, D, E);
500 BODY_00_15 (U, 8, E, T, A, B, C, D);
501 BODY_00_15 (U, 9, D, E, T, A, B, C);
502 BODY_00_15 (U, 10, C, D, E, T, A, B);
503 BODY_00_15 (U, 11, B, C, D, E, T, A);
504 BODY_00_15 (U, 12, A, B, C, D, E, T);
505 BODY_00_15 (U, 13, T, A, B, C, D, E);
506 BODY_00_15 (U, 14, E, T, A, B, C, D);
507 BODY_00_15 (U, 15, D, E, T, A, B, C);
508 BODY_16_19 (U, 16, C, D, E, T, A, B);
509 BODY_16_19 (U, 17, B, C, D, E, T, A);
510 BODY_16_19 (U, 18, A, B, C, D, E, T);
511 BODY_16_19 (U, 19, T, A, B, C, D, E);
512
513 BODY_20_39 (U, 20, E, T, A, B, C, D);
514 BODY_20_39 (U, 21, D, E, T, A, B, C);
515 BODY_20_39 (U, 22, C, D, E, T, A, B);
516 BODY_20_39 (U, 23, B, C, D, E, T, A);
517 BODY_20_39 (U, 24, A, B, C, D, E, T);
518 BODY_20_39 (U, 25, T, A, B, C, D, E);
519 BODY_20_39 (U, 26, E, T, A, B, C, D);
520 BODY_20_39 (U, 27, D, E, T, A, B, C);
521 BODY_20_39 (U, 28, C, D, E, T, A, B);
522 BODY_20_39 (U, 29, B, C, D, E, T, A);
523 BODY_20_39 (U, 30, A, B, C, D, E, T);
524 BODY_20_39 (U, 31, T, A, B, C, D, E);
525 BODY_20_39 (U, 32, E, T, A, B, C, D);
526 BODY_20_39 (U, 33, D, E, T, A, B, C);
527 BODY_20_39 (U, 34, C, D, E, T, A, B);
528 BODY_20_39 (U, 35, B, C, D, E, T, A);
529 BODY_20_39 (U, 36, A, B, C, D, E, T);
530 BODY_20_39 (U, 37, T, A, B, C, D, E);
531 BODY_20_39 (U, 38, E, T, A, B, C, D);
532 BODY_20_39 (U, 39, D, E, T, A, B, C);
533
534 BODY_40_59 (U, 40, C, D, E, T, A, B);
535 BODY_40_59 (U, 41, B, C, D, E, T, A);
536 BODY_40_59 (U, 42, A, B, C, D, E, T);
537 BODY_40_59 (U, 43, T, A, B, C, D, E);
538 BODY_40_59 (U, 44, E, T, A, B, C, D);
539 BODY_40_59 (U, 45, D, E, T, A, B, C);
540 BODY_40_59 (U, 46, C, D, E, T, A, B);
541 BODY_40_59 (U, 47, B, C, D, E, T, A);
542 BODY_40_59 (U, 48, A, B, C, D, E, T);
543 BODY_40_59 (U, 49, T, A, B, C, D, E);
544 BODY_40_59 (U, 50, E, T, A, B, C, D);
545 BODY_40_59 (U, 51, D, E, T, A, B, C);
546 BODY_40_59 (U, 52, C, D, E, T, A, B);
547 BODY_40_59 (U, 53, B, C, D, E, T, A);
548 BODY_40_59 (U, 54, A, B, C, D, E, T);
549 BODY_40_59 (U, 55, T, A, B, C, D, E);
550 BODY_40_59 (U, 56, E, T, A, B, C, D);
551 BODY_40_59 (U, 57, D, E, T, A, B, C);
552 BODY_40_59 (U, 58, C, D, E, T, A, B);
553 BODY_40_59 (U, 59, B, C, D, E, T, A);
554
555 BODY_60_79 (U, 60, A, B, C, D, E, T);
556 BODY_60_79 (U, 61, T, A, B, C, D, E);
557 BODY_60_79 (U, 62, E, T, A, B, C, D);
558 BODY_60_79 (U, 63, D, E, T, A, B, C);
559 BODY_60_79 (U, 64, C, D, E, T, A, B);
560 BODY_60_79 (U, 65, B, C, D, E, T, A);
561 BODY_60_79 (U, 66, A, B, C, D, E, T);
562 BODY_60_79 (U, 67, T, A, B, C, D, E);
563 BODY_60_79 (U, 68, E, T, A, B, C, D);
564 BODY_60_79 (U, 69, D, E, T, A, B, C);
565 BODY_60_79 (U, 70, C, D, E, T, A, B);
566 BODY_60_79 (U, 71, B, C, D, E, T, A);
567 BODY_60_79 (U, 72, A, B, C, D, E, T);
568 BODY_60_79 (U, 73, T, A, B, C, D, E);
569 BODY_60_79 (U, 74, E, T, A, B, C, D);
570 BODY_60_79 (U, 75, D, E, T, A, B, C);
571 BODY_60_79 (U, 76, C, D, E, T, A, B);
572 BODY_60_79 (U, 77, B, C, D, E, T, A);
573 BODY_60_79 (U, 78, A, B, C, D, E, T);
574 BODY_60_79 (U, 79, T, A, B, C, D, E);
575
576 ctx->m_nA += E;
577 ctx->m_nB += T;
578 ctx->m_nC += A;
579 ctx->m_nD += B;
580 ctx->m_nE += C;
581}
582
583/*
584 * __rtl_digest_endSHA.
585 */
586static void __rtl_digest_endSHA (DigestContextSHA *ctx)
587{
588 static const sal_uInt8 end[4] =
589 {
590 0x80, 0x00, 0x00, 0x00
591 };
592 const sal_uInt8 *p = end;
593
594 sal_uInt32 *X;
595 int i;
596
597 X = ctx->m_pData;
598 i = (ctx->m_nDatLen >> 2);
599
600#ifdef WORDS_BIGENDIAN
601 __rtl_digest_swapLong (X, i + 1);
602#endif
603
604 switch (ctx->m_nDatLen & 0x03)
605 {
606 case 1: X[i] &= 0x000000ff; break;
607 case 2: X[i] &= 0x0000ffff; break;
608 case 3: X[i] &= 0x00ffffff; break;
609 }
610
611 switch (ctx->m_nDatLen & 0x03)
612 {
613 case 0: X[i] = ((sal_uInt32)(*(p++))) << 0L;
614 case 1: X[i] |= ((sal_uInt32)(*(p++))) << 8L;
615 case 2: X[i] |= ((sal_uInt32)(*(p++))) << 16L;
616 case 3: X[i] |= ((sal_uInt32)(*(p++))) << 24L;
617 }
618
619 __rtl_digest_swapLong (X, i + 1);
620
621 i += 1;
622
623 if (i >= (DIGEST_LBLOCK_SHA - 2))
624 {
625 for (; i < DIGEST_LBLOCK_SHA; i++)
626 X[i] = 0;
627 __rtl_digest_updateSHA (ctx);
628 i = 0;
629 }
630
631 for (; i < (DIGEST_LBLOCK_SHA - 2); i++)
632 X[i] = 0;
633
634 X[DIGEST_LBLOCK_SHA - 2] = ctx->m_nH;
635 X[DIGEST_LBLOCK_SHA - 1] = ctx->m_nL;
636
637 __rtl_digest_updateSHA (ctx);
638}
639
640/*========================================================================
641 *
642 * rtl_digest_SHA1 internals.
643 *
644 *======================================================================*/
645/*
646 * __rtl_digest_SHA_1.
647 */
648static const Digest_Impl __rtl_digest_SHA_1 = { rtl_Digest_AlgorithmSHA1,
649 RTL_DIGEST_LENGTH_SHA1,
650 0,
651 rtl_digest_destroySHA1,
652 rtl_digest_updateSHA1,
653 rtl_digest_getSHA1
654};
655
656/*
657 * __rtl_digest_updateSHA_1.
658 */
659static sal_uInt32 __rtl_digest_updateSHA_1 (sal_uInt32 x)
660{
661 return RTL_DIGEST_ROTL (x, 1);
662}
663
664/*========================================================================
665 *
666 * rtl_digest_SHA1 implementation.
667 *
668 *======================================================================*/
669/*
670 * rtl_digest_SHA1.
671 */
672rtlDigestError rtl_digest_SHA1 (
673 const void *pData, sal_uInt32 nDatLen,
674 sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
675{
676 DigestSHA_Impl digest;
677 rtlDigestError result;
678
679 digest.m_digest = __rtl_digest_SHA_1;
680 __rtl_digest_initSHA (&(digest.m_context), __rtl_digest_updateSHA_1);
681
682 result = rtl_digest_updateSHA1 (&digest, pData, nDatLen);
683 if (result == rtl_Digest_E_None)
684 result = rtl_digest_getSHA1 (&digest, pBuffer, nBufLen);
685
686 rtl_zeroMemory (&digest, sizeof (digest));
687 return (result);
688}
689
690/*
691 * rtl_digest_createSHA1.
692 */
693rtlDigest rtl_digest_createSHA1 (void)
694{
695 DigestSHA_Impl *pImpl = (DigestSHA_Impl*)NULL;
696 pImpl = RTL_DIGEST_CREATE(DigestSHA_Impl);
697 if (pImpl)
698 {
699 pImpl->m_digest = __rtl_digest_SHA_1;
700 __rtl_digest_initSHA (&(pImpl->m_context), __rtl_digest_updateSHA_1);
701 }
702 return ((rtlDigest)pImpl);
703}
704
705/*
706 * rtl_digest_updateSHA1.
707 */
708rtlDigestError rtl_digest_updateSHA1 (
709 rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
710{
711 DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
712 const sal_uInt8 *d = (const sal_uInt8 *)pData;
713
714 DigestContextSHA *ctx;
715 sal_uInt32 len;
716
717 if ((pImpl == NULL) || (pData == NULL))
718 return rtl_Digest_E_Argument;
719
720 if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1))
721 return rtl_Digest_E_Algorithm;
722
723 if (nDatLen == 0)
724 return rtl_Digest_E_None;
725
726 ctx = &(pImpl->m_context);
727
728 len = ctx->m_nL + (nDatLen << 3);
729 if (len < ctx->m_nL) ctx->m_nH += 1;
730 ctx->m_nH += (nDatLen >> 29);
731 ctx->m_nL = len;
732
733 if (ctx->m_nDatLen)
734 {
735 sal_uInt8 *p = (sal_uInt8 *)(ctx->m_pData) + ctx->m_nDatLen;
736 sal_uInt32 n = DIGEST_CBLOCK_SHA - ctx->m_nDatLen;
737
738 if (nDatLen < n)
739 {
740 rtl_copyMemory (p, d, nDatLen);
741 ctx->m_nDatLen += nDatLen;
742
743 return rtl_Digest_E_None;
744 }
745
746 rtl_copyMemory (p, d, n);
747 d += n;
748 nDatLen -= n;
749
750#ifndef WORDS_BIGENDIAN
751 __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
752#endif
753
754 __rtl_digest_updateSHA (ctx);
755 ctx->m_nDatLen = 0;
756 }
757
758 while (nDatLen >= DIGEST_CBLOCK_SHA)
759 {
760 rtl_copyMemory (ctx->m_pData, d, DIGEST_CBLOCK_SHA);
761 d += DIGEST_CBLOCK_SHA;
762 nDatLen -= DIGEST_CBLOCK_SHA;
763
764#ifndef WORDS_BIGENDIAN
765 __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
766#endif
767
768 __rtl_digest_updateSHA (ctx);
769 }
770
771 rtl_copyMemory (ctx->m_pData, d, nDatLen);
772 ctx->m_nDatLen = nDatLen;
773
774 return rtl_Digest_E_None;
775}
776
777/*
778 * rtl_digest_getSHA1.
779 */
780rtlDigestError rtl_digest_getSHA1 (
781 rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
782{
783 DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
784 sal_uInt8 *p = pBuffer;
785
786 DigestContextSHA *ctx;
787
788 if ((pImpl == NULL) || (pBuffer == NULL))
789 return rtl_Digest_E_Argument;
790
791 if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1))
792 return rtl_Digest_E_Algorithm;
793
794 if (!(pImpl->m_digest.m_length <= nBufLen))
795 return rtl_Digest_E_BufferSize;
796
797 ctx = &(pImpl->m_context);
798
799 __rtl_digest_endSHA (ctx);
800 RTL_DIGEST_HTONL (ctx->m_nA, p);
801 RTL_DIGEST_HTONL (ctx->m_nB, p);
802 RTL_DIGEST_HTONL (ctx->m_nC, p);
803 RTL_DIGEST_HTONL (ctx->m_nD, p);
804 RTL_DIGEST_HTONL (ctx->m_nE, p);
805 __rtl_digest_initSHA (ctx, __rtl_digest_updateSHA_1);
806
807 return rtl_Digest_E_None;
808}
809
810/*
811 * rtl_digest_destroySHA1.
812 */
813void rtl_digest_destroySHA1 (rtlDigest Digest)
814{
815 DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
816 if (pImpl)
817 {
818 if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1)
819 rtl_freeZeroMemory (pImpl, sizeof (DigestSHA_Impl));
820 else
821 rtl_freeMemory (pImpl);
822 }
823}
824
825/*========================================================================
826 *
827 * The End.
828 *
829 *======================================================================*/
830
831bool SHA1::getHash( TQString const & text, TQCString & hash )
832{
833 rtlDigest aDigest = rtl_digest_createSHA1();
834 rtlDigestError aError = rtl_digest_updateSHA1( aDigest, text.unicode(), text.length() * sizeof(TQChar) );
835
836 if ( aError == rtl_Digest_E_None )
837 {
838 TQCString digest;
839 digest.resize( RTL_DIGEST_LENGTH_SHA1 + 1 );
840 digest.fill( '\0', RTL_DIGEST_LENGTH_SHA1 );
841
842 aError = rtl_digest_getSHA1( aDigest, (unsigned char *) digest.data(), RTL_DIGEST_LENGTH_SHA1 );
843
844 if (aError != rtl_Digest_E_None)
845 return false;
846
847 hash = digest;
848
849 return true;
850 }
851
852 return false;
853}