LCOV - code coverage report
Current view: top level - sal/rtl - digest.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 176 833 21.1 %
Date: 2014-04-14 Functions: 13 60 21.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10