svx/inc/mscodec.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: mscodec.hxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef SVX_MSCODEC_HXX
  32 #define SVX_MSCODEC_HXX
  33
  34 #include "rtl/cipher.h"
  35 #include "rtl/digest.h"
  36 #include "svx/svxdllapi.h"
  37
  38 namespace svx {
  39
  40 // ============================================================================
  41
  42 /** Encodes and decodes data from protected MSO 95- documents.
  43  */
  44 class SVX_DLLPUBLIC MSCodec_Xor95
  45 {
  46 public:
  47     explicit            MSCodec_Xor95(int nRotateDistance);
  48     virtual            ~MSCodec_Xor95();
  49
  50     /** Initializes the algorithm with the specified password.
  51
  52         @param pPassData
  53             Character array containing the password. Must be zero terminated,
  54             which results in a maximum length of 15 characters.
  55      */
  56     void                InitKey( const sal_uInt8 pnPassData[ 16 ] );
  57
  58     /** Verifies the validity of the password using the passed key and hash.
  59
  60         @precond
  61             The codec must be initialized with InitKey() before this function
  62             can be used.
  63
  64         @param nKey
  65             Password key value read from the file.
  66         @param nHash
  67             Password hash value read from the file.
  68
  69         @return
  70             true = Test was successful.
  71      */
  72     bool                VerifyKey( sal_uInt16 nKey, sal_uInt16 nHash ) const;
  73
  74     /** Reinitializes the codec to start a new memory block.
  75
  76         Resets the internal key offset to 0.
  77
  78         @precond
  79             The codec must be initialized with InitKey() before this function
  80             can be used.
  81      */
  82     void                InitCipher();
  83
  84     /** Decodes a block of memory inplace.
  85
  86         @precond
  87             The codec must be initialized with InitKey() before this function
  88             can be used.
  89
  90         @param pnData
  91             Encrypted data block. Will contain the decrypted data afterwards.
  92         @param nBytes
  93             Size of the passed data block.
  94     */
  95     virtual void                Decode( sal_uInt8* pnData, sal_Size nBytes )=0;
  96
  97     /** Lets the cipher skip a specific amount of bytes.
  98
  99         This function sets the cipher to the same state as if the specified
 100         amount of data has been decoded with one or more calls of Decode().
 101
 102         @precond
 103             The codec must be initialized with InitKey() before this function
 104             can be used.
 105
 106         @param nBytes
 107             Number of bytes to be skipped (cipher "seeks" forward).
 108      */
 109     void                Skip( sal_Size nBytes );
 110
 111     // static -----------------------------------------------------------------
 112
 113     /** Calculates the 16-bit hash value for the given password.
 114
 115         The password data may be longer than 16 bytes. The array does not need
 116         to be terminated with a NULL byte (but it can without invalidating the
 117         result).
 118      */
 119     static sal_uInt16   GetHash( const sal_uInt8* pnPassData, sal_Size nSize );
 120
 121 protected:
 122     sal_uInt8           mpnKey[ 16 ];   /// Encryption key.
 123     sal_Size            mnOffset;       /// Key offset.
 124
 125 private:
 126                         SVX_DLLPRIVATE MSCodec_Xor95( const MSCodec_Xor95& );
 127     SVX_DLLPRIVATE MSCodec_Xor95&      operator=( const MSCodec_Xor95& );
 128
 129     sal_uInt16          mnKey;          /// Base key from password.
 130     sal_uInt16          mnHash;         /// Hash value from password.
 131     int                 mnRotateDistance;
 132 };
 133
 134 /** Encodes and decodes data from protected MSO XLS 95- documents.
 135  */
 136 class SVX_DLLPUBLIC MSCodec_XorXLS95 : public MSCodec_Xor95
 137 {
 138 public:
 139     explicit            MSCodec_XorXLS95() : MSCodec_Xor95(2) {}
 140
 141     /** Decodes a block of memory inplace.
 142
 143         @precond
 144             The codec must be initialized with InitKey() before this function
 145             can be used.
 146
 147         @param pnData
 148             Encrypted data block. Will contain the decrypted data afterwards.
 149         @param nBytes
 150             Size of the passed data block.
 151     */
 152     virtual void                Decode( sal_uInt8* pnData, sal_Size nBytes );
 153 };
 154
 155 /** Encodes and decodes data from protected MSO Word 95- documents.
 156  */
 157 class SVX_DLLPUBLIC MSCodec_XorWord95 : public MSCodec_Xor95
 158 {
 159 public:
 160     explicit            MSCodec_XorWord95() : MSCodec_Xor95(7) {}
 161
 162     /** Decodes a block of memory inplace.
 163
 164         @precond
 165             The codec must be initialized with InitKey() before this function
 166             can be used.
 167
 168         @param pnData
 169             Encrypted data block. Will contain the decrypted data afterwards.
 170         @param nBytes
 171             Size of the passed data block.
 172     */
 173     virtual void                Decode( sal_uInt8* pnData, sal_Size nBytes );
 174 };
 175
 176
 177 // ============================================================================
 178
 179 /** Encodes and decodes data from protected MSO 97+ documents.
 180
 181     This is a wrapper class around low level cryptographic functions from RTL.
 182     Implementation is based on the wvDecrypt package by Caolan McNamara:
 183     http://www.csn.ul.ie/~caolan/docs/wvDecrypt.html
 184  */
 185 class SVX_DLLPUBLIC MSCodec_Std97
 186 {
 187 public:
 188     explicit            MSCodec_Std97();
 189                         ~MSCodec_Std97();
 190
 191     /** Initializes the algorithm with the specified password and document ID.
 192
 193         @param pPassData
 194             Wide character array containing the password. Must be zero
 195             terminated, which results in a maximum length of 15 characters.
 196         @param pUnique
 197             Unique document identifier read from or written to the file.
 198      */
 199     void                InitKey(
 200                             const sal_uInt16 pPassData[ 16 ],
 201                             const sal_uInt8 pUnique[ 16 ] );
 202
 203     /** Verifies the validity of the password using the passed salt data.
 204
 205         @precond
 206             The codec must be initialized with InitKey() before this function
 207             can be used.
 208
 209         @param pSaltData
 210             Salt data block read from the file.
 211         @param pSaltDigest
 212             Salt digest read from the file.
 213
 214         @return
 215             true = Test was successful.
 216      */
 217     bool                VerifyKey(
 218                             const sal_uInt8 pSaltData[ 16 ],
 219                             const sal_uInt8 pSaltDigest[ 16 ] );
 220
 221     /** Rekeys the codec using the specified counter.
 222
 223         After reading a specific amount of data the cipher algorithm needs to
 224         be rekeyed using a counter that counts the data blocks.
 225
 226         The block size is for example 512 Bytes for Word files and 1024 Bytes
 227         for Excel files.
 228
 229         @precond
 230             The codec must be initialized with InitKey() before this function
 231             can be used.
 232
 233         @param nCounter
 234             Block counter used to rekey the cipher.
 235      */
 236     bool                InitCipher( sal_uInt32 nCounter );
 237
 238     /** Creates an MD5 digest of salt digest. */
 239     bool                CreateSaltDigest(
 240                             const sal_uInt8 nSaltData[16], sal_uInt8 nSaltDigest[16] );
 241
 242     /** Encodes a block of memory.
 243
 244         @see rtl_cipher_encode()
 245
 246         @precond
 247             The codec must be initialized with InitKey() before this function
 248             can be used. The destination buffer must be able to take all
 249             unencoded data from the source buffer (usually this means it must be
 250             as long as or longer than the source buffer).
 251
 252         @param pData
 253             Unencrypted source data block.
 254         @param nDatLen
 255             Size of the passed source data block.
 256         @param pBuffer
 257             Destination buffer for the encrypted data.
 258         @param nBufLen
 259             Size of the destination buffer.
 260
 261         @return
 262             true = Encoding was successful (no error occured).
 263     */
 264     bool                Encode(
 265                             const void* pData, sal_Size nDatLen,
 266                             sal_uInt8* pBuffer, sal_Size nBufLen );
 267
 268     /** Decodes a block of memory.
 269
 270         @see rtl_cipher_decode()
 271
 272         @precond
 273             The codec must be initialized with InitKey() before this function
 274             can be used. The destination buffer must be able to take all
 275             encoded data from the source buffer (usually this means it must be
 276             as long as or longer than the source buffer).
 277
 278         @param pData
 279             Encrypted source data block.
 280         @param nDatLen
 281             Size of the passed source data block.
 282         @param pBuffer
 283             Destination buffer for the decrypted data.
 284         @param nBufLen
 285             Size of the destination buffer.
 286
 287         @return
 288             true = Decoding was successful (no error occured).
 289     */
 290     bool                Decode(
 291                             const void* pData, sal_Size nDatLen,
 292                             sal_uInt8* pBuffer, sal_Size nBufLen );
 293
 294     /** Lets the cipher skip a specific amount of bytes.
 295
 296         This function sets the cipher to the same state as if the specified
 297         amount of data has been decoded with one or more calls of Decode().
 298
 299         @precond
 300             The codec must be initialized with InitKey() before this function
 301             can be used.
 302
 303         @param nDatLen
 304             Number of bytes to be skipped (cipher "seeks" forward).
 305      */
 306     bool                Skip( sal_Size nDatLen );
 307
 308     /** Gets salt data and salt digest.
 309
 310         @precond
 311             The codec must be initialized with InitKey() before this function
 312             can be used.
 313
 314         @param pSalt
 315             Salt, a random number.
 316         @param pSaltData
 317             Salt data block generated from the salt.
 318         @param pSaltDigest
 319             Salt digest generated from the salt.
 320      */
 321     void                                GetEncryptKey (
 322                             const sal_uInt8 pSalt[16],
 323                             sal_uInt8 pSaltData[16],
 324                             sal_uInt8 pSaltDigest[16]);
 325
 326 private:
 327     void                GetDigestFromSalt( const sal_uInt8 pSaltData[16], sal_uInt8 pDigest[16] );
 328
 329 private:
 330                         SVX_DLLPRIVATE MSCodec_Std97( const MSCodec_Std97& );
 331     SVX_DLLPRIVATE MSCodec_Std97&      operator=( const MSCodec_Std97& );
 332
 333     rtlCipher           m_hCipher;
 334     rtlDigest           m_hDigest;
 335     sal_uInt8           m_pDigestValue[ RTL_DIGEST_LENGTH_MD5 ];
 336 };
 337
 338 // ============================================================================
 339
 340 } // namespace svx
 341
 342 #endif
 343