kspread

digest.cc

00001 /*************************************************************************
00002  * This implementation has been taken from the OpenOffice 1.0 and modified
00003  * to use KSpread data types.
00004  *
00005  *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
00006  *
00007  *  Sun has made the contents of this file available subject to the
00008  *  terms of GNU Lesser General Public License Version 2.1 as
00009  *  specified in sal/rtl/source/digest.c in the OpenOffice package.
00010  *
00011  *
00012  *  Sun Microsystems Inc., October, 2000
00013  *
00014  *  GNU Lesser General Public License Version 2.1
00015  *  =============================================
00016  *  Copyright 2000 by Sun Microsystems, Inc.
00017  *  901 San Antonio Road, Palo Alto, CA 94303, USA
00018  *
00019  *  This library is free software; you can redistribute it and/or
00020  *  modify it under the terms of the GNU Lesser General Public
00021  *  License version 2.1, as published by the Free Software Foundation.
00022  *
00023  *  This library is distributed in the hope that it will be useful,
00024  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00025  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00026  *  Lesser General Public License for more details.
00027  *
00028  *  You should have received a copy of the GNU Lesser General Public
00029  *  License along with this library; if not, write to the Free Software
00030  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
00031  * Boston, MA 02110-1301, USA
00032  *
00033  *  All Rights Reserved.
00034  *
00035  *  Contributor(s): Matthias Huetsch <matthias.huetsch@sun.com>
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  * rtlDigest.
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  * rtl_digest_SHA1 interface.
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  * rtlDigest internals.
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  * __rtl_digest_swapLong.
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  * rtlDigest implementation.
00275  *
00276  *======================================================================*/
00277 /*
00278  * rtl_digest_create.
00279  
00280 rtlDigest rtl_digest_create (rtlDigestAlgorithm Algorithm)
00281 {
00282     rtlDigest Digest = (rtlDigest)NULL;
00283     switch (Algorithm)
00284     {
00285         case rtl_Digest_AlgorithmMD2:
00286             Digest = rtl_digest_createMD2();
00287             break;
00288 
00289         case rtl_Digest_AlgorithmMD5:
00290             Digest = rtl_digest_createMD5();
00291             break;
00292 
00293         case rtl_Digest_AlgorithmSHA:
00294             Digest = rtl_digest_createSHA();
00295             break;
00296 
00297         case rtl_Digest_AlgorithmSHA1:
00298             Digest = rtl_digest_createSHA1();
00299             break;
00300 
00301         case rtl_Digest_AlgorithmHMAC_MD5:
00302             Digest = rtl_digest_createHMAC_MD5();
00303             break;
00304 
00305         case rtl_Digest_AlgorithmHMAC_SHA1:
00306             Digest = rtl_digest_createHMAC_SHA1();
00307             break;
00308 
00309                 default: // rtl_Digest_AlgorithmInvalid 
00310             break;
00311     }
00312     return Digest;
00313 }
00314 
00315 
00316 // rtl_digest_queryAlgorithm.
00317  
00318 rtlDigestAlgorithm rtl_digest_queryAlgorithm (rtlDigest Digest)
00319 {
00320     Digest_Impl *pImpl = (Digest_Impl *)Digest;
00321     if (pImpl)
00322         return pImpl->m_algorithm;
00323     else
00324         return rtl_Digest_AlgorithmInvalid;
00325 }
00326 
00327  // rtl_digest_queryLength.
00328 sal_uInt32 rtl_digest_queryLength (rtlDigest Digest)
00329 {
00330     Digest_Impl *pImpl = (Digest_Impl *)Digest;
00331     if (pImpl)
00332         return pImpl->m_length;
00333     else
00334         return 0;
00335 }
00336 
00337 // * rtl_digest_init.
00338 rtlDigestError rtl_digest_init (
00339     rtlDigest Digest, const sal_uInt8 *pData, sal_uInt32 nDatLen)
00340 {
00341     Digest_Impl *pImpl = (Digest_Impl *)Digest;
00342     if (pImpl)
00343     {
00344         if (pImpl->m_init)
00345             return pImpl->m_init (Digest, pData, nDatLen);
00346         else
00347             return rtl_Digest_E_None;
00348     }
00349     return rtl_Digest_E_Argument;
00350 }
00351 
00352 // * rtl_digest_update.
00353 rtlDigestError rtl_digest_update (
00354     rtlDigest Digest, const void *pData, sal_uInt32 nDatLen)
00355 {
00356     Digest_Impl *pImpl = (Digest_Impl *)Digest;
00357     if (pImpl && pImpl->m_update)
00358         return pImpl->m_update (Digest, pData, nDatLen);
00359     else
00360         return rtl_Digest_E_Argument;
00361 }
00362 
00363 // * rtl_digest_get.
00364 rtlDigestError rtl_digest_get (
00365     rtlDigest Digest, sal_uInt8 *pBuffer, sal_uInt32 nBufLen)
00366 {
00367     Digest_Impl *pImpl = (Digest_Impl *)Digest;
00368     if (pImpl && pImpl->m_get)
00369         return pImpl->m_get (Digest, pBuffer, nBufLen);
00370     else
00371         return rtl_Digest_E_Argument;
00372 }
00373 
00374 // * rtl_digest_destroy.
00375 void rtl_digest_destroy (rtlDigest Digest)
00376 {
00377     Digest_Impl *pImpl = (Digest_Impl *)Digest;
00378     if (pImpl && pImpl->m_delete)
00379         pImpl->m_delete (Digest);
00380 }
00381 */
00382 
00383 /*========================================================================
00384  *
00385  * rtl_digest_(SHA|SHA1) common internals.
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  * __rtl_digest_initSHA.
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  * __rtl_digest_updateSHA.
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  * __rtl_digest_endSHA.
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  * rtl_digest_SHA1 internals.
00643  *
00644  *======================================================================*/
00645 /*
00646  * __rtl_digest_SHA_1.
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  * __rtl_digest_updateSHA_1.
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  * rtl_digest_SHA1 implementation.
00667  *
00668  *======================================================================*/
00669 /*
00670  * rtl_digest_SHA1.
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  * rtl_digest_createSHA1.
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  * rtl_digest_updateSHA1.
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  * rtl_digest_getSHA1.
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  * rtl_digest_destroySHA1.
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  * The End.
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 }
KDE Home | KDE Accessibility Home | Description of Access Keys