sc/source/filter/oox/biffcodec.cxx

   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 "biffcodec.hxx"
  21
  22 #include <osl/thread.h>
  23 #include <string.h>
  24 #include <oox/core/filterbase.hxx>
  25 #include "biffinputstream.hxx"
  26
  27 namespace oox {
  28 namespace xls {
  29
  30 using namespace ::com::sun::star::beans;
  31 using namespace ::com::sun::star::uno;
  32
  33 using ::oox::core::FilterBase;
  34
  35 BiffDecoderBase::BiffDecoderBase() :
  36     mbValid( false )
  37 {
  38 }
  39
  40 BiffDecoderBase::~BiffDecoderBase()
  41 {
  42 }
  43
  44 ::comphelper::DocPasswordVerifierResult BiffDecoderBase::verifyPassword( const OUString& rPassword, Sequence< NamedValue >& o_rEncryptionData )
  45 {
  46     o_rEncryptionData = implVerifyPassword( rPassword );
  47     mbValid = o_rEncryptionData.hasElements();
  48     return mbValid ? ::comphelper::DocPasswordVerifierResult_OK : ::comphelper::DocPasswordVerifierResult_WRONG_PASSWORD;
  49 }
  50
  51 ::comphelper::DocPasswordVerifierResult BiffDecoderBase::verifyEncryptionData( const Sequence< NamedValue >& rEncryptionData )
  52 {
  53     mbValid = implVerifyEncryptionData( rEncryptionData );
  54     return mbValid ? ::comphelper::DocPasswordVerifierResult_OK : ::comphelper::DocPasswordVerifierResult_WRONG_PASSWORD;
  55 }
  56
  57 void BiffDecoderBase::decode( sal_uInt8* pnDestData, const sal_uInt8* pnSrcData, sal_Int64 nStreamPos, sal_uInt16 nBytes )
  58 {
  59     if( pnDestData && pnSrcData && (nBytes > 0) )
  60     {
  61         if( mbValid )
  62             implDecode( pnDestData, pnSrcData, nStreamPos, nBytes );
  63         else
  64             memcpy( pnDestData, pnSrcData, nBytes );
  65     }
  66 }
  67
  68 BiffDecoder_XOR::BiffDecoder_XOR( const BiffDecoder_XOR& rDecoder ) :
  69     BiffDecoderBase(),  // must be called to prevent compiler warning
  70     maCodec( ::oox::core::BinaryCodec_XOR::CODEC_EXCEL ),
  71     maEncryptionData( rDecoder.maEncryptionData ),
  72     mnKey( rDecoder.mnKey ),
  73     mnHash( rDecoder.mnHash )
  74 {
  75     if( isValid() )
  76         maCodec.initCodec( maEncryptionData );
  77 }
  78
  79 BiffDecoder_XOR* BiffDecoder_XOR::implClone()
  80 {
  81     return new BiffDecoder_XOR( *this );
  82 }
  83
  84 Sequence< NamedValue > BiffDecoder_XOR::implVerifyPassword( const OUString& rPassword )
  85 {
  86     maEncryptionData.realloc( 0 );
  87
  88     /*  Convert password to a byte string. TODO: this needs some finetuning
  89         according to the spec... */
  90     OString aBytePassword = OUStringToOString( rPassword, osl_getThreadTextEncoding() );
  91     sal_Int32 nLen = aBytePassword.getLength();
  92     if( (0 < nLen) && (nLen < 16) )
  93     {
  94         // init codec
  95         maCodec.initKey( reinterpret_cast< const sal_uInt8* >( aBytePassword.getStr() ) );
  96
  97         if( maCodec.verifyKey( mnKey, mnHash ) )
  98             maEncryptionData = maCodec.getEncryptionData();
  99     }
 100
 101     return maEncryptionData;
 102 }
 103
 104 bool BiffDecoder_XOR::implVerifyEncryptionData( const Sequence< NamedValue >& rEncryptionData )
 105 {
 106     maEncryptionData.realloc( 0 );
 107
 108     if( rEncryptionData.hasElements() )
 109     {
 110         // init codec
 111         maCodec.initCodec( rEncryptionData );
 112
 113         if( maCodec.verifyKey( mnKey, mnHash ) )
 114             maEncryptionData = rEncryptionData;
 115     }
 116
 117     return maEncryptionData.hasElements();
 118 }
 119
 120 void BiffDecoder_XOR::implDecode( sal_uInt8* pnDestData, const sal_uInt8* pnSrcData, sal_Int64 nStreamPos, sal_uInt16 nBytes )
 121 {
 122     maCodec.startBlock();
 123     maCodec.skip( static_cast< sal_Int32 >( (nStreamPos + nBytes) & 0x0F ) );
 124     maCodec.decode( pnDestData, pnSrcData, nBytes );
 125 }
 126
 127 namespace {
 128
 129 /** Returns the block index of the passed stream position for RCF decryption. */
 130 sal_Int32 lclGetRcfBlock( sal_Int64 nStreamPos )
 131 {
 132     return static_cast< sal_Int32 >( nStreamPos / BIFF_RCF_BLOCKSIZE );
 133 }
 134
 135 /** Returns the offset of the passed stream position in a block for RCF decryption. */
 136 sal_Int32 lclGetRcfOffset( sal_Int64 nStreamPos )
 137 {
 138     return static_cast< sal_Int32 >( nStreamPos % BIFF_RCF_BLOCKSIZE );
 139 }
 140
 141 } // namespace
 142
 143 BiffDecoder_RCF::BiffDecoder_RCF( const BiffDecoder_RCF& rDecoder ) :
 144     BiffDecoderBase(),  // must be called to prevent compiler warning
 145     maEncryptionData( rDecoder.maEncryptionData ),
 146     maSalt( rDecoder.maSalt ),
 147     maVerifier( rDecoder.maVerifier ),
 148     maVerifierHash( rDecoder.maVerifierHash )
 149 {
 150     if( isValid() )
 151         maCodec.initCodec( maEncryptionData );
 152 }
 153
 154 BiffDecoder_RCF* BiffDecoder_RCF::implClone()
 155 {
 156     return new BiffDecoder_RCF( *this );
 157 }
 158
 159 Sequence< NamedValue > BiffDecoder_RCF::implVerifyPassword( const OUString& rPassword )
 160 {
 161     maEncryptionData.realloc( 0 );
 162
 163     sal_Int32 nLen = rPassword.getLength();
 164     if( (0 < nLen) && (nLen < 16) )
 165     {
 166         // copy string to sal_uInt16 array
 167         ::std::vector< sal_uInt16 > aPassVect( 16 );
 168         const sal_Unicode* pcChar = rPassword.getStr();
 169         const sal_Unicode* pcCharEnd = pcChar + nLen;
 170         ::std::vector< sal_uInt16 >::iterator aIt = aPassVect.begin();
 171         for( ; pcChar < pcCharEnd; ++pcChar, ++aIt )
 172             *aIt = static_cast< sal_uInt16 >( *pcChar );
 173
 174         // init codec
 175         maCodec.initKey( &aPassVect.front(), &maSalt.front() );
 176         if( maCodec.verifyKey( &maVerifier.front(), &maVerifierHash.front() ) )
 177             maEncryptionData = maCodec.getEncryptionData();
 178     }
 179
 180     return maEncryptionData;
 181 }
 182
 183 bool BiffDecoder_RCF::implVerifyEncryptionData( const Sequence< NamedValue >& rEncryptionData )
 184 {
 185     maEncryptionData.realloc( 0 );
 186
 187     if( rEncryptionData.hasElements() )
 188     {
 189         // init codec
 190         maCodec.initCodec( rEncryptionData );
 191
 192         if( maCodec.verifyKey( &maVerifier.front(), &maVerifierHash.front() ) )
 193             maEncryptionData = rEncryptionData;
 194     }
 195
 196     return maEncryptionData.hasElements();
 197 }
 198
 199 void BiffDecoder_RCF::implDecode( sal_uInt8* pnDestData, const sal_uInt8* pnSrcData, sal_Int64 nStreamPos, sal_uInt16 nBytes )
 200 {
 201     sal_uInt8* pnCurrDest = pnDestData;
 202     const sal_uInt8* pnCurrSrc = pnSrcData;
 203     sal_Int64 nCurrPos = nStreamPos;
 204     sal_uInt16 nBytesLeft = nBytes;
 205     while( nBytesLeft > 0 )
 206     {
 207         // initialize codec for current stream position
 208         maCodec.startBlock( lclGetRcfBlock( nCurrPos ) );
 209         maCodec.skip( lclGetRcfOffset( nCurrPos ) );
 210
 211         // decode the block
 212         sal_uInt16 nBlockLeft = static_cast< sal_uInt16 >( BIFF_RCF_BLOCKSIZE - lclGetRcfOffset( nCurrPos ) );
 213         sal_uInt16 nDecBytes = ::std::min( nBytesLeft, nBlockLeft );
 214         maCodec.decode( pnCurrDest, pnCurrSrc, static_cast< sal_Int32 >( nDecBytes ) );
 215
 216         // prepare for next block
 217         pnCurrDest += nDecBytes;
 218         pnCurrSrc += nDecBytes;
 219         nCurrPos += nDecBytes;
 220         nBytesLeft = nBytesLeft - nDecBytes;
 221     }
 222 }
 223
 224 BiffCodecHelper::BiffCodecHelper( const WorkbookHelper& rHelper ) :
 225     WorkbookHelper( rHelper )
 226 {
 227 }
 228
 229 void BiffCodecHelper::cloneDecoder( BiffInputStream& rStrm )
 230 {
 231     if( mxDecoder.get() )
 232         rStrm.setDecoder( BiffDecoderRef( mxDecoder->clone() ) );
 233 }
 234
 235 } // namespace xls
 236 } // namespace oox
 237
 238 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */