include/oox/core/binarycodec.hxx

   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 #ifndef OOX_CORE_BINARYCODEC_HXX
  21 #define OOX_CORE_BINARYCODEC_HXX
  22
  23 #include <com/sun/star/uno/Sequence.hxx>
  24 #include <com/sun/star/beans/NamedValue.hpp>
  25
  26 #include <rtl/cipher.h>
  27 #include <rtl/digest.h>
  28 #include "oox/dllapi.h"
  29
  30 namespace oox { class AttributeList; }
  31
  32 namespace oox {
  33 namespace core {
  34
  35 // ============================================================================
  36
  37 class OOX_DLLPUBLIC CodecHelper
  38 {
  39 public:
  40     /** Returns the password hash if it is in the required 16-bit limit. */
  41     static sal_uInt16   getPasswordHash( const AttributeList& rAttribs, sal_Int32 nElement );
  42
  43 private:
  44                         CodecHelper();
  45                         ~CodecHelper();
  46 };
  47
  48 // ============================================================================
  49
  50 /** Encodes and decodes data from/to protected MS Office documents.
  51
  52     Implements a simple XOR encoding/decoding algorithm used in MS Office
  53     versions up to MSO 95.
  54  */
  55 class OOX_DLLPUBLIC BinaryCodec_XOR
  56 {
  57 public:
  58     /** Enumerates codec types supported by this XOR codec implementation. */
  59     enum CodecType
  60     {
  61         CODEC_WORD,     ///< MS Word XOR codec.
  62         CODEC_EXCEL     ///< MS Excel XOR codec.
  63     };
  64
  65 public:
  66     /** Default constructor.
  67
  68         Two-step construction in conjunction with the initKey() and verifyKey()
  69         functions allows to try to initialize with different passwords (e.g.
  70         built-in default password used for Excel workbook protection).
  71      */
  72     explicit            BinaryCodec_XOR( CodecType eCodecType );
  73
  74                         ~BinaryCodec_XOR();
  75
  76     /** Initializes the algorithm with the specified password.
  77
  78         @param pnPassData
  79             Character array containing the password. Must be zero terminated,
  80             which results in a maximum length of 15 characters.
  81      */
  82     void                initKey( const sal_uInt8 pnPassData[ 16 ] );
  83
  84     /** Initializes the algorithm with the encryption data.
  85
  86         @param aData
  87             The sequence contains the necessary data to initialize
  88             the codec.
  89      */
  90     bool                initCodec( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::NamedValue >& aData );
  91
  92     /** Retrieves the encryption data
  93
  94         @return
  95             The sequence contains the necessary data to initialize
  96             the codec.
  97      */
  98     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::NamedValue > getEncryptionData();
  99
 100     /** Verifies the validity of the password using the passed key and hash.
 101
 102         @precond
 103             The codec must be initialized with the initKey() function before
 104             this function can be used.
 105
 106         @param nKey
 107             Password key value read from the file.
 108         @param nHash
 109             Password hash value read from the file.
 110
 111         @return
 112             True = test was successful.
 113      */
 114     bool                verifyKey( sal_uInt16 nKey, sal_uInt16 nHash ) const;
 115
 116     /** Reinitializes the codec to start a new memory block.
 117
 118         Resets the internal key offset to 0.
 119
 120         @precond
 121             The codec must be initialized with the initKey() function before
 122             this function can be used.
 123      */
 124     void                startBlock();
 125
 126     /** Decodes a block of memory.
 127
 128         @precond
 129             The codec must be initialized with the initKey() function before
 130             this function can be used.
 131
 132         @param pnDestData
 133             Destination buffer. Will contain the decrypted data afterwards.
 134         @param pnSrcData
 135             Encrypted data block.
 136         @param nBytes
 137             Size of the passed data blocks. pnDestData and pnSrcData must be of
 138             this size.
 139
 140         @return
 141             True = decoding was successful (no error occurred).
 142     */
 143     bool                decode(
 144                             sal_uInt8* pnDestData,
 145                             const sal_uInt8* pnSrcData,
 146                             sal_Int32 nBytes );
 147
 148     /** Lets the cipher skip a specific amount of bytes.
 149
 150         This function sets the cipher to the same state as if the specified
 151         amount of data has been decoded with one or more calls of decode().
 152
 153         @precond
 154             The codec must be initialized with the initKey() function before
 155             this function can be used.
 156
 157         @param nBytes
 158             Number of bytes to be skipped (cipher "seeks" forward).
 159
 160         @return
 161             True = skip was successful (no error occurred).
 162      */
 163     bool                skip( sal_Int32 nBytes );
 164
 165 private:
 166     CodecType           meCodecType;        ///< Codec type.
 167     sal_uInt8           mpnKey[ 16 ];       ///< Encryption key.
 168     sal_Int32           mnOffset;           ///< Key offset.
 169     sal_uInt16          mnBaseKey;          ///< Base key from password.
 170     sal_uInt16          mnHash;             ///< Hash value from password.
 171 };
 172
 173 // ============================================================================
 174
 175 /** Encodes and decodes data from protected MSO 97+ documents.
 176
 177     This is a wrapper class around low level cryptographic functions from RTL.
 178     Implementation is based on the wvDecrypt package by Caolan McNamara:
 179     http://www.csn.ul.ie/~caolan/docs/wvDecrypt.html
 180  */
 181 class OOX_DLLPUBLIC BinaryCodec_RCF
 182 {
 183 public:
 184     /** Default constructor.
 185
 186         Two-step construction in conjunction with the initKey() and verifyKey()
 187         functions allows to try to initialize with different passwords (e.g.
 188         built-in default password used for Excel workbook protection).
 189      */
 190     explicit            BinaryCodec_RCF();
 191
 192                         ~BinaryCodec_RCF();
 193
 194     /** Initializes the algorithm with the encryption data.
 195
 196         @param aData
 197             The sequence contains the necessary data to initialize
 198             the codec.
 199      */
 200     bool            initCodec( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::NamedValue >& aData );
 201
 202     /** Retrieves the encryption data
 203
 204         @return
 205             The sequence contains the necessary data to initialize
 206             the codec.
 207      */
 208     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::NamedValue > getEncryptionData();
 209
 210     /** Initializes the algorithm with the specified password and document ID.
 211
 212         @param pnPassData
 213             Unicode character array containing the password. Must be zero
 214             terminated, which results in a maximum length of 15 characters.
 215         @param pnSalt
 216             Random salt data block read from or written to the file.
 217      */
 218     void                initKey(
 219                             const sal_uInt16 pnPassData[ 16 ],
 220                             const sal_uInt8 pnSalt[ 16 ] );
 221
 222     /** Verifies the validity of the password using the passed salt data.
 223
 224         @precond
 225             The codec must be initialized with the initKey() function before
 226             this function can be used.
 227
 228         @param pnVerifier
 229             Verifier block read from the file.
 230         @param pnVerifierHash
 231             Verifier hash read from the file.
 232
 233         @return
 234             True = test was successful.
 235      */
 236     bool                verifyKey(
 237                             const sal_uInt8 pnVerifier[ 16 ],
 238                             const sal_uInt8 pnVerifierHash[ 16 ] );
 239
 240     /** Rekeys the codec using the specified counter.
 241
 242         After reading a specific amount of data the cipher algorithm needs to
 243         be rekeyed using a counter that counts the data blocks.
 244
 245         The block size is for example 512 bytes for MS Word files and 1024
 246         bytes for MS Excel files.
 247
 248         @precond
 249             The codec must be initialized with the initKey() function before
 250             this function can be used.
 251
 252         @param nCounter
 253             Block counter used to rekey the cipher.
 254      */
 255     bool                startBlock( sal_Int32 nCounter );
 256
 257     /** Decodes a block of memory.
 258
 259         @see rtl_cipher_decode()
 260
 261         @precond
 262             The codec must be initialized with the initKey() function before
 263             this function can be used.
 264
 265         @param pnDestData
 266             Destination buffer. Will contain the decrypted data afterwards.
 267         @param pnSrcData
 268             Encrypted data block.
 269         @param nBytes
 270             Size of the passed data blocks. pnDestData and pnSrcData must be of
 271             this size.
 272
 273         @return
 274             True = decoding was successful (no error occurred).
 275     */
 276     bool                decode(
 277                             sal_uInt8* pnDestData,
 278                             const sal_uInt8* pnSrcData,
 279                             sal_Int32 nBytes );
 280
 281     /** Lets the cipher skip a specific amount of bytes.
 282
 283         This function sets the cipher to the same state as if the specified
 284         amount of data has been decoded with one or more calls of decode().
 285
 286         @precond
 287             The codec must be initialized with the initKey() function before
 288             this function can be used.
 289
 290         @param nBytes
 291             Number of bytes to be skipped (cipher "seeks" forward).
 292
 293         @return
 294             True = skip was successful (no error occurred).
 295      */
 296     bool                skip( sal_Int32 nBytes );
 297
 298 private:
 299     void                InitKeyImpl(
 300                             const sal_uInt8 pKeyData[64],
 301                             const sal_uInt8 pUnique[16] );
 302
 303     rtlCipher           mhCipher;
 304     rtlDigest           mhDigest;
 305     sal_uInt8           mpnDigestValue[ RTL_DIGEST_LENGTH_MD5 ];
 306     sal_uInt8           mpnUnique[16];
 307 };
 308
 309 // ============================================================================
 310
 311 } // namespace core
 312 } // namespace oox
 313
 314 #endif
 315
 316 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */