00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040 #include <stdlib.h>
00041 #include <string.h>
00042
00043 #include "../config.h"
00044 #include "digest.h"
00045 #include <kdebug.h>
00046 #include <kmdcodec.h>
00047
00048 typedef unsigned char sal_uInt8;
00049 typedef unsigned short sal_uInt16;
00050
00051 #if SIZEOF_INT == 4
00052 typedef unsigned int sal_uInt32;
00053 #elif
00054 typedef unsigned long sal_uInt32;
00055 #endif
00056
00057 void rtl_freeZeroMemory(void * p, sal_uInt32 n);
00058 void rtl_freeMemory(void * p);
00059 void rtl_zeroMemory(void * Ptr, sal_uInt32 Bytes);
00060 void rtl_copyMemory(void *Dst, const void *Src, sal_uInt32 Bytes);
00061
00062 #ifndef OSL_LOBYTE
00063 # define OSL_LOBYTE(w) ((sal_uInt8)((sal_uInt16)(w) & 0xFF))
00064 #endif
00065 #ifndef OSL_HIBYTE
00066 # define OSL_HIBYTE(w) ((sal_uInt8)(((sal_uInt16)(w) >> 8) & 0xFF))
00067 #endif
00068 #ifndef OSL_MAKEWORD
00069 # define OSL_MAKEWORD(bl, bh) ((sal_uInt16)((bl) & 0xFF) | (((sal_uInt16)(bh) & 0xFF) << 8))
00070 #endif
00071 #ifndef OSL_MAKEDWORD
00072 # define OSL_MAKEDWORD(wl, wh) ((sal_uInt32)((wl) & 0xFFFF) | (((sal_uInt32)(wh) & 0xFFFF) << 16))
00073 #endif
00074 #ifndef OSL_LOWORD
00075 # define OSL_LOWORD(d) ((sal_uInt16)((sal_uInt32)(d) & 0xFFFF))
00076 #endif
00077 #ifndef OSL_HIWORD
00078 # define OSL_HIWORD(d) ((sal_uInt16)(((sal_uInt32)(d) >> 16) & 0xFFFF))
00079 #endif
00080
00083 #ifndef OSL_SWAPWORD
00084 # define OSL_SWAPWORD(w) OSL_MAKEWORD(OSL_HIBYTE(w),OSL_LOBYTE(w))
00085 #endif
00086 #ifndef OSL_SWAPDWORD
00087 # define OSL_SWAPDWORD(d) OSL_MAKEDWORD(OSL_SWAPWORD(OSL_HIWORD(d)),OSL_SWAPWORD(OSL_LOWORD(d)))
00088 #endif
00089
00090
00091
00092
00093
00094
00095
00098 typedef void* rtlDigest;
00099
00103 enum __rtl_DigestAlgorithm
00104 {
00105 rtl_Digest_AlgorithmMD2,
00106 rtl_Digest_AlgorithmMD5,
00107 rtl_Digest_AlgorithmSHA,
00108 rtl_Digest_AlgorithmSHA1,
00109
00110 rtl_Digest_AlgorithmHMAC_MD5,
00111 rtl_Digest_AlgorithmHMAC_SHA1,
00112
00113 rtl_Digest_AlgorithmInvalid,
00114 rtl_Digest_Algorithm_FORCE_EQUAL_SIZE
00115 };
00116
00119 typedef enum __rtl_DigestAlgorithm rtlDigestAlgorithm;
00120
00121
00124 enum __rtl_DigestError
00125 {
00126 rtl_Digest_E_None,
00127 rtl_Digest_E_Argument,
00128 rtl_Digest_E_Algorithm,
00129 rtl_Digest_E_BufferSize,
00130 rtl_Digest_E_Memory,
00131 rtl_Digest_E_Unknown,
00132 rtl_Digest_E_FORCE_EQUAL_SIZE
00133 };
00134
00137 typedef enum __rtl_DigestError rtlDigestError;
00138
00139 typedef rtlDigestError Digest_init_t( void * ctx, const sal_uInt8 * Data, sal_uInt32 DatLen );
00140
00141 typedef void Digest_delete_t( void *ctx );
00142
00143 typedef rtlDigestError Digest_update_t( void * ctx, const void * Data, sal_uInt32 DatLen );
00144
00145 typedef rtlDigestError Digest_get_t( void * ctx, sal_uInt8 * Buffer, sal_uInt32 BufLen );
00146
00147
00148
00149
00150
00151
00152 #define RTL_DIGEST_LENGTH_SHA1 20
00153
00162 rtlDigest rtl_digest_createSHA1 (void);
00163
00164
00168 void rtl_digest_destroySHA1( rtlDigest Digest );
00169
00170
00174 rtlDigestError rtl_digest_updateSHA1( rtlDigest Digest, const void * pData, uint nDatLen );
00175
00176
00180 rtlDigestError rtl_digest_getSHA1( rtlDigest Digest, sal_uInt8 * pBuffer, uint nBufLen );
00181
00182
00197 rtlDigestError rtl_digest_SHA1( const void * pData, uint nDatLen,
00198 unsigned char * pBuffer, uint nBufLen );
00199
00200
00201
00202
00203
00204
00205
00206
00207 void rtl_zeroMemory(void * Ptr, sal_uInt32 Bytes)
00208 {
00209 memset(Ptr, 0, Bytes);
00210 }
00211
00212 void rtl_copyMemory(void *Dst, const void *Src, sal_uInt32 Bytes)
00213 {
00214 memcpy(Dst, Src, Bytes);
00215 }
00216
00217 void rtl_freeMemory (void * p)
00218 {
00219 free(p);
00220 }
00221
00222 void rtl_freeZeroMemory (void * p, sal_uInt32 n)
00223 {
00224 if (p)
00225 {
00226 memset(p, 0, n);
00227 free(p);
00228 }
00229 }
00230
00231 #define RTL_DIGEST_CREATE(T) ((T*)(malloc(sizeof(T))))
00232
00233 #define RTL_DIGEST_ROTL(a,n) (((a) << (n)) | ((a) >> (32 - (n))))
00234
00235 #define RTL_DIGEST_HTONL(l,c) \
00236 (*((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff), \
00237 *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
00238 *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
00239 *((c)++) = (sal_uInt8)(((l) ) & 0xff))
00240
00241 #define RTL_DIGEST_LTOC(l,c) \
00242 (*((c)++) = (sal_uInt8)(((l) ) & 0xff), \
00243 *((c)++) = (sal_uInt8)(((l) >> 8L) & 0xff), \
00244 *((c)++) = (sal_uInt8)(((l) >> 16L) & 0xff), \
00245 *((c)++) = (sal_uInt8)(((l) >> 24L) & 0xff))
00246
00247 typedef struct digest_impl_st
00248 {
00249 rtlDigestAlgorithm m_algorithm;
00250 sal_uInt32 m_length;
00251 Digest_init_t *m_init;
00252 Digest_delete_t *m_delete;
00253 Digest_update_t *m_update;
00254 Digest_get_t *m_get;
00255 } Digest_Impl;
00256
00257
00258
00259
00260 static void __rtl_digest_swapLong (sal_uInt32 *pData, sal_uInt32 nDatLen)
00261 {
00262 register sal_uInt32 *X;
00263 register int i, n;
00264
00265 X = pData;
00266 n = nDatLen;
00267
00268 for (i = 0; i < n; i++)
00269 X[i] = OSL_SWAPDWORD(X[i]);
00270 }
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388 #define DIGEST_CBLOCK_SHA 64
00389 #define DIGEST_LBLOCK_SHA 16
00390
00391 typedef sal_uInt32 DigestSHA_update_t (sal_uInt32 x);
00392
00393 static sal_uInt32 __rtl_digest_updateSHA_1 (sal_uInt32 x);
00394
00395 typedef struct digestSHA_context_st
00396 {
00397 DigestSHA_update_t *m_update;
00398 sal_uInt32 m_nDatLen;
00399 sal_uInt32 m_pData[DIGEST_LBLOCK_SHA];
00400 sal_uInt32 m_nA, m_nB, m_nC, m_nD, m_nE;
00401 sal_uInt32 m_nL, m_nH;
00402 } DigestContextSHA;
00403
00404 typedef struct digestSHA_impl_st
00405 {
00406 Digest_Impl m_digest;
00407 DigestContextSHA m_context;
00408 } DigestSHA_Impl;
00409
00410 static void __rtl_digest_initSHA (
00411 DigestContextSHA *ctx, DigestSHA_update_t *fct);
00412
00413 static void __rtl_digest_updateSHA (DigestContextSHA *ctx);
00414 static void __rtl_digest_endSHA (DigestContextSHA *ctx);
00415
00416 #define K_00_19 (sal_uInt32)0x5a827999L
00417 #define K_20_39 (sal_uInt32)0x6ed9eba1L
00418 #define K_40_59 (sal_uInt32)0x8f1bbcdcL
00419 #define K_60_79 (sal_uInt32)0xca62c1d6L
00420
00421 #define F_00_19(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
00422 #define F_20_39(b,c,d) ((b) ^ (c) ^ (d))
00423 #define F_40_59(b,c,d) (((b) & (c)) | ((b) & (d)) | ((c) & (d)))
00424 #define F_60_79(b,c,d) F_20_39(b,c,d)
00425
00426 #define BODY_X(i) \
00427 (X[(i)&0x0f] ^ X[((i)+2)&0x0f] ^ X[((i)+8)&0x0f] ^ X[((i)+13)&0x0f])
00428
00429 #define BODY_00_15(u,i,a,b,c,d,e,f) \
00430 (f) = X[i]; \
00431 (f) += (e) + K_00_19 + RTL_DIGEST_ROTL((a), 5) + F_00_19((b), (c), (d)); \
00432 (b) = RTL_DIGEST_ROTL((b), 30);
00433
00434 #define BODY_16_19(u,i,a,b,c,d,e,f) \
00435 (f) = BODY_X((i)); \
00436 (f) = X[(i)&0x0f] = (u)((f)); \
00437 (f) += (e) + K_00_19 + RTL_DIGEST_ROTL((a), 5) + F_00_19((b), (c), (d)); \
00438 (b) = RTL_DIGEST_ROTL((b), 30);
00439
00440 #define BODY_20_39(u,i,a,b,c,d,e,f) \
00441 (f) = BODY_X((i)); \
00442 (f) = X[(i)&0x0f] = (u)((f)); \
00443 (f) += (e) + K_20_39 + RTL_DIGEST_ROTL((a), 5) + F_20_39((b), (c), (d)); \
00444 (b) = RTL_DIGEST_ROTL((b), 30);
00445
00446 #define BODY_40_59(u,i,a,b,c,d,e,f) \
00447 (f) = BODY_X((i)); \
00448 (f) = X[(i)&0x0f] = (u)((f)); \
00449 (f) += (e) + K_40_59 + RTL_DIGEST_ROTL((a), 5) + F_40_59((b), (c), (d)); \
00450 (b) = RTL_DIGEST_ROTL((b), 30);
00451
00452 #define BODY_60_79(u,i,a,b,c,d,e,f) \
00453 (f) = BODY_X((i)); \
00454 (f) = X[(i)&0x0f] = (u)((f)); \
00455 (f) += (e) + K_60_79 + RTL_DIGEST_ROTL((a), 5) + F_60_79((b), (c), (d)); \
00456 (b) = RTL_DIGEST_ROTL((b), 30);
00457
00458
00459
00460
00461 static void __rtl_digest_initSHA (
00462 DigestContextSHA *ctx, DigestSHA_update_t *fct)
00463 {
00464 rtl_zeroMemory (ctx, sizeof (DigestContextSHA));
00465 ctx->m_update = fct;
00466
00467 ctx->m_nA = (sal_uInt32)0x67452301L;
00468 ctx->m_nB = (sal_uInt32)0xefcdab89L;
00469 ctx->m_nC = (sal_uInt32)0x98badcfeL;
00470 ctx->m_nD = (sal_uInt32)0x10325476L;
00471 ctx->m_nE = (sal_uInt32)0xc3d2e1f0L;
00472 }
00473
00474
00475
00476
00477 static void __rtl_digest_updateSHA (DigestContextSHA *ctx)
00478 {
00479 register sal_uInt32 A, B, C, D, E, T;
00480 register sal_uInt32 *X;
00481
00482 register DigestSHA_update_t *U;
00483 U = ctx->m_update;
00484
00485 A = ctx->m_nA;
00486 B = ctx->m_nB;
00487 C = ctx->m_nC;
00488 D = ctx->m_nD;
00489 E = ctx->m_nE;
00490 X = ctx->m_pData;
00491
00492 BODY_00_15 (U, 0, A, B, C, D, E, T);
00493 BODY_00_15 (U, 1, T, A, B, C, D, E);
00494 BODY_00_15 (U, 2, E, T, A, B, C, D);
00495 BODY_00_15 (U, 3, D, E, T, A, B, C);
00496 BODY_00_15 (U, 4, C, D, E, T, A, B);
00497 BODY_00_15 (U, 5, B, C, D, E, T, A);
00498 BODY_00_15 (U, 6, A, B, C, D, E, T);
00499 BODY_00_15 (U, 7, T, A, B, C, D, E);
00500 BODY_00_15 (U, 8, E, T, A, B, C, D);
00501 BODY_00_15 (U, 9, D, E, T, A, B, C);
00502 BODY_00_15 (U, 10, C, D, E, T, A, B);
00503 BODY_00_15 (U, 11, B, C, D, E, T, A);
00504 BODY_00_15 (U, 12, A, B, C, D, E, T);
00505 BODY_00_15 (U, 13, T, A, B, C, D, E);
00506 BODY_00_15 (U, 14, E, T, A, B, C, D);
00507 BODY_00_15 (U, 15, D, E, T, A, B, C);
00508 BODY_16_19 (U, 16, C, D, E, T, A, B);
00509 BODY_16_19 (U, 17, B, C, D, E, T, A);
00510 BODY_16_19 (U, 18, A, B, C, D, E, T);
00511 BODY_16_19 (U, 19, T, A, B, C, D, E);
00512
00513 BODY_20_39 (U, 20, E, T, A, B, C, D);
00514 BODY_20_39 (U, 21, D, E, T, A, B, C);
00515 BODY_20_39 (U, 22, C, D, E, T, A, B);
00516 BODY_20_39 (U, 23, B, C, D, E, T, A);
00517 BODY_20_39 (U, 24, A, B, C, D, E, T);
00518 BODY_20_39 (U, 25, T, A, B, C, D, E);
00519 BODY_20_39 (U, 26, E, T, A, B, C, D);
00520 BODY_20_39 (U, 27, D, E, T, A, B, C);
00521 BODY_20_39 (U, 28, C, D, E, T, A, B);
00522 BODY_20_39 (U, 29, B, C, D, E, T, A);
00523 BODY_20_39 (U, 30, A, B, C, D, E, T);
00524 BODY_20_39 (U, 31, T, A, B, C, D, E);
00525 BODY_20_39 (U, 32, E, T, A, B, C, D);
00526 BODY_20_39 (U, 33, D, E, T, A, B, C);
00527 BODY_20_39 (U, 34, C, D, E, T, A, B);
00528 BODY_20_39 (U, 35, B, C, D, E, T, A);
00529 BODY_20_39 (U, 36, A, B, C, D, E, T);
00530 BODY_20_39 (U, 37, T, A, B, C, D, E);
00531 BODY_20_39 (U, 38, E, T, A, B, C, D);
00532 BODY_20_39 (U, 39, D, E, T, A, B, C);
00533
00534 BODY_40_59 (U, 40, C, D, E, T, A, B);
00535 BODY_40_59 (U, 41, B, C, D, E, T, A);
00536 BODY_40_59 (U, 42, A, B, C, D, E, T);
00537 BODY_40_59 (U, 43, T, A, B, C, D, E);
00538 BODY_40_59 (U, 44, E, T, A, B, C, D);
00539 BODY_40_59 (U, 45, D, E, T, A, B, C);
00540 BODY_40_59 (U, 46, C, D, E, T, A, B);
00541 BODY_40_59 (U, 47, B, C, D, E, T, A);
00542 BODY_40_59 (U, 48, A, B, C, D, E, T);
00543 BODY_40_59 (U, 49, T, A, B, C, D, E);
00544 BODY_40_59 (U, 50, E, T, A, B, C, D);
00545 BODY_40_59 (U, 51, D, E, T, A, B, C);
00546 BODY_40_59 (U, 52, C, D, E, T, A, B);
00547 BODY_40_59 (U, 53, B, C, D, E, T, A);
00548 BODY_40_59 (U, 54, A, B, C, D, E, T);
00549 BODY_40_59 (U, 55, T, A, B, C, D, E);
00550 BODY_40_59 (U, 56, E, T, A, B, C, D);
00551 BODY_40_59 (U, 57, D, E, T, A, B, C);
00552 BODY_40_59 (U, 58, C, D, E, T, A, B);
00553 BODY_40_59 (U, 59, B, C, D, E, T, A);
00554
00555 BODY_60_79 (U, 60, A, B, C, D, E, T);
00556 BODY_60_79 (U, 61, T, A, B, C, D, E);
00557 BODY_60_79 (U, 62, E, T, A, B, C, D);
00558 BODY_60_79 (U, 63, D, E, T, A, B, C);
00559 BODY_60_79 (U, 64, C, D, E, T, A, B);
00560 BODY_60_79 (U, 65, B, C, D, E, T, A);
00561 BODY_60_79 (U, 66, A, B, C, D, E, T);
00562 BODY_60_79 (U, 67, T, A, B, C, D, E);
00563 BODY_60_79 (U, 68, E, T, A, B, C, D);
00564 BODY_60_79 (U, 69, D, E, T, A, B, C);
00565 BODY_60_79 (U, 70, C, D, E, T, A, B);
00566 BODY_60_79 (U, 71, B, C, D, E, T, A);
00567 BODY_60_79 (U, 72, A, B, C, D, E, T);
00568 BODY_60_79 (U, 73, T, A, B, C, D, E);
00569 BODY_60_79 (U, 74, E, T, A, B, C, D);
00570 BODY_60_79 (U, 75, D, E, T, A, B, C);
00571 BODY_60_79 (U, 76, C, D, E, T, A, B);
00572 BODY_60_79 (U, 77, B, C, D, E, T, A);
00573 BODY_60_79 (U, 78, A, B, C, D, E, T);
00574 BODY_60_79 (U, 79, T, A, B, C, D, E);
00575
00576 ctx->m_nA += E;
00577 ctx->m_nB += T;
00578 ctx->m_nC += A;
00579 ctx->m_nD += B;
00580 ctx->m_nE += C;
00581 }
00582
00583
00584
00585
00586 static void __rtl_digest_endSHA (DigestContextSHA *ctx)
00587 {
00588 static const sal_uInt8 end[4] =
00589 {
00590 0x80, 0x00, 0x00, 0x00
00591 };
00592 register const sal_uInt8 *p = end;
00593
00594 register sal_uInt32 *X;
00595 register int i;
00596
00597 X = ctx->m_pData;
00598 i = (ctx->m_nDatLen >> 2);
00599
00600 #ifdef WORDS_BIGENDIAN
00601 __rtl_digest_swapLong (X, i + 1);
00602 #endif
00603
00604 switch (ctx->m_nDatLen & 0x03)
00605 {
00606 case 1: X[i] &= 0x000000ff; break;
00607 case 2: X[i] &= 0x0000ffff; break;
00608 case 3: X[i] &= 0x00ffffff; break;
00609 }
00610
00611 switch (ctx->m_nDatLen & 0x03)
00612 {
00613 case 0: X[i] = ((sal_uInt32)(*(p++))) << 0L;
00614 case 1: X[i] |= ((sal_uInt32)(*(p++))) << 8L;
00615 case 2: X[i] |= ((sal_uInt32)(*(p++))) << 16L;
00616 case 3: X[i] |= ((sal_uInt32)(*(p++))) << 24L;
00617 }
00618
00619 __rtl_digest_swapLong (X, i + 1);
00620
00621 i += 1;
00622
00623 if (i >= (DIGEST_LBLOCK_SHA - 2))
00624 {
00625 for (; i < DIGEST_LBLOCK_SHA; i++)
00626 X[i] = 0;
00627 __rtl_digest_updateSHA (ctx);
00628 i = 0;
00629 }
00630
00631 for (; i < (DIGEST_LBLOCK_SHA - 2); i++)
00632 X[i] = 0;
00633
00634 X[DIGEST_LBLOCK_SHA - 2] = ctx->m_nH;
00635 X[DIGEST_LBLOCK_SHA - 1] = ctx->m_nL;
00636
00637 __rtl_digest_updateSHA (ctx);
00638 }
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648 static const Digest_Impl __rtl_digest_SHA_1 = { rtl_Digest_AlgorithmSHA1,
00649 RTL_DIGEST_LENGTH_SHA1,
00650 0,
00651 rtl_digest_destroySHA1,
00652 rtl_digest_updateSHA1,
00653 rtl_digest_getSHA1
00654 };
00655
00656
00657
00658
00659 static sal_uInt32 __rtl_digest_updateSHA_1 (sal_uInt32 x)
00660 {
00661 return RTL_DIGEST_ROTL (x, 1);
00662 }
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672 rtlDigestError rtl_digest_SHA1 (
00673 const void *pData, sal_uInt32 nDatLen,
00674 sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
00675 {
00676 DigestSHA_Impl digest;
00677 rtlDigestError result;
00678
00679 digest.m_digest = __rtl_digest_SHA_1;
00680 __rtl_digest_initSHA (&(digest.m_context), __rtl_digest_updateSHA_1);
00681
00682 result = rtl_digest_updateSHA1 (&digest, pData, nDatLen);
00683 if (result == rtl_Digest_E_None)
00684 result = rtl_digest_getSHA1 (&digest, pBuffer, nBufLen);
00685
00686 rtl_zeroMemory (&digest, sizeof (digest));
00687 return (result);
00688 }
00689
00690
00691
00692
00693 rtlDigest rtl_digest_createSHA1 (void)
00694 {
00695 DigestSHA_Impl *pImpl = (DigestSHA_Impl*)NULL;
00696 pImpl = RTL_DIGEST_CREATE(DigestSHA_Impl);
00697 if (pImpl)
00698 {
00699 pImpl->m_digest = __rtl_digest_SHA_1;
00700 __rtl_digest_initSHA (&(pImpl->m_context), __rtl_digest_updateSHA_1);
00701 }
00702 return ((rtlDigest)pImpl);
00703 }
00704
00705
00706
00707
00708 rtlDigestError rtl_digest_updateSHA1 (
00709 rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
00710 {
00711 DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
00712 const sal_uInt8 *d = (const sal_uInt8 *)pData;
00713
00714 DigestContextSHA *ctx;
00715 sal_uInt32 len;
00716
00717 if ((pImpl == NULL) || (pData == NULL))
00718 return rtl_Digest_E_Argument;
00719
00720 if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1))
00721 return rtl_Digest_E_Algorithm;
00722
00723 if (nDatLen == 0)
00724 return rtl_Digest_E_None;
00725
00726 ctx = &(pImpl->m_context);
00727
00728 len = ctx->m_nL + (nDatLen << 3);
00729 if (len < ctx->m_nL) ctx->m_nH += 1;
00730 ctx->m_nH += (nDatLen >> 29);
00731 ctx->m_nL = len;
00732
00733 if (ctx->m_nDatLen)
00734 {
00735 sal_uInt8 *p = (sal_uInt8 *)(ctx->m_pData) + ctx->m_nDatLen;
00736 sal_uInt32 n = DIGEST_CBLOCK_SHA - ctx->m_nDatLen;
00737
00738 if (nDatLen < n)
00739 {
00740 rtl_copyMemory (p, d, nDatLen);
00741 ctx->m_nDatLen += nDatLen;
00742
00743 return rtl_Digest_E_None;
00744 }
00745
00746 rtl_copyMemory (p, d, n);
00747 d += n;
00748 nDatLen -= n;
00749
00750 #ifndef WORDS_BIGENDIAN
00751 __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
00752 #endif
00753
00754 __rtl_digest_updateSHA (ctx);
00755 ctx->m_nDatLen = 0;
00756 }
00757
00758 while (nDatLen >= DIGEST_CBLOCK_SHA)
00759 {
00760 rtl_copyMemory (ctx->m_pData, d, DIGEST_CBLOCK_SHA);
00761 d += DIGEST_CBLOCK_SHA;
00762 nDatLen -= DIGEST_CBLOCK_SHA;
00763
00764 #ifndef WORDS_BIGENDIAN
00765 __rtl_digest_swapLong (ctx->m_pData, DIGEST_LBLOCK_SHA);
00766 #endif
00767
00768 __rtl_digest_updateSHA (ctx);
00769 }
00770
00771 rtl_copyMemory (ctx->m_pData, d, nDatLen);
00772 ctx->m_nDatLen = nDatLen;
00773
00774 return rtl_Digest_E_None;
00775 }
00776
00777
00778
00779
00780 rtlDigestError rtl_digest_getSHA1 (
00781 rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
00782 {
00783 DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
00784 sal_uInt8 *p = pBuffer;
00785
00786 DigestContextSHA *ctx;
00787
00788 if ((pImpl == NULL) || (pBuffer == NULL))
00789 return rtl_Digest_E_Argument;
00790
00791 if (!(pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1))
00792 return rtl_Digest_E_Algorithm;
00793
00794 if (!(pImpl->m_digest.m_length <= nBufLen))
00795 return rtl_Digest_E_BufferSize;
00796
00797 ctx = &(pImpl->m_context);
00798
00799 __rtl_digest_endSHA (ctx);
00800 RTL_DIGEST_HTONL (ctx->m_nA, p);
00801 RTL_DIGEST_HTONL (ctx->m_nB, p);
00802 RTL_DIGEST_HTONL (ctx->m_nC, p);
00803 RTL_DIGEST_HTONL (ctx->m_nD, p);
00804 RTL_DIGEST_HTONL (ctx->m_nE, p);
00805 __rtl_digest_initSHA (ctx, __rtl_digest_updateSHA_1);
00806
00807 return rtl_Digest_E_None;
00808 }
00809
00810
00811
00812
00813 void rtl_digest_destroySHA1 (rtlDigest Digest)
00814 {
00815 DigestSHA_Impl *pImpl = (DigestSHA_Impl *)Digest;
00816 if (pImpl)
00817 {
00818 if (pImpl->m_digest.m_algorithm == rtl_Digest_AlgorithmSHA1)
00819 rtl_freeZeroMemory (pImpl, sizeof (DigestSHA_Impl));
00820 else
00821 rtl_freeMemory (pImpl);
00822 }
00823 }
00824
00825
00826
00827
00828
00829
00830
00831 bool SHA1::getHash( QString const & text, QCString & hash )
00832 {
00833 rtlDigest aDigest = rtl_digest_createSHA1();
00834 rtlDigestError aError = rtl_digest_updateSHA1( aDigest, text.unicode(), text.length() * sizeof(QChar) );
00835
00836 if ( aError == rtl_Digest_E_None )
00837 {
00838 QCString digest;
00839 digest.resize( RTL_DIGEST_LENGTH_SHA1 + 1 );
00840 digest.fill( '\0', RTL_DIGEST_LENGTH_SHA1 );
00841
00842 aError = rtl_digest_getSHA1( aDigest, (unsigned char *) digest.data(), RTL_DIGEST_LENGTH_SHA1 );
00843
00844 if (aError != rtl_Digest_E_None)
00845 return false;
00846
00847 hash = digest;
00848
00849 return true;
00850 }
00851
00852 return false;
00853 }