LCOV - code coverage report
Current view: top level - sal/rtl - cipher.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 258 325 79.4 %
Date: 2015-06-13 12:38:46 Functions: 23 25 92.0 %
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 <rtl/alloc.h>
      24             : #include <rtl/cipher.h>
      25             : 
      26             : /*========================================================================
      27             :  *
      28             :  * rtlCipher internals.
      29             :  *
      30             :  *======================================================================*/
      31             : #define RTL_CIPHER_NTOHL(c, l) \
      32             :     ((l)  = ((sal_uInt32)(*((c)++))) << 24L, \
      33             :      (l) |= ((sal_uInt32)(*((c)++))) << 16L, \
      34             :      (l) |= ((sal_uInt32)(*((c)++))) <<  8L, \
      35             :      (l) |= ((sal_uInt32)(*((c)++))))
      36             : 
      37             : #define RTL_CIPHER_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_CIPHER_NTOHL64(c, xl, xr, n) \
      44             : { \
      45             :     (xl) = (xr) = 0; \
      46             :     (c) += (n);  \
      47             :     switch ((n)) \
      48             :     { \
      49             :         case 8: (xr)  = ((sal_uInt32)(*(--(c)))); \
      50             :         case 7: (xr) |= ((sal_uInt32)(*(--(c)))) <<  8L; \
      51             :         case 6: (xr) |= ((sal_uInt32)(*(--(c)))) << 16L; \
      52             :         case 5: (xr) |= ((sal_uInt32)(*(--(c)))) << 24L; \
      53             :         case 4: (xl)  = ((sal_uInt32)(*(--(c)))); \
      54             :         case 3: (xl) |= ((sal_uInt32)(*(--(c)))) <<  8L; \
      55             :         case 2: (xl) |= ((sal_uInt32)(*(--(c)))) << 16L; \
      56             :         case 1: (xl) |= ((sal_uInt32)(*(--(c)))) << 24L; \
      57             :     } \
      58             : }
      59             : 
      60             : #define RTL_CIPHER_HTONL64(xl, xr, c, n) \
      61             : { \
      62             :     (c) += (n);  \
      63             :     switch ((n)) \
      64             :     { \
      65             :         case 8: *(--(c)) = (sal_uInt8)(((xr)       ) & 0xff); \
      66             :         case 7: *(--(c)) = (sal_uInt8)(((xr) >>  8L) & 0xff); \
      67             :         case 6: *(--(c)) = (sal_uInt8)(((xr) >> 16L) & 0xff); \
      68             :         case 5: *(--(c)) = (sal_uInt8)(((xr) >> 24L) & 0xff); \
      69             :         case 4: *(--(c)) = (sal_uInt8)(((xl)       ) & 0xff); \
      70             :         case 3: *(--(c)) = (sal_uInt8)(((xl) >>  8L) & 0xff); \
      71             :         case 2: *(--(c)) = (sal_uInt8)(((xl) >> 16L) & 0xff); \
      72             :         case 1: *(--(c)) = (sal_uInt8)(((xl) >> 24L) & 0xff); \
      73             :     } \
      74             : }
      75             : 
      76             : typedef rtlCipherError (SAL_CALL cipher_init_t) (
      77             :     rtlCipher          Cipher,
      78             :     rtlCipherDirection Direction,
      79             :     const sal_uInt8 *pKeyData, sal_Size nKeyLen,
      80             :     const sal_uInt8 *pArgData, sal_Size nArgLen);
      81             : 
      82             : typedef rtlCipherError (SAL_CALL cipher_update_t) (
      83             :     rtlCipher   Cipher,
      84             :     const void *pData,   sal_Size nDatLen,
      85             :     sal_uInt8  *pBuffer, sal_Size nBufLen);
      86             : 
      87             : typedef void (SAL_CALL cipher_delete_t) (rtlCipher Cipher);
      88             : 
      89             : /** Cipher_Impl.
      90             :  */
      91             : struct Cipher_Impl
      92             : {
      93             :     rtlCipherAlgorithm  m_algorithm;
      94             :     rtlCipherDirection  m_direction;
      95             :     rtlCipherMode       m_mode;
      96             : 
      97             :     cipher_init_t      *m_init;
      98             :     cipher_update_t    *m_encode;
      99             :     cipher_update_t    *m_decode;
     100             :     cipher_delete_t    *m_delete;
     101             : };
     102             : 
     103             : /*========================================================================
     104             :  *
     105             :  * rtlCipher implementation.
     106             :  *
     107             :  *======================================================================*/
     108             : /*
     109             :  * rtl_cipher_create.
     110             :  */
     111         285 : rtlCipher SAL_CALL rtl_cipher_create (
     112             :     rtlCipherAlgorithm Algorithm,
     113             :     rtlCipherMode      Mode) SAL_THROW_EXTERN_C()
     114             : {
     115         285 :     rtlCipher Cipher = nullptr;
     116         285 :     switch (Algorithm)
     117             :     {
     118             :         case rtl_Cipher_AlgorithmBF:
     119          80 :             Cipher = rtl_cipher_createBF (Mode);
     120          80 :             break;
     121             : 
     122             :         case rtl_Cipher_AlgorithmARCFOUR:
     123         201 :             Cipher = rtl_cipher_createARCFOUR (Mode);
     124         201 :             break;
     125             : 
     126             :         default: /* rtl_Cipher_AlgorithmInvalid */
     127           4 :             break;
     128             :     }
     129         285 :     return Cipher;
     130             : }
     131             : 
     132             : /*
     133             :  * rtl_cipher_init.
     134             :  */
     135         244 : rtlCipherError SAL_CALL rtl_cipher_init (
     136             :     rtlCipher          Cipher,
     137             :     rtlCipherDirection Direction,
     138             :     const sal_uInt8 *pKeyData, sal_Size nKeyLen,
     139             :     const sal_uInt8 *pArgData, sal_Size nArgLen) SAL_THROW_EXTERN_C()
     140             : {
     141         244 :     Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
     142         244 :     if (pImpl == NULL)
     143           0 :         return rtl_Cipher_E_Argument;
     144         244 :     if (pImpl->m_init == NULL)
     145           0 :         return rtl_Cipher_E_Unknown;
     146             : 
     147             :     return (pImpl->m_init)(
     148         244 :         Cipher, Direction, pKeyData, nKeyLen, pArgData, nArgLen);
     149             : }
     150             : 
     151             : /*
     152             :  * rtl_cipher_encode.
     153             :  */
     154          43 : rtlCipherError SAL_CALL rtl_cipher_encode (
     155             :     rtlCipher   Cipher,
     156             :     const void *pData,   sal_Size nDatLen,
     157             :     sal_uInt8  *pBuffer, sal_Size nBufLen) SAL_THROW_EXTERN_C()
     158             : {
     159          43 :     Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
     160          43 :     if (pImpl == NULL)
     161           0 :         return rtl_Cipher_E_Argument;
     162          43 :     if (pImpl->m_encode == NULL)
     163           0 :         return rtl_Cipher_E_Unknown;
     164             : 
     165          43 :     return (pImpl->m_encode)(Cipher, pData, nDatLen, pBuffer, nBufLen);
     166             : }
     167             : 
     168             : /*
     169             :  * rtl_cipher_decode.
     170             :  */
     171        4170 : rtlCipherError SAL_CALL rtl_cipher_decode (
     172             :     rtlCipher   Cipher,
     173             :     const void *pData,   sal_Size nDatLen,
     174             :     sal_uInt8  *pBuffer, sal_Size nBufLen) SAL_THROW_EXTERN_C()
     175             : {
     176        4170 :     Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
     177        4170 :     if (pImpl == NULL)
     178           0 :         return rtl_Cipher_E_Argument;
     179        4170 :     if (pImpl->m_decode == NULL)
     180           0 :         return rtl_Cipher_E_Unknown;
     181             : 
     182        4170 :     return (pImpl->m_decode)(Cipher, pData, nDatLen, pBuffer, nBufLen);
     183             : }
     184             : 
     185             : /*
     186             :  * rtl_cipher_destroy.
     187             :  */
     188         283 : void SAL_CALL rtl_cipher_destroy (rtlCipher Cipher) SAL_THROW_EXTERN_C()
     189             : {
     190         283 :     Cipher_Impl *pImpl = static_cast<Cipher_Impl*>(Cipher);
     191         283 :     if (pImpl && pImpl->m_delete)
     192         283 :         pImpl->m_delete (Cipher);
     193         283 : }
     194             : 
     195             : /*========================================================================
     196             :  *
     197             :  * rtl_cipherBF (Blowfish) internals.
     198             :  *
     199             :  *======================================================================*/
     200             : #define CIPHER_ROUNDS_BF 16
     201             : 
     202             : struct CipherKeyBF
     203             : {
     204             :     sal_uInt32 m_S[4][256];
     205             :     sal_uInt32 m_P[CIPHER_ROUNDS_BF + 2];
     206             : };
     207             : 
     208             : struct CipherContextBF
     209             : {
     210             :     CipherKeyBF    m_key;
     211             :     union
     212             :     {
     213             :         sal_uInt32 m_long[2];
     214             :         sal_uInt8  m_byte[8];
     215             :     } m_iv;
     216             :     sal_uInt32     m_offset;
     217             : };
     218             : 
     219             : struct CipherBF_Impl
     220             : {
     221             :     Cipher_Impl     m_cipher;
     222             :     CipherContextBF m_context;
     223             : };
     224             : 
     225             : /** __rtl_cipherBF_init.
     226             :  */
     227             : static rtlCipherError __rtl_cipherBF_init (
     228             :     CipherContextBF *ctx,
     229             :     rtlCipherMode    eMode,
     230             :     const sal_uInt8 *pKeyData, sal_Size nKeyLen,
     231             :     const sal_uInt8 *pArgData, sal_Size nArgLen);
     232             : 
     233             : /** __rtl_cipherBF_update.
     234             :  */
     235             : static rtlCipherError __rtl_cipherBF_update (
     236             :     CipherContextBF    *ctx,
     237             :     rtlCipherMode       eMode,
     238             :     rtlCipherDirection  eDirection,
     239             :     const sal_uInt8    *pData,   sal_Size nDatLen,
     240             :     sal_uInt8          *pBuffer, sal_Size nBufLen);
     241             : 
     242             : /** __rtl_cipherBF_updateECB.
     243             :  */
     244             : static void __rtl_cipherBF_updateECB (
     245             :     CipherContextBF    *ctx,
     246             :     rtlCipherDirection  direction,
     247             :     const sal_uInt8    *pData,
     248             :     sal_uInt8          *pBuffer,
     249             :     sal_Size            nLength);
     250             : 
     251             : /** __rtl_cipherBF_updateCBC.
     252             :  */
     253             : static void __rtl_cipherBF_updateCBC (
     254             :     CipherContextBF    *ctx,
     255             :     rtlCipherDirection  direction,
     256             :     const sal_uInt8    *pData,
     257             :     sal_uInt8          *pBuffer,
     258             :     sal_Size          nLength);
     259             : 
     260             : /** __rtl_cipherBF_updateCFB.
     261             :  */
     262             : static void __rtl_cipherBF_updateCFB (
     263             :     CipherContextBF    *ctx,
     264             :     rtlCipherDirection  direction,
     265             :     const sal_uInt8    *pData,
     266             :     sal_uInt8          *pBuffer);
     267             : 
     268             : /** __rtl_cipher_encode.
     269             :  */
     270             : static void __rtl_cipherBF_encode (
     271             :     CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr);
     272             : 
     273             : /** __rtl_cipherBF_decode.
     274             :  */
     275             : static void __rtl_cipherBF_decode (
     276             :     CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr);
     277             : 
     278             : /** __rtl_cipherBF.
     279             :  */
     280             : static sal_uInt32 __rtl_cipherBF (
     281             :     CipherKeyBF *key, sal_uInt32 x);
     282             : 
     283             : /** __rtl_cipherBF_key.
     284             :  */
     285             : static const CipherKeyBF __rtl_cipherBF_key =
     286             : {
     287             :     /* S */
     288             :     {
     289             :         /* S[0] */
     290             :         {
     291             :             /* 0 */
     292             :             0xD1310BA6L, 0x98DFB5ACL, 0x2FFD72DBL, 0xD01ADFB7L,
     293             :             0xB8E1AFEDL, 0x6A267E96L, 0xBA7C9045L, 0xF12C7F99L,
     294             :             0x24A19947L, 0xB3916CF7L, 0x0801F2E2L, 0x858EFC16L,
     295             :             0x636920D8L, 0x71574E69L, 0xA458FEA3L, 0xF4933D7EL,
     296             : 
     297             :             /* 1 */
     298             :             0x0D95748FL, 0x728EB658L, 0x718BCD58L, 0x82154AEEL,
     299             :             0x7B54A41DL, 0xC25A59B5L, 0x9C30D539L, 0x2AF26013L,
     300             :             0xC5D1B023L, 0x286085F0L, 0xCA417918L, 0xB8DB38EFL,
     301             :             0x8E79DCB0L, 0x603A180EL, 0x6C9E0E8BL, 0xB01E8A3EL,
     302             : 
     303             :             /* 2 */
     304             :             0xD71577C1L, 0xBD314B27L, 0x78AF2FDAL, 0x55605C60L,
     305             :             0xE65525F3L, 0xAA55AB94L, 0x57489862L, 0x63E81440L,
     306             :             0x55CA396AL, 0x2AAB10B6L, 0xB4CC5C34L, 0x1141E8CEL,
     307             :             0xA15486AFL, 0x7C72E993L, 0xB3EE1411L, 0x636FBC2AL,
     308             : 
     309             :             /* 3 */
     310             :             0x2BA9C55DL, 0x741831F6L, 0xCE5C3E16L, 0x9B87931EL,
     311             :             0xAFD6BA33L, 0x6C24CF5CL, 0x7A325381L, 0x28958677L,
     312             :             0x3B8F4898L, 0x6B4BB9AFL, 0xC4BFE81BL, 0x66282193L,
     313             :             0x61D809CCL, 0xFB21A991L, 0x487CAC60L, 0x5DEC8032L,
     314             : 
     315             :             /* 4 */
     316             :             0xEF845D5DL, 0xE98575B1L, 0xDC262302L, 0xEB651B88L,
     317             :             0x23893E81L, 0xD396ACC5L, 0x0F6D6FF3L, 0x83F44239L,
     318             :             0x2E0B4482L, 0xA4842004L, 0x69C8F04AL, 0x9E1F9B5EL,
     319             :             0x21C66842L, 0xF6E96C9AL, 0x670C9C61L, 0xABD388F0L,
     320             : 
     321             :             /* 5 */
     322             :             0x6A51A0D2L, 0xD8542F68L, 0x960FA728L, 0xAB5133A3L,
     323             :             0x6EEF0B6CL, 0x137A3BE4L, 0xBA3BF050L, 0x7EFB2A98L,
     324             :             0xA1F1651DL, 0x39AF0176L, 0x66CA593EL, 0x82430E88L,
     325             :             0x8CEE8619L, 0x456F9FB4L, 0x7D84A5C3L, 0x3B8B5EBEL,
     326             : 
     327             :             /* 6 */
     328             :             0xE06F75D8L, 0x85C12073L, 0x401A449FL, 0x56C16AA6L,
     329             :             0x4ED3AA62L, 0x363F7706L, 0x1BFEDF72L, 0x429B023DL,
     330             :             0x37D0D724L, 0xD00A1248L, 0xDB0FEAD3L, 0x49F1C09BL,
     331             :             0x075372C9L, 0x80991B7BL, 0x25D479D8L, 0xF6E8DEF7L,
     332             : 
     333             :             /* 7 */
     334             :             0xE3FE501AL, 0xB6794C3BL, 0x976CE0BDL, 0x04C006BAL,
     335             :             0xC1A94FB6L, 0x409F60C4L, 0x5E5C9EC2L, 0x196A2463L,
     336             :             0x68FB6FAFL, 0x3E6C53B5L, 0x1339B2EBL, 0x3B52EC6FL,
     337             :             0x6DFC511FL, 0x9B30952CL, 0xCC814544L, 0xAF5EBD09L,
     338             : 
     339             :             /* 8 */
     340             :             0xBEE3D004L, 0xDE334AFDL, 0x660F2807L, 0x192E4BB3L,
     341             :             0xC0CBA857L, 0x45C8740FL, 0xD20B5F39L, 0xB9D3FBDBL,
     342             :             0x5579C0BDL, 0x1A60320AL, 0xD6A100C6L, 0x402C7279L,
     343             :             0x679F25FEL, 0xFB1FA3CCL, 0x8EA5E9F8L, 0xDB3222F8L,
     344             : 
     345             :             /* 9 */
     346             :             0x3C7516DFL, 0xFD616B15L, 0x2F501EC8L, 0xAD0552ABL,
     347             :             0x323DB5FAL, 0xFD238760L, 0x53317B48L, 0x3E00DF82L,
     348             :             0x9E5C57BBL, 0xCA6F8CA0L, 0x1A87562EL, 0xDF1769DBL,
     349             :             0xD542A8F6L, 0x287EFFC3L, 0xAC6732C6L, 0x8C4F5573L,
     350             : 
     351             :             /* A */
     352             :             0x695B27B0L, 0xBBCA58C8L, 0xE1FFA35DL, 0xB8F011A0L,
     353             :             0x10FA3D98L, 0xFD2183B8L, 0x4AFCB56CL, 0x2DD1D35BL,
     354             :             0x9A53E479L, 0xB6F84565L, 0xD28E49BCL, 0x4BFB9790L,
     355             :             0xE1DDF2DAL, 0xA4CB7E33L, 0x62FB1341L, 0xCEE4C6E8L,
     356             : 
     357             :             /* B */
     358             :             0xEF20CADAL, 0x36774C01L, 0xD07E9EFEL, 0x2BF11FB4L,
     359             :             0x95DBDA4DL, 0xAE909198L, 0xEAAD8E71L, 0x6B93D5A0L,
     360             :             0xD08ED1D0L, 0xAFC725E0L, 0x8E3C5B2FL, 0x8E7594B7L,
     361             :             0x8FF6E2FBL, 0xF2122B64L, 0x8888B812L, 0x900DF01CL,
     362             : 
     363             :             /* C */
     364             :             0x4FAD5EA0L, 0x688FC31CL, 0xD1CFF191L, 0xB3A8C1ADL,
     365             :             0x2F2F2218L, 0xBE0E1777L, 0xEA752DFEL, 0x8B021FA1L,
     366             :             0xE5A0CC0FL, 0xB56F74E8L, 0x18ACF3D6L, 0xCE89E299L,
     367             :             0xB4A84FE0L, 0xFD13E0B7L, 0x7CC43B81L, 0xD2ADA8D9L,
     368             : 
     369             :             /* D */
     370             :             0x165FA266L, 0x80957705L, 0x93CC7314L, 0x211A1477L,
     371             :             0xE6AD2065L, 0x77B5FA86L, 0xC75442F5L, 0xFB9D35CFL,
     372             :             0xEBCDAF0CL, 0x7B3E89A0L, 0xD6411BD3L, 0xAE1E7E49L,
     373             :             0x00250E2DL, 0x2071B35EL, 0x226800BBL, 0x57B8E0AFL,
     374             : 
     375             :             /* E */
     376             :             0x2464369BL, 0xF009B91EL, 0x5563911DL, 0x59DFA6AAL,
     377             :             0x78C14389L, 0xD95A537FL, 0x207D5BA2L, 0x02E5B9C5L,
     378             :             0x83260376L, 0x6295CFA9L, 0x11C81968L, 0x4E734A41L,
     379             :             0xB3472DCAL, 0x7B14A94AL, 0x1B510052L, 0x9A532915L,
     380             : 
     381             :             /* F */
     382             :             0xD60F573FL, 0xBC9BC6E4L, 0x2B60A476L, 0x81E67400L,
     383             :             0x08BA6FB5L, 0x571BE91FL, 0xF296EC6BL, 0x2A0DD915L,
     384             :             0xB6636521L, 0xE7B9F9B6L, 0xFF34052EL, 0xC5855664L,
     385             :             0x53B02D5DL, 0xA99F8FA1L, 0x08BA4799L, 0x6E85076AL
     386             :         },
     387             : 
     388             :         /* S[1] */
     389             :         {
     390             :             0x4B7A70E9L, 0xB5B32944L, 0xDB75092EL, 0xC4192623L,
     391             :             0xAD6EA6B0L, 0x49A7DF7DL, 0x9CEE60B8L, 0x8FEDB266L,
     392             :             0xECAA8C71L, 0x699A17FFL, 0x5664526CL, 0xC2B19EE1L,
     393             :             0x193602A5L, 0x75094C29L, 0xA0591340L, 0xE4183A3EL,
     394             : 
     395             :             0x3F54989AL, 0x5B429D65L, 0x6B8FE4D6L, 0x99F73FD6L,
     396             :             0xA1D29C07L, 0xEFE830F5L, 0x4D2D38E6L, 0xF0255DC1L,
     397             :             0x4CDD2086L, 0x8470EB26L, 0x6382E9C6L, 0x021ECC5EL,
     398             :             0x09686B3FL, 0x3EBAEFC9L, 0x3C971814L, 0x6B6A70A1L,
     399             : 
     400             :             0x687F3584L, 0x52A0E286L, 0xB79C5305L, 0xAA500737L,
     401             :             0x3E07841CL, 0x7FDEAE5CL, 0x8E7D44ECL, 0x5716F2B8L,
     402             :             0xB03ADA37L, 0xF0500C0DL, 0xF01C1F04L, 0x0200B3FFL,
     403             :             0xAE0CF51AL, 0x3CB574B2L, 0x25837A58L, 0xDC0921BDL,
     404             : 
     405             :             0xD19113F9L, 0x7CA92FF6L, 0x94324773L, 0x22F54701L,
     406             :             0x3AE5E581L, 0x37C2DADCL, 0xC8B57634L, 0x9AF3DDA7L,
     407             :             0xA9446146L, 0x0FD0030EL, 0xECC8C73EL, 0xA4751E41L,
     408             :             0xE238CD99L, 0x3BEA0E2FL, 0x3280BBA1L, 0x183EB331L,
     409             : 
     410             :             0x4E548B38L, 0x4F6DB908L, 0x6F420D03L, 0xF60A04BFL,
     411             :             0x2CB81290L, 0x24977C79L, 0x5679B072L, 0xBCAF89AFL,
     412             :             0xDE9A771FL, 0xD9930810L, 0xB38BAE12L, 0xDCCF3F2EL,
     413             :             0x5512721FL, 0x2E6B7124L, 0x501ADDE6L, 0x9F84CD87L,
     414             : 
     415             :             0x7A584718L, 0x7408DA17L, 0xBC9F9ABCL, 0xE94B7D8CL,
     416             :             0xEC7AEC3AL, 0xDB851DFAL, 0x63094366L, 0xC464C3D2L,
     417             :             0xEF1C1847L, 0x3215D908L, 0xDD433B37L, 0x24C2BA16L,
     418             :             0x12A14D43L, 0x2A65C451L, 0x50940002L, 0x133AE4DDL,
     419             : 
     420             :             0x71DFF89EL, 0x10314E55L, 0x81AC77D6L, 0x5F11199BL,
     421             :             0x043556F1L, 0xD7A3C76BL, 0x3C11183BL, 0x5924A509L,
     422             :             0xF28FE6EDL, 0x97F1FBFAL, 0x9EBABF2CL, 0x1E153C6EL,
     423             :             0x86E34570L, 0xEAE96FB1L, 0x860E5E0AL, 0x5A3E2AB3L,
     424             : 
     425             :             0x771FE71CL, 0x4E3D06FAL, 0x2965DCB9L, 0x99E71D0FL,
     426             :             0x803E89D6L, 0x5266C825L, 0x2E4CC978L, 0x9C10B36AL,
     427             :             0xC6150EBAL, 0x94E2EA78L, 0xA5FC3C53L, 0x1E0A2DF4L,
     428             :             0xF2F74EA7L, 0x361D2B3DL, 0x1939260FL, 0x19C27960L,
     429             : 
     430             :             0x5223A708L, 0xF71312B6L, 0xEBADFE6EL, 0xEAC31F66L,
     431             :             0xE3BC4595L, 0xA67BC883L, 0xB17F37D1L, 0x018CFF28L,
     432             :             0xC332DDEFL, 0xBE6C5AA5L, 0x65582185L, 0x68AB9802L,
     433             :             0xEECEA50FL, 0xDB2F953BL, 0x2AEF7DADL, 0x5B6E2F84L,
     434             : 
     435             :             0x1521B628L, 0x29076170L, 0xECDD4775L, 0x619F1510L,
     436             :             0x13CCA830L, 0xEB61BD96L, 0x0334FE1EL, 0xAA0363CFL,
     437             :             0xB5735C90L, 0x4C70A239L, 0xD59E9E0BL, 0xCBAADE14L,
     438             :             0xEECC86BCL, 0x60622CA7L, 0x9CAB5CABL, 0xB2F3846EL,
     439             : 
     440             :             0x648B1EAFL, 0x19BDF0CAL, 0xA02369B9L, 0x655ABB50L,
     441             :             0x40685A32L, 0x3C2AB4B3L, 0x319EE9D5L, 0xC021B8F7L,
     442             :             0x9B540B19L, 0x875FA099L, 0x95F7997EL, 0x623D7DA8L,
     443             :             0xF837889AL, 0x97E32D77L, 0x11ED935FL, 0x16681281L,
     444             : 
     445             :             0x0E358829L, 0xC7E61FD6L, 0x96DEDFA1L, 0x7858BA99L,
     446             :             0x57F584A5L, 0x1B227263L, 0x9B83C3FFL, 0x1AC24696L,
     447             :             0xCDB30AEBL, 0x532E3054L, 0x8FD948E4L, 0x6DBC3128L,
     448             :             0x58EBF2EFL, 0x34C6FFEAL, 0xFE28ED61L, 0xEE7C3C73L,
     449             : 
     450             :             0x5D4A14D9L, 0xE864B7E3L, 0x42105D14L, 0x203E13E0L,
     451             :             0x45EEE2B6L, 0xA3AAABEAL, 0xDB6C4F15L, 0xFACB4FD0L,
     452             :             0xC742F442L, 0xEF6ABBB5L, 0x654F3B1DL, 0x41CD2105L,
     453             :             0xD81E799EL, 0x86854DC7L, 0xE44B476AL, 0x3D816250L,
     454             : 
     455             :             0xCF62A1F2L, 0x5B8D2646L, 0xFC8883A0L, 0xC1C7B6A3L,
     456             :             0x7F1524C3L, 0x69CB7492L, 0x47848A0BL, 0x5692B285L,
     457             :             0x095BBF00L, 0xAD19489DL, 0x1462B174L, 0x23820E00L,
     458             :             0x58428D2AL, 0x0C55F5EAL, 0x1DADF43EL, 0x233F7061L,
     459             : 
     460             :             0x3372F092L, 0x8D937E41L, 0xD65FECF1L, 0x6C223BDBL,
     461             :             0x7CDE3759L, 0xCBEE7460L, 0x4085F2A7L, 0xCE77326EL,
     462             :             0xA6078084L, 0x19F8509EL, 0xE8EFD855L, 0x61D99735L,
     463             :             0xA969A7AAL, 0xC50C06C2L, 0x5A04ABFCL, 0x800BCADCL,
     464             : 
     465             :             0x9E447A2EL, 0xC3453484L, 0xFDD56705L, 0x0E1E9EC9L,
     466             :             0xDB73DBD3L, 0x105588CDL, 0x675FDA79L, 0xE3674340L,
     467             :             0xC5C43465L, 0x713E38D8L, 0x3D28F89EL, 0xF16DFF20L,
     468             :             0x153E21E7L, 0x8FB03D4AL, 0xE6E39F2BL, 0xDB83ADF7L
     469             :         },
     470             : 
     471             :         /* S[2] */
     472             :         {
     473             :             0xE93D5A68L, 0x948140F7L, 0xF64C261CL, 0x94692934L,
     474             :             0x411520F7L, 0x7602D4F7L, 0xBCF46B2EL, 0xD4A20068L,
     475             :             0xD4082471L, 0x3320F46AL, 0x43B7D4B7L, 0x500061AFL,
     476             :             0x1E39F62EL, 0x97244546L, 0x14214F74L, 0xBF8B8840L,
     477             : 
     478             :             0x4D95FC1DL, 0x96B591AFL, 0x70F4DDD3L, 0x66A02F45L,
     479             :             0xBFBC09ECL, 0x03BD9785L, 0x7FAC6DD0L, 0x31CB8504L,
     480             :             0x96EB27B3L, 0x55FD3941L, 0xDA2547E6L, 0xABCA0A9AL,
     481             :             0x28507825L, 0x530429F4L, 0x0A2C86DAL, 0xE9B66DFBL,
     482             : 
     483             :             0x68DC1462L, 0xD7486900L, 0x680EC0A4L, 0x27A18DEEL,
     484             :             0x4F3FFEA2L, 0xE887AD8CL, 0xB58CE006L, 0x7AF4D6B6L,
     485             :             0xAACE1E7CL, 0xD3375FECL, 0xCE78A399L, 0x406B2A42L,
     486             :             0x20FE9E35L, 0xD9F385B9L, 0xEE39D7ABL, 0x3B124E8BL,
     487             : 
     488             :             0x1DC9FAF7L, 0x4B6D1856L, 0x26A36631L, 0xEAE397B2L,
     489             :             0x3A6EFA74L, 0xDD5B4332L, 0x6841E7F7L, 0xCA7820FBL,
     490             :             0xFB0AF54EL, 0xD8FEB397L, 0x454056ACL, 0xBA489527L,
     491             :             0x55533A3AL, 0x20838D87L, 0xFE6BA9B7L, 0xD096954BL,
     492             : 
     493             :             0x55A867BCL, 0xA1159A58L, 0xCCA92963L, 0x99E1DB33L,
     494             :             0xA62A4A56L, 0x3F3125F9L, 0x5EF47E1CL, 0x9029317CL,
     495             :             0xFDF8E802L, 0x04272F70L, 0x80BB155CL, 0x05282CE3L,
     496             :             0x95C11548L, 0xE4C66D22L, 0x48C1133FL, 0xC70F86DCL,
     497             : 
     498             :             0x07F9C9EEL, 0x41041F0FL, 0x404779A4L, 0x5D886E17L,
     499             :             0x325F51EBL, 0xD59BC0D1L, 0xF2BCC18FL, 0x41113564L,
     500             :             0x257B7834L, 0x602A9C60L, 0xDFF8E8A3L, 0x1F636C1BL,
     501             :             0x0E12B4C2L, 0x02E1329EL, 0xAF664FD1L, 0xCAD18115L,
     502             : 
     503             :             0x6B2395E0L, 0x333E92E1L, 0x3B240B62L, 0xEEBEB922L,
     504             :             0x85B2A20EL, 0xE6BA0D99L, 0xDE720C8CL, 0x2DA2F728L,
     505             :             0xD0127845L, 0x95B794FDL, 0x647D0862L, 0xE7CCF5F0L,
     506             :             0x5449A36FL, 0x877D48FAL, 0xC39DFD27L, 0xF33E8D1EL,
     507             : 
     508             :             0x0A476341L, 0x992EFF74L, 0x3A6F6EABL, 0xF4F8FD37L,
     509             :             0xA812DC60L, 0xA1EBDDF8L, 0x991BE14CL, 0xDB6E6B0DL,
     510             :             0xC67B5510L, 0x6D672C37L, 0x2765D43BL, 0xDCD0E804L,
     511             :             0xF1290DC7L, 0xCC00FFA3L, 0xB5390F92L, 0x690FED0BL,
     512             : 
     513             :             0x667B9FFBL, 0xCEDB7D9CL, 0xA091CF0BL, 0xD9155EA3L,
     514             :             0xBB132F88L, 0x515BAD24L, 0x7B9479BFL, 0x763BD6EBL,
     515             :             0x37392EB3L, 0xCC115979L, 0x8026E297L, 0xF42E312DL,
     516             :             0x6842ADA7L, 0xC66A2B3BL, 0x12754CCCL, 0x782EF11CL,
     517             : 
     518             :             0x6A124237L, 0xB79251E7L, 0x06A1BBE6L, 0x4BFB6350L,
     519             :             0x1A6B1018L, 0x11CAEDFAL, 0x3D25BDD8L, 0xE2E1C3C9L,
     520             :             0x44421659L, 0x0A121386L, 0xD90CEC6EL, 0xD5ABEA2AL,
     521             :             0x64AF674EL, 0xDA86A85FL, 0xBEBFE988L, 0x64E4C3FEL,
     522             : 
     523             :             0x9DBC8057L, 0xF0F7C086L, 0x60787BF8L, 0x6003604DL,
     524             :             0xD1FD8346L, 0xF6381FB0L, 0x7745AE04L, 0xD736FCCCL,
     525             :             0x83426B33L, 0xF01EAB71L, 0xB0804187L, 0x3C005E5FL,
     526             :             0x77A057BEL, 0xBDE8AE24L, 0x55464299L, 0xBF582E61L,
     527             : 
     528             :             0x4E58F48FL, 0xF2DDFDA2L, 0xF474EF38L, 0x8789BDC2L,
     529             :             0x5366F9C3L, 0xC8B38E74L, 0xB475F255L, 0x46FCD9B9L,
     530             :             0x7AEB2661L, 0x8B1DDF84L, 0x846A0E79L, 0x915F95E2L,
     531             :             0x466E598EL, 0x20B45770L, 0x8CD55591L, 0xC902DE4CL,
     532             : 
     533             :             0xB90BACE1L, 0xBB8205D0L, 0x11A86248L, 0x7574A99EL,
     534             :             0xB77F19B6L, 0xE0A9DC09L, 0x662D09A1L, 0xC4324633L,
     535             :             0xE85A1F02L, 0x09F0BE8CL, 0x4A99A025L, 0x1D6EFE10L,
     536             :             0x1AB93D1DL, 0x0BA5A4DFL, 0xA186F20FL, 0x2868F169L,
     537             : 
     538             :             0xDCB7DA83L, 0x573906FEL, 0xA1E2CE9BL, 0x4FCD7F52L,
     539             :             0x50115E01L, 0xA70683FAL, 0xA002B5C4L, 0x0DE6D027L,
     540             :             0x9AF88C27L, 0x773F8641L, 0xC3604C06L, 0x61A806B5L,
     541             :             0xF0177A28L, 0xC0F586E0L, 0x006058AAL, 0x30DC7D62L,
     542             : 
     543             :             0x11E69ED7L, 0x2338EA63L, 0x53C2DD94L, 0xC2C21634L,
     544             :             0xBBCBEE56L, 0x90BCB6DEL, 0xEBFC7DA1L, 0xCE591D76L,
     545             :             0x6F05E409L, 0x4B7C0188L, 0x39720A3DL, 0x7C927C24L,
     546             :             0x86E3725FL, 0x724D9DB9L, 0x1AC15BB4L, 0xD39EB8FCL,
     547             : 
     548             :             0xED545578L, 0x08FCA5B5L, 0xD83D7CD3L, 0x4DAD0FC4L,
     549             :             0x1E50EF5EL, 0xB161E6F8L, 0xA28514D9L, 0x6C51133CL,
     550             :             0x6FD5C7E7L, 0x56E14EC4L, 0x362ABFCEL, 0xDDC6C837L,
     551             :             0xD79A3234L, 0x92638212L, 0x670EFA8EL, 0x406000E0L
     552             :         },
     553             : 
     554             :         /* S[3] */
     555             :         {
     556             :             0x3A39CE37L, 0xD3FAF5CFL, 0xABC27737L, 0x5AC52D1BL,
     557             :             0x5CB0679EL, 0x4FA33742L, 0xD3822740L, 0x99BC9BBEL,
     558             :             0xD5118E9DL, 0xBF0F7315L, 0xD62D1C7EL, 0xC700C47BL,
     559             :             0xB78C1B6BL, 0x21A19045L, 0xB26EB1BEL, 0x6A366EB4L,
     560             : 
     561             :             0x5748AB2FL, 0xBC946E79L, 0xC6A376D2L, 0x6549C2C8L,
     562             :             0x530FF8EEL, 0x468DDE7DL, 0xD5730A1DL, 0x4CD04DC6L,
     563             :             0x2939BBDBL, 0xA9BA4650L, 0xAC9526E8L, 0xBE5EE304L,
     564             :             0xA1FAD5F0L, 0x6A2D519AL, 0x63EF8CE2L, 0x9A86EE22L,
     565             : 
     566             :             0xC089C2B8L, 0x43242EF6L, 0xA51E03AAL, 0x9CF2D0A4L,
     567             :             0x83C061BAL, 0x9BE96A4DL, 0x8FE51550L, 0xBA645BD6L,
     568             :             0x2826A2F9L, 0xA73A3AE1L, 0x4BA99586L, 0xEF5562E9L,
     569             :             0xC72FEFD3L, 0xF752F7DAL, 0x3F046F69L, 0x77FA0A59L,
     570             : 
     571             :             0x80E4A915L, 0x87B08601L, 0x9B09E6ADL, 0x3B3EE593L,
     572             :             0xE990FD5AL, 0x9E34D797L, 0x2CF0B7D9L, 0x022B8B51L,
     573             :             0x96D5AC3AL, 0x017DA67DL, 0xD1CF3ED6L, 0x7C7D2D28L,
     574             :             0x1F9F25CFL, 0xADF2B89BL, 0x5AD6B472L, 0x5A88F54CL,
     575             : 
     576             :             0xE029AC71L, 0xE019A5E6L, 0x47B0ACFDL, 0xED93FA9BL,
     577             :             0xE8D3C48DL, 0x283B57CCL, 0xF8D56629L, 0x79132E28L,
     578             :             0x785F0191L, 0xED756055L, 0xF7960E44L, 0xE3D35E8CL,
     579             :             0x15056DD4L, 0x88F46DBAL, 0x03A16125L, 0x0564F0BDL,
     580             : 
     581             :             0xC3EB9E15L, 0x3C9057A2L, 0x97271AECL, 0xA93A072AL,
     582             :             0x1B3F6D9BL, 0x1E6321F5L, 0xF59C66FBL, 0x26DCF319L,
     583             :             0x7533D928L, 0xB155FDF5L, 0x03563482L, 0x8ABA3CBBL,
     584             :             0x28517711L, 0xC20AD9F8L, 0xABCC5167L, 0xCCAD925FL,
     585             : 
     586             :             0x4DE81751L, 0x3830DC8EL, 0x379D5862L, 0x9320F991L,
     587             :             0xEA7A90C2L, 0xFB3E7BCEL, 0x5121CE64L, 0x774FBE32L,
     588             :             0xA8B6E37EL, 0xC3293D46L, 0x48DE5369L, 0x6413E680L,
     589             :             0xA2AE0810L, 0xDD6DB224L, 0x69852DFDL, 0x09072166L,
     590             : 
     591             :             0xB39A460AL, 0x6445C0DDL, 0x586CDECFL, 0x1C20C8AEL,
     592             :             0x5BBEF7DDL, 0x1B588D40L, 0xCCD2017FL, 0x6BB4E3BBL,
     593             :             0xDDA26A7EL, 0x3A59FF45L, 0x3E350A44L, 0xBCB4CDD5L,
     594             :             0x72EACEA8L, 0xFA6484BBL, 0x8D6612AEL, 0xBF3C6F47L,
     595             : 
     596             :             0xD29BE463L, 0x542F5D9EL, 0xAEC2771BL, 0xF64E6370L,
     597             :             0x740E0D8DL, 0xE75B1357L, 0xF8721671L, 0xAF537D5DL,
     598             :             0x4040CB08L, 0x4EB4E2CCL, 0x34D2466AL, 0x0115AF84L,
     599             :             0xE1B00428L, 0x95983A1DL, 0x06B89FB4L, 0xCE6EA048L,
     600             : 
     601             :             0x6F3F3B82L, 0x3520AB82L, 0x011A1D4BL, 0x277227F8L,
     602             :             0x611560B1L, 0xE7933FDCL, 0xBB3A792BL, 0x344525BDL,
     603             :             0xA08839E1L, 0x51CE794BL, 0x2F32C9B7L, 0xA01FBAC9L,
     604             :             0xE01CC87EL, 0xBCC7D1F6L, 0xCF0111C3L, 0xA1E8AAC7L,
     605             : 
     606             :             0x1A908749L, 0xD44FBD9AL, 0xD0DADECBL, 0xD50ADA38L,
     607             :             0x0339C32AL, 0xC6913667L, 0x8DF9317CL, 0xE0B12B4FL,
     608             :             0xF79E59B7L, 0x43F5BB3AL, 0xF2D519FFL, 0x27D9459CL,
     609             :             0xBF97222CL, 0x15E6FC2AL, 0x0F91FC71L, 0x9B941525L,
     610             : 
     611             :             0xFAE59361L, 0xCEB69CEBL, 0xC2A86459L, 0x12BAA8D1L,
     612             :             0xB6C1075EL, 0xE3056A0CL, 0x10D25065L, 0xCB03A442L,
     613             :             0xE0EC6E0EL, 0x1698DB3BL, 0x4C98A0BEL, 0x3278E964L,
     614             :             0x9F1F9532L, 0xE0D392DFL, 0xD3A0342BL, 0x8971F21EL,
     615             : 
     616             :             0x1B0A7441L, 0x4BA3348CL, 0xC5BE7120L, 0xC37632D8L,
     617             :             0xDF359F8DL, 0x9B992F2EL, 0xE60B6F47L, 0x0FE3F11DL,
     618             :             0xE54CDA54L, 0x1EDAD891L, 0xCE6279CFL, 0xCD3E7E6FL,
     619             :             0x1618B166L, 0xFD2C1D05L, 0x848FD2C5L, 0xF6FB2299L,
     620             : 
     621             :             0xF523F357L, 0xA6327623L, 0x93A83531L, 0x56CCCD02L,
     622             :             0xACF08162L, 0x5A75EBB5L, 0x6E163697L, 0x88D273CCL,
     623             :             0xDE966292L, 0x81B949D0L, 0x4C50901BL, 0x71C65614L,
     624             :             0xE6C6C7BDL, 0x327A140AL, 0x45E1D006L, 0xC3F27B9AL,
     625             : 
     626             :             0xC9AA53FDL, 0x62A80F00L, 0xBB25BFE2L, 0x35BDD2F6L,
     627             :             0x71126905L, 0xB2040222L, 0xB6CBCF7CL, 0xCD769C2BL,
     628             :             0x53113EC0L, 0x1640E3D3L, 0x38ABBD60L, 0x2547ADF0L,
     629             :             0xBA38209CL, 0xF746CE76L, 0x77AFA1C5L, 0x20756060L,
     630             : 
     631             :             0x85CBFE4EL, 0x8AE88DD8L, 0x7AAAF9B0L, 0x4CF9AA7EL,
     632             :             0x1948C25CL, 0x02FB8A8CL, 0x01C36AE4L, 0xD6EBE1F9L,
     633             :             0x90D4F869L, 0xA65CDEA0L, 0x3F09252DL, 0xC208E69FL,
     634             :             0xB74E6132L, 0xCE77E25BL, 0x578FDFE3L, 0x3AC372E6L
     635             :         }
     636             :     },
     637             : 
     638             :     /* P */
     639             :     {
     640             :         0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L,
     641             :         0xA4093822L, 0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L,
     642             :         0x452821E6L, 0x38D01377L, 0xBE5466CFL, 0x34E90C6CL,
     643             :         0xC0AC29B7L, 0xC97C50DDL, 0x3F84D5B5L, 0xB5470917L,
     644             :         0x9216D5D9L, 0x8979FB1BL
     645             :     }
     646             : };
     647             : 
     648             : /*
     649             :  * __rtl_cipherBF_init.
     650             :  */
     651          75 : static rtlCipherError __rtl_cipherBF_init (
     652             :     CipherContextBF *ctx,
     653             :     rtlCipherMode    eMode,
     654             :     const sal_uInt8 *pKeyData, sal_Size nKeyLen,
     655             :     const sal_uInt8 *pArgData, sal_Size nArgLen)
     656             : {
     657             :     CipherKeyBF *key;
     658             :     sal_uInt32   D, DL, DR;
     659             :     sal_uInt16   i, j, k;
     660             : 
     661          75 :     key = &(ctx->m_key);
     662             : 
     663          75 :     memcpy (key, &__rtl_cipherBF_key, sizeof (CipherKeyBF));
     664          75 :     memset (&(ctx->m_iv), 0, sizeof(ctx->m_iv));
     665          75 :     ctx->m_offset = 0;
     666             : 
     667        1425 :     for (i = 0, k = 0; i < CIPHER_ROUNDS_BF + 2; ++i)
     668             :     {
     669        1350 :         D = 0;
     670        6750 :         for (j = 0; j < 4; ++j)
     671             :         {
     672        5400 :             D = ((D << 8) | pKeyData[k]);
     673        5400 :             k++;
     674        5400 :             if (k >= nKeyLen)
     675         300 :                 k = 0;
     676             :         }
     677        1350 :         key->m_P[i] ^= D;
     678             :     }
     679             : 
     680          75 :     DL = 0;
     681          75 :     DR = 0;
     682             : 
     683         750 :     for (i = 0; i < CIPHER_ROUNDS_BF + 2; i += 2)
     684             :     {
     685         675 :         __rtl_cipherBF_encode (key, &DL, &DR);
     686         675 :         key->m_P[i    ] = DL;
     687         675 :         key->m_P[i + 1] = DR;
     688             :     }
     689             : 
     690         375 :     for (i = 0; i < 4; ++i)
     691             :     {
     692       38700 :         for (k = 0; k < 256; k += 2)
     693             :         {
     694       38400 :             __rtl_cipherBF_encode (key, &DL, &DR);
     695       38400 :             key->m_S[i][k    ] = DL;
     696       38400 :             key->m_S[i][k + 1] = DR;
     697             :         }
     698             :     }
     699             : 
     700          75 :     if (pArgData && nArgLen)
     701             :     {
     702          28 :         nArgLen = ((nArgLen < 8) ? nArgLen : 8);
     703          28 :         if (eMode == rtl_Cipher_ModeStream)
     704             :         {
     705           8 :             memcpy (ctx->m_iv.m_byte, pArgData, nArgLen);
     706             :         }
     707             :         else
     708             :         {
     709          20 :             RTL_CIPHER_NTOHL64 (pArgData, DL, DR, nArgLen);
     710          20 :             ctx->m_iv.m_long[0] = DL;
     711          20 :             ctx->m_iv.m_long[1] = DR;
     712             :         }
     713             :     }
     714             : 
     715          75 :     return rtl_Cipher_E_None;
     716             : }
     717             : 
     718             : /*
     719             :  * __rtl_cipherBF_update.
     720             :  */
     721          75 : static rtlCipherError __rtl_cipherBF_update (
     722             :     CipherContextBF    *ctx,
     723             :     rtlCipherMode       eMode,
     724             :     rtlCipherDirection  eDirection,
     725             :     const sal_uInt8    *pData,   sal_Size nDatLen,
     726             :     sal_uInt8          *pBuffer, sal_Size nBufLen)
     727             : {
     728             :     /* Check arguments. */
     729          75 :     if ((pData == NULL) || (pBuffer == NULL))
     730           0 :         return rtl_Cipher_E_Argument;
     731             : 
     732          75 :     if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
     733           0 :         return rtl_Cipher_E_BufferSize;
     734             : 
     735             :     /* Update. */
     736          75 :     if (eMode == rtl_Cipher_ModeECB)
     737             :     {
     738             :         /* Block mode. */
     739          60 :         while (nDatLen > 8)
     740             :         {
     741          20 :             __rtl_cipherBF_updateECB (ctx, eDirection, pData, pBuffer, 8);
     742          20 :             nDatLen -= 8;
     743          20 :             pData   += 8;
     744          20 :             pBuffer += 8;
     745             :         }
     746          20 :         __rtl_cipherBF_updateECB (ctx, eDirection, pData, pBuffer, nDatLen);
     747             :     }
     748          55 :     else if (eMode == rtl_Cipher_ModeCBC)
     749             :     {
     750             :         /* Block mode. */
     751           0 :         while (nDatLen > 8)
     752             :         {
     753           0 :             __rtl_cipherBF_updateCBC (ctx, eDirection, pData, pBuffer, 8);
     754           0 :             nDatLen -= 8;
     755           0 :             pData   += 8;
     756           0 :             pBuffer += 8;
     757             :         }
     758           0 :         __rtl_cipherBF_updateCBC (ctx, eDirection, pData, pBuffer, nDatLen);
     759             :     }
     760             :     else
     761             :     {
     762             :         /* Stream mode. */
     763        8004 :         while (nDatLen > 0)
     764             :         {
     765        7894 :             __rtl_cipherBF_updateCFB (ctx, eDirection, pData, pBuffer);
     766        7894 :             nDatLen -= 1;
     767        7894 :             pData   += 1;
     768        7894 :             pBuffer += 1;
     769             :         }
     770             :     }
     771          75 :     return rtl_Cipher_E_None;
     772             : }
     773             : 
     774             : /*
     775             :  * __rtl_cipherBF_updateECB.
     776             :  */
     777          40 : static void __rtl_cipherBF_updateECB (
     778             :     CipherContextBF    *ctx,
     779             :     rtlCipherDirection  direction,
     780             :     const sal_uInt8    *pData,
     781             :     sal_uInt8          *pBuffer,
     782             :     sal_Size            nLength)
     783             : {
     784             :     CipherKeyBF *key;
     785             :     sal_uInt32   DL, DR;
     786             : 
     787          40 :     key = &(ctx->m_key);
     788          40 :     if (direction == rtl_Cipher_DirectionEncode)
     789             :     {
     790          32 :         RTL_CIPHER_NTOHL64(pData, DL, DR, nLength);
     791             : 
     792          32 :         __rtl_cipherBF_encode (key, &DL, &DR);
     793             : 
     794          32 :         RTL_CIPHER_HTONL(DL, pBuffer);
     795          32 :         RTL_CIPHER_HTONL(DR, pBuffer);
     796             :     }
     797             :     else
     798             :     {
     799           8 :         RTL_CIPHER_NTOHL(pData, DL);
     800           8 :         RTL_CIPHER_NTOHL(pData, DR);
     801             : 
     802           8 :         __rtl_cipherBF_decode (key, &DL, &DR);
     803             : 
     804           8 :         RTL_CIPHER_HTONL64(DL, DR, pBuffer, nLength);
     805             :     }
     806          40 :     DL = DR = 0;
     807          40 : }
     808             : 
     809             : /*
     810             :  * __rtl_cipherBF_updateCBC.
     811             :  */
     812           0 : static void __rtl_cipherBF_updateCBC (
     813             :     CipherContextBF    *ctx,
     814             :     rtlCipherDirection  direction,
     815             :     const sal_uInt8    *pData,
     816             :     sal_uInt8          *pBuffer,
     817             :     sal_Size            nLength)
     818             : {
     819             :     CipherKeyBF *key;
     820             :     sal_uInt32   DL, DR;
     821             : 
     822           0 :     key = &(ctx->m_key);
     823           0 :     if (direction == rtl_Cipher_DirectionEncode)
     824             :     {
     825           0 :         RTL_CIPHER_NTOHL64(pData, DL, DR, nLength);
     826             : 
     827           0 :         DL ^= ctx->m_iv.m_long[0];
     828           0 :         DR ^= ctx->m_iv.m_long[1];
     829             : 
     830           0 :         __rtl_cipherBF_encode (key, &DL, &DR);
     831             : 
     832           0 :         ctx->m_iv.m_long[0] = DL;
     833           0 :         ctx->m_iv.m_long[1] = DR;
     834             : 
     835           0 :         RTL_CIPHER_HTONL(DL, pBuffer);
     836           0 :         RTL_CIPHER_HTONL(DR, pBuffer);
     837             :     }
     838             :     else
     839             :     {
     840             :         sal_uInt32 IVL, IVR;
     841             : 
     842           0 :         RTL_CIPHER_NTOHL(pData, DL);
     843           0 :         RTL_CIPHER_NTOHL(pData, DR);
     844             : 
     845           0 :         IVL = DL;
     846           0 :         IVR = DR;
     847             : 
     848           0 :         __rtl_cipherBF_decode (key, &DL, &DR);
     849             : 
     850           0 :         DL ^= ctx->m_iv.m_long[0];
     851           0 :         DR ^= ctx->m_iv.m_long[1];
     852             : 
     853           0 :         ctx->m_iv.m_long[0] = IVL;
     854           0 :         ctx->m_iv.m_long[1] = IVR;
     855             : 
     856           0 :         RTL_CIPHER_HTONL64(DL, DR, pBuffer, nLength);
     857             :     }
     858           0 :     DL = DR = 0;
     859           0 : }
     860             : 
     861             : /*
     862             :  * __rtl_cipherBF_updateCFB.
     863             :  */
     864        7894 : static void __rtl_cipherBF_updateCFB (
     865             :     CipherContextBF    *ctx,
     866             :     rtlCipherDirection  direction,
     867             :     const sal_uInt8    *pData,
     868             :     sal_uInt8          *pBuffer)
     869             : {
     870             :     sal_uInt8  *iv;
     871             :     sal_uInt32  k;
     872             : 
     873        7894 :     iv = ctx->m_iv.m_byte;
     874        7894 :     k  = ctx->m_offset;
     875             : 
     876        7894 :     if (k == 0)
     877             :     {
     878             :         sal_uInt32 IVL, IVR;
     879             : 
     880        1032 :         RTL_CIPHER_NTOHL64(iv, IVL, IVR, 8);
     881        1032 :         __rtl_cipherBF_encode (&(ctx->m_key), &IVL, &IVR);
     882        1032 :         RTL_CIPHER_HTONL64(IVL, IVR, iv, 8);
     883             : 
     884        1032 :         IVL = IVR = 0;
     885             :     }
     886             : 
     887        7894 :     if (direction == rtl_Cipher_DirectionEncode)
     888             :     {
     889         491 :         iv[k] ^= *pData;
     890         491 :         *pBuffer = iv[k];
     891             :     }
     892             :     else
     893             :     {
     894        7403 :         sal_uInt8 c = iv[k];
     895        7403 :         iv[k] = *pData;
     896        7403 :         *pBuffer = *pData ^ c;
     897             :     }
     898             : 
     899        7894 :     ctx->m_offset = ((k + 1) & 0x07);
     900        7894 :     iv = NULL;
     901        7894 : }
     902             : 
     903             : /*
     904             :  * __rtl_cipherBF_encode.
     905             :  */
     906       40139 : static void __rtl_cipherBF_encode (
     907             :     CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr)
     908             : {
     909             :     sal_uInt32  t, XL, XR;
     910             :     sal_uInt16  i;
     911             : 
     912       40139 :     XL = *xl;
     913       40139 :     XR = *xr;
     914             : 
     915      682363 :     for (i = 0; i < CIPHER_ROUNDS_BF; ++i)
     916             :     {
     917      642224 :         XL ^= key->m_P[i];
     918      642224 :         XR ^= __rtl_cipherBF (key, XL);
     919             : 
     920      642224 :         t  = XL;
     921      642224 :         XL = XR;
     922      642224 :         XR = t;
     923             :     }
     924             : 
     925       40139 :     t  = XL;
     926       40139 :     XL = XR;
     927       40139 :     XR = t;
     928             : 
     929       40139 :     XR ^= key->m_P[CIPHER_ROUNDS_BF    ];
     930       40139 :     XL ^= key->m_P[CIPHER_ROUNDS_BF + 1];
     931             : 
     932       40139 :     *xl = XL;
     933       40139 :     *xr = XR;
     934             : 
     935       40139 : }
     936             : 
     937             : /*
     938             :  * __rtl_cipherBF_decode.
     939             :  */
     940           8 : static void __rtl_cipherBF_decode (
     941             :     CipherKeyBF *key, sal_uInt32 *xl, sal_uInt32 *xr)
     942             : {
     943             :     sal_uInt32  t, XL, XR;
     944             :     sal_uInt16  i;
     945             : 
     946           8 :     XL = *xl;
     947           8 :     XR = *xr;
     948             : 
     949         136 :     for (i = CIPHER_ROUNDS_BF + 1; i > 1; --i)
     950             :     {
     951         128 :         XL ^= key->m_P[i];
     952         128 :         XR ^= __rtl_cipherBF (key, XL);
     953             : 
     954         128 :         t  = XL;
     955         128 :         XL = XR;
     956         128 :         XR = t;
     957             :     }
     958             : 
     959           8 :     t  = XL;
     960           8 :     XL = XR;
     961           8 :     XR = t;
     962             : 
     963           8 :     XR ^= key->m_P[1];
     964           8 :     XL ^= key->m_P[0];
     965             : 
     966           8 :     *xl = XL;
     967           8 :     *xr = XR;
     968             : 
     969           8 : }
     970             : 
     971             : /*
     972             :  * __rtl_cipherBF.
     973             :  */
     974      642352 : static sal_uInt32 __rtl_cipherBF (CipherKeyBF *key, sal_uInt32 x)
     975             : {
     976             :     sal_uInt16 a, b, c, d;
     977             :     sal_uInt32 y;
     978             : 
     979      642352 :     d = (sal_uInt16)(x & 0x00ff);
     980      642352 :     x >>= 8;
     981      642352 :     c = (sal_uInt16)(x & 0x00ff);
     982      642352 :     x >>= 8;
     983      642352 :     b = (sal_uInt16)(x & 0x00ff);
     984      642352 :     x >>= 8;
     985      642352 :     a = (sal_uInt16)(x & 0x00ff);
     986             : 
     987      642352 :     y  = key->m_S[0][a];
     988      642352 :     y += key->m_S[1][b];
     989      642352 :     y ^= key->m_S[2][c];
     990      642352 :     y += key->m_S[3][d];
     991             : 
     992      642352 :     return y;
     993             : }
     994             : 
     995             : /*========================================================================
     996             :  *
     997             :  * rtl_cipherBF (Blowfish) implementation.
     998             :  *
     999             :  * Reference:
    1000             :  *   Bruce Schneier: Applied Cryptography, 2nd edition, ch. 14.3
    1001             :  *
    1002             :  *======================================================================*/
    1003             : /*
    1004             :  * rtl_cipher_createBF.
    1005             :  */
    1006          85 : rtlCipher SAL_CALL rtl_cipher_createBF (rtlCipherMode Mode) SAL_THROW_EXTERN_C()
    1007             : {
    1008          85 :     CipherBF_Impl *pImpl = nullptr;
    1009             : 
    1010          85 :     if (Mode == rtl_Cipher_ModeInvalid)
    1011           2 :         return (nullptr);
    1012             : 
    1013          83 :     pImpl = static_cast<CipherBF_Impl*>(rtl_allocateZeroMemory (sizeof (CipherBF_Impl)));
    1014          83 :     if (pImpl)
    1015             :     {
    1016          83 :         pImpl->m_cipher.m_algorithm = rtl_Cipher_AlgorithmBF;
    1017          83 :         pImpl->m_cipher.m_direction = rtl_Cipher_DirectionInvalid;
    1018          83 :         pImpl->m_cipher.m_mode      = Mode;
    1019             : 
    1020          83 :         pImpl->m_cipher.m_init      = rtl_cipher_initBF;
    1021          83 :         pImpl->m_cipher.m_encode    = rtl_cipher_encodeBF;
    1022          83 :         pImpl->m_cipher.m_decode    = rtl_cipher_decodeBF;
    1023          83 :         pImpl->m_cipher.m_delete    = rtl_cipher_destroyBF;
    1024             :     }
    1025          83 :     return (static_cast<rtlCipher>(pImpl));
    1026             : }
    1027             : 
    1028             : /*
    1029             :  * rtl_cipher_initBF.
    1030             :  */
    1031          75 : rtlCipherError SAL_CALL rtl_cipher_initBF (
    1032             :     rtlCipher          Cipher,
    1033             :     rtlCipherDirection Direction,
    1034             :     const sal_uInt8 *pKeyData, sal_Size nKeyLen,
    1035             :     const sal_uInt8 *pArgData, sal_Size nArgLen) SAL_THROW_EXTERN_C()
    1036             : {
    1037          75 :     CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
    1038             : 
    1039          75 :     if ((pImpl == NULL) || (pKeyData == NULL))
    1040           0 :         return rtl_Cipher_E_Argument;
    1041             : 
    1042          75 :     if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
    1043           0 :         return rtl_Cipher_E_Algorithm;
    1044             : 
    1045          75 :     if (!(Direction == rtl_Cipher_DirectionInvalid))
    1046          75 :         pImpl->m_cipher.m_direction = Direction;
    1047             :     else
    1048           0 :         return rtl_Cipher_E_Direction;
    1049             : 
    1050             :     return __rtl_cipherBF_init (
    1051             :         &(pImpl->m_context), pImpl->m_cipher.m_mode,
    1052          75 :         pKeyData, nKeyLen, pArgData, nArgLen);
    1053             : }
    1054             : 
    1055             : /*
    1056             :  * rtl_cipher_encodeBF.
    1057             :  */
    1058          43 : rtlCipherError SAL_CALL rtl_cipher_encodeBF (
    1059             :     rtlCipher   Cipher,
    1060             :     const void *pData,   sal_Size nDatLen,
    1061             :     sal_uInt8  *pBuffer, sal_Size nBufLen) SAL_THROW_EXTERN_C()
    1062             : {
    1063          43 :     CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
    1064          43 :     if (pImpl == NULL)
    1065           0 :         return rtl_Cipher_E_Argument;
    1066             : 
    1067          43 :     if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
    1068           0 :         return rtl_Cipher_E_Algorithm;
    1069             : 
    1070          43 :     if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
    1071           0 :         return rtl_Cipher_E_Direction;
    1072          43 :     if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionDecode)
    1073           0 :         return rtl_Cipher_E_Direction;
    1074             : 
    1075             :     return __rtl_cipherBF_update (
    1076             :         &(pImpl->m_context), pImpl->m_cipher.m_mode,
    1077             :         rtl_Cipher_DirectionEncode,
    1078          43 :         static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
    1079             : }
    1080             : 
    1081             : /*
    1082             :  * rtl_cipher_decodeBF.
    1083             :  */
    1084          36 : rtlCipherError SAL_CALL rtl_cipher_decodeBF (
    1085             :     rtlCipher   Cipher,
    1086             :     const void *pData,   sal_Size nDatLen,
    1087             :     sal_uInt8  *pBuffer, sal_Size nBufLen) SAL_THROW_EXTERN_C()
    1088             : {
    1089          36 :     CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
    1090          36 :     if (pImpl == NULL)
    1091           0 :         return rtl_Cipher_E_Argument;
    1092             : 
    1093          36 :     if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF))
    1094           0 :         return rtl_Cipher_E_Algorithm;
    1095             : 
    1096          36 :     if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
    1097           0 :         return rtl_Cipher_E_Direction;
    1098          36 :     if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionEncode)
    1099           4 :         return rtl_Cipher_E_Direction;
    1100             : 
    1101             :     return __rtl_cipherBF_update (
    1102             :         &(pImpl->m_context), pImpl->m_cipher.m_mode,
    1103             :         rtl_Cipher_DirectionDecode,
    1104          32 :         static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
    1105             : }
    1106             : 
    1107             : /*
    1108             :  * rtl_cipher_destroyBF.
    1109             :  */
    1110          83 : void SAL_CALL rtl_cipher_destroyBF (rtlCipher Cipher) SAL_THROW_EXTERN_C()
    1111             : {
    1112          83 :     CipherBF_Impl *pImpl = static_cast<CipherBF_Impl*>(Cipher);
    1113          83 :     if (pImpl)
    1114             :     {
    1115          83 :         if (pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmBF)
    1116          83 :             rtl_freeZeroMemory (pImpl, sizeof (CipherBF_Impl));
    1117             :         else
    1118           0 :             rtl_freeMemory (pImpl);
    1119             :     }
    1120          83 : }
    1121             : 
    1122             : /*========================================================================
    1123             :  *
    1124             :  * rtl_cipher_ARCFOUR (RC4) internals.
    1125             :  *
    1126             :  *======================================================================*/
    1127             : #define CIPHER_CBLOCK_ARCFOUR 256
    1128             : 
    1129             : struct ContextARCFOUR_Impl
    1130             : {
    1131             :     unsigned int m_S[CIPHER_CBLOCK_ARCFOUR];
    1132             :     unsigned int m_X, m_Y;
    1133             : };
    1134             : 
    1135             : struct CipherARCFOUR_Impl
    1136             : {
    1137             :     Cipher_Impl         m_cipher;
    1138             :     ContextARCFOUR_Impl m_context;
    1139             : };
    1140             : 
    1141             : /** rtl_cipherARCFOUR_update_Impl.
    1142             :  */
    1143             : static rtlCipherError rtl_cipherARCFOUR_update_Impl (
    1144             :     ContextARCFOUR_Impl *ctx,
    1145             :     const sal_uInt8     *pData,   sal_Size nDatLen,
    1146             :     sal_uInt8           *pBuffer, sal_Size nBufLen);
    1147             : 
    1148             : /*
    1149             :  * rtl_cipherARCFOUR_init_Impl.
    1150             :  */
    1151         169 : static rtlCipherError rtl_cipherARCFOUR_init_Impl (
    1152             :     ContextARCFOUR_Impl *ctx,
    1153             :     const sal_uInt8     *pKeyData, sal_Size nKeyLen)
    1154             : {
    1155             :     unsigned int  K[CIPHER_CBLOCK_ARCFOUR];
    1156             :     unsigned int *L, *S;
    1157             :     unsigned int  x, y, t;
    1158             :     sal_Size      n, k;
    1159             : 
    1160         169 :     S = &(ctx->m_S[0]);
    1161             : 
    1162             :     /* Initialize S linearly. */
    1163       43433 :     for (x = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
    1164       43264 :         S[x] = x;
    1165             : 
    1166             :     /* Initialize K with key, repeat key as necessary. */
    1167       14534 :     for (L = K, n = CIPHER_CBLOCK_ARCFOUR; n > nKeyLen; n -= nKeyLen)
    1168             :     {
    1169       14365 :         for (k = 0; k < nKeyLen; k++) L[k] = pKeyData[k];
    1170       14365 :         L += nKeyLen;
    1171             :     }
    1172         169 :     for (k = 0; k < n; k++) L[k] = pKeyData[k];
    1173             : 
    1174             :     /* Initialize S with K. */
    1175       43433 :     for (x = 0, y = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
    1176             :     {
    1177       43264 :         y = (y + S[x] + K[x]) % CIPHER_CBLOCK_ARCFOUR;
    1178       43264 :         t = S[x], S[x] = S[y], S[y] = t; /* swap S[x] and S[y] */
    1179             :     }
    1180             : 
    1181             :     /* Initialize counters X and Y. */
    1182         169 :     ctx->m_X = 0;
    1183         169 :     ctx->m_Y = 0;
    1184             : 
    1185         169 :     return rtl_Cipher_E_None;
    1186             : }
    1187             : 
    1188             : /*
    1189             :  * rtl_cipherARCFOUR_update_Impl.
    1190             :  */
    1191        4134 : static rtlCipherError rtl_cipherARCFOUR_update_Impl (
    1192             :     ContextARCFOUR_Impl *ctx,
    1193             :     const sal_uInt8     *pData,   sal_Size nDatLen,
    1194             :     sal_uInt8           *pBuffer, sal_Size nBufLen)
    1195             : {
    1196             :     unsigned int *S;
    1197             :     unsigned int t;
    1198             :     sal_Size               k;
    1199             : 
    1200             :     /* Check arguments. */
    1201        4134 :     if ((pData == NULL) || (pBuffer == NULL))
    1202           0 :         return rtl_Cipher_E_Argument;
    1203             : 
    1204        4134 :     if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
    1205           0 :         return rtl_Cipher_E_BufferSize;
    1206             : 
    1207             :     /* Update. */
    1208        4134 :     S = &(ctx->m_S[0]);
    1209    33045170 :     for (k = 0; k < nDatLen; k++)
    1210             :     {
    1211             :         /* Update counters X and Y. */
    1212    33041036 :         unsigned int x = ctx->m_X;
    1213    33041036 :         unsigned int y = ctx->m_Y;
    1214    33041036 :         x = (x + 1   ) % CIPHER_CBLOCK_ARCFOUR;
    1215    33041036 :         y = (y + S[x]) % CIPHER_CBLOCK_ARCFOUR;
    1216    33041036 :         ctx->m_X = x;
    1217    33041036 :         ctx->m_Y = y;
    1218             : 
    1219             :         /* Swap S[x] and S[y]. */
    1220    33041036 :         t = S[x], S[x] = S[y], S[y] = t;
    1221             : 
    1222             :         /* Evaluate next key byte S[t]. */
    1223    33041036 :         t = (S[x] + S[y]) % CIPHER_CBLOCK_ARCFOUR;
    1224    33041036 :         pBuffer[k] = pData[k] ^ ((sal_uInt8)(S[t] & 0xff));
    1225             :     }
    1226             : 
    1227        4134 :     return rtl_Cipher_E_None;
    1228             : }
    1229             : 
    1230             : /*========================================================================
    1231             :  *
    1232             :  * rtl_cipher_ARCFOUR (RC4) implementation.
    1233             :  *
    1234             :  * Reference:
    1235             :  *   Bruce Schneier: Applied Cryptography, 2nd edition, ch. 17.1
    1236             :  *
    1237             :  *======================================================================*/
    1238             : /*
    1239             :  * rtl_cipher_createARCFOUR.
    1240             :  */
    1241         201 : rtlCipher SAL_CALL rtl_cipher_createARCFOUR (rtlCipherMode Mode)
    1242             :     SAL_THROW_EXTERN_C()
    1243             : {
    1244         201 :     CipherARCFOUR_Impl *pImpl = nullptr;
    1245             : 
    1246         201 :     if (!(Mode == rtl_Cipher_ModeStream))
    1247           0 :         return (nullptr);
    1248             : 
    1249         201 :     pImpl = static_cast<CipherARCFOUR_Impl*>(rtl_allocateZeroMemory (sizeof (CipherARCFOUR_Impl)));
    1250         201 :     if (pImpl)
    1251             :     {
    1252         201 :         pImpl->m_cipher.m_algorithm = rtl_Cipher_AlgorithmARCFOUR;
    1253         201 :         pImpl->m_cipher.m_direction = rtl_Cipher_DirectionInvalid;
    1254         201 :         pImpl->m_cipher.m_mode      = rtl_Cipher_ModeStream;
    1255             : 
    1256         201 :         pImpl->m_cipher.m_init      = rtl_cipher_initARCFOUR;
    1257         201 :         pImpl->m_cipher.m_encode    = rtl_cipher_encodeARCFOUR;
    1258         201 :         pImpl->m_cipher.m_decode    = rtl_cipher_decodeARCFOUR;
    1259         201 :         pImpl->m_cipher.m_delete    = rtl_cipher_destroyARCFOUR;
    1260             :     }
    1261         201 :     return (static_cast<rtlCipher>(pImpl));
    1262             : }
    1263             : 
    1264             : /*
    1265             :  * rtl_cipher_initARCFOUR.
    1266             :  */
    1267         169 : rtlCipherError SAL_CALL rtl_cipher_initARCFOUR (
    1268             :     rtlCipher          Cipher,
    1269             :     rtlCipherDirection Direction,
    1270             :     const sal_uInt8 *pKeyData, sal_Size nKeyLen,
    1271             :     SAL_UNUSED_PARAMETER const sal_uInt8 *, SAL_UNUSED_PARAMETER sal_Size)
    1272             :     SAL_THROW_EXTERN_C()
    1273             : {
    1274         169 :     CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
    1275             : 
    1276         169 :     if ((pImpl == NULL) || (pKeyData == NULL))
    1277           0 :         return rtl_Cipher_E_Argument;
    1278             : 
    1279         169 :     if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
    1280           0 :         return rtl_Cipher_E_Algorithm;
    1281             : 
    1282         169 :     if (!(Direction == rtl_Cipher_DirectionInvalid))
    1283         169 :         pImpl->m_cipher.m_direction = Direction;
    1284             :     else
    1285           0 :         return rtl_Cipher_E_Direction;
    1286             : 
    1287         169 :     return rtl_cipherARCFOUR_init_Impl (&(pImpl->m_context), pKeyData, nKeyLen);
    1288             : }
    1289             : 
    1290             : /*
    1291             :  * rtl_cipher_encodeARCFOUR.
    1292             :  */
    1293           0 : rtlCipherError SAL_CALL rtl_cipher_encodeARCFOUR (
    1294             :     rtlCipher   Cipher,
    1295             :     const void *pData,   sal_Size nDatLen,
    1296             :     sal_uInt8  *pBuffer, sal_Size nBufLen) SAL_THROW_EXTERN_C()
    1297             : {
    1298           0 :     CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
    1299           0 :     if (pImpl == NULL)
    1300           0 :         return rtl_Cipher_E_Argument;
    1301             : 
    1302           0 :     if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
    1303           0 :         return rtl_Cipher_E_Algorithm;
    1304             : 
    1305           0 :     if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
    1306           0 :         return rtl_Cipher_E_Direction;
    1307             : 
    1308             :     return rtl_cipherARCFOUR_update_Impl (
    1309             :         &(pImpl->m_context),
    1310           0 :         static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
    1311             : }
    1312             : 
    1313             : /*
    1314             :  * rtl_cipher_decodeARCFOUR.
    1315             :  */
    1316        4134 : rtlCipherError SAL_CALL rtl_cipher_decodeARCFOUR (
    1317             :     rtlCipher   Cipher,
    1318             :     const void *pData,   sal_Size nDatLen,
    1319             :     sal_uInt8  *pBuffer, sal_Size nBufLen) SAL_THROW_EXTERN_C()
    1320             : {
    1321        4134 :     CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
    1322        4134 :     if (pImpl == NULL)
    1323           0 :         return rtl_Cipher_E_Argument;
    1324             : 
    1325        4134 :     if (!(pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR))
    1326           0 :         return rtl_Cipher_E_Algorithm;
    1327             : 
    1328        4134 :     if (pImpl->m_cipher.m_direction == rtl_Cipher_DirectionInvalid)
    1329           0 :         return rtl_Cipher_E_Direction;
    1330             : 
    1331             :     return rtl_cipherARCFOUR_update_Impl (
    1332             :         &(pImpl->m_context),
    1333        4134 :         static_cast<const sal_uInt8*>(pData), nDatLen, pBuffer, nBufLen);
    1334             : }
    1335             : 
    1336             : /*
    1337             :  * rtl_cipher_destroyARCFOUR.
    1338             :  */
    1339         201 : void SAL_CALL rtl_cipher_destroyARCFOUR (rtlCipher Cipher) SAL_THROW_EXTERN_C()
    1340             : {
    1341         201 :     CipherARCFOUR_Impl *pImpl = static_cast<CipherARCFOUR_Impl*>(Cipher);
    1342         201 :     if (pImpl)
    1343             :     {
    1344         201 :         if (pImpl->m_cipher.m_algorithm == rtl_Cipher_AlgorithmARCFOUR)
    1345         201 :             rtl_freeZeroMemory (pImpl, sizeof (CipherARCFOUR_Impl));
    1346             :         else
    1347           0 :             rtl_freeMemory (pImpl);
    1348             :     }
    1349         201 : }
    1350             : 
    1351             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11