mscodec.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_FILTER_MSFILTER_MSCODEC_HXX
#define INCLUDED_FILTER_MSFILTER_MSCODEC_HXX
 
#include <com/sun/star/uno/Sequence.hxx>
#include <filter/msfilter/msfilterdllapi.h>
#include <rtl/cipher.h>
#include <rtl/digest.h>
#include <sal/types.h>
#include <comphelper/hash.hxx>
#include <vector>
 
namespace com::sun::star {
    namespace beans { struct NamedValue; }
}
 
namespace msfilter {
 
 
class MSFILTER_DLLPUBLIC MSCodec_Xor95
{
public:
    explicit            MSCodec_Xor95(int nRotateDistance);
    virtual            ~MSCodec_Xor95();
 
    void                InitKey( const sal_uInt8 pnPassData[ 16 ] );
 
    bool                InitCodec( const css::uno::Sequence< css::beans::NamedValue >& aData );
 
    css::uno::Sequence< css::beans::NamedValue > GetEncryptionData();
 
 
    bool                VerifyKey( sal_uInt16 nKey, sal_uInt16 nHash ) const;
 
    void                InitCipher();
 
    virtual void                Decode( sal_uInt8* pnData, std::size_t nBytes )=0;
 
    void                Skip( std::size_t nBytes );
 
protected:
    sal_uInt8           mpnKey[ 16 ] = {}; 
    std::size_t         mnOffset;       
 
private:
                        MSCodec_Xor95( const MSCodec_Xor95& ) = delete;
    MSCodec_Xor95&      operator=( const MSCodec_Xor95& ) = delete;
 
    sal_uInt16          mnKey;          
    sal_uInt16          mnHash;         
    int                 mnRotateDistance;
};
 
class MSFILTER_DLLPUBLIC MSCodec_XorXLS95 final : public MSCodec_Xor95
{
public:
    explicit            MSCodec_XorXLS95() : MSCodec_Xor95(2) {}
 
    virtual void                Decode( sal_uInt8* pnData, std::size_t nBytes ) override;
};
 
class MSFILTER_DLLPUBLIC MSCodec_XorWord95 final : public MSCodec_Xor95
{
public:
    explicit            MSCodec_XorWord95() : MSCodec_Xor95(7) {}
 
    virtual void                Decode( sal_uInt8* pnData, std::size_t nBytes ) override;
};
 
class MSFILTER_DLLPUBLIC MSCodec97
{
public:
    MSCodec97(size_t nHashLen, OUString aEncKeyName);
    virtual ~MSCodec97();
 
    bool InitCodec(const css::uno::Sequence< css::beans::NamedValue >& aData);
 
    virtual css::uno::Sequence<css::beans::NamedValue> GetEncryptionData();
 
    virtual void InitKey(const sal_uInt16 pPassData[16],
                         const sal_uInt8 pDocId[16]) = 0;
 
 
    bool VerifyKey(const sal_uInt8* pSaltData, const sal_uInt8* pSaltDigest);
 
    virtual void GetDigestFromSalt(const sal_uInt8* pSaltData, sal_uInt8* pDigest) = 0;
 
    virtual bool                InitCipher(sal_uInt32 nCounter) = 0;
 
    bool                Encode(const void* pData, std::size_t nDatLen,
                               sal_uInt8* pBuffer, std::size_t nBufLen);
 
    bool                Decode(const void* pData, std::size_t nDatLen,
                               sal_uInt8* pBuffer, std::size_t nBufLen);
 
    bool                Skip(std::size_t nDatLen);
 
    /* allows to get the unique document id from the codec
     */
    void                GetDocId( sal_uInt8 pDocId[16] );
 
private:
                        MSCodec97(const MSCodec97&) = delete;
    MSCodec97&          operator=(const MSCodec97&) = delete;
 
protected:
    OUString            m_sEncKeyName;
    size_t              m_nHashLen;
    rtlCipher           m_hCipher;
    std::vector<sal_uInt8> m_aDocId;
    std::vector<sal_uInt8> m_aDigestValue;
};
 
class MSFILTER_DLLPUBLIC MSCodec_Std97 final : public MSCodec97
{
public:
    MSCodec_Std97();
    virtual ~MSCodec_Std97() override;
 
    virtual void InitKey(const sal_uInt16 pPassData[16],
                         const sal_uInt8 pDocId[16]) override;
 
    virtual bool InitCipher(sal_uInt32 nCounter) override;
 
    void               CreateSaltDigest(
                            const sal_uInt8 nSaltData[16], sal_uInt8 nSaltDigest[16] );
 
    void                GetEncryptKey (
                            const sal_uInt8 pSalt[16],
                            sal_uInt8 pSaltData[16],
                            sal_uInt8 pSaltDigest[16]);
 
    virtual void        GetDigestFromSalt(const sal_uInt8* pSaltData, sal_uInt8* pDigest) override;
 
private:
                        MSCodec_Std97( const MSCodec_Std97& ) = delete;
    MSCodec_Std97&      operator=( const MSCodec_Std97& ) = delete;
 
    rtlDigest           m_hDigest;
};
 
class MSFILTER_DLLPUBLIC MSCodec_CryptoAPI final : public MSCodec97
{
private:
    css::uno::Sequence<sal_Int8> m_aStd97Key;
public:
    MSCodec_CryptoAPI();
 
    virtual void InitKey(const sal_uInt16 pPassData[16],
                         const sal_uInt8 pDocId[16]) override;
    virtual bool InitCipher(sal_uInt32 nCounter) override;
    virtual void GetDigestFromSalt(const sal_uInt8* pSaltData, sal_uInt8* pDigest) override;
    virtual css::uno::Sequence<css::beans::NamedValue> GetEncryptionData() override;
};
 
const sal_uInt32 ENCRYPTINFO_CRYPTOAPI      = 0x00000004;
const sal_uInt32 ENCRYPTINFO_DOCPROPS       = 0x00000008;
const sal_uInt32 ENCRYPTINFO_EXTERNAL       = 0x00000010;
const sal_uInt32 ENCRYPTINFO_AES            = 0x00000020;
 
const sal_uInt32 ENCRYPT_ALGO_AES128        = 0x0000660E;
const sal_uInt32 ENCRYPT_ALGO_AES192        = 0x0000660F;
const sal_uInt32 ENCRYPT_ALGO_AES256        = 0x00006610;
const sal_uInt32 ENCRYPT_ALGO_RC4           = 0x00006801;
 
const sal_uInt32 ENCRYPT_HASH_SHA1          = 0x00008004;
 
const sal_uInt32 ENCRYPT_KEY_SIZE_AES_128   = 0x00000080;
const sal_uInt32 ENCRYPT_KEY_SIZE_AES_192   = 0x000000C0;
const sal_uInt32 ENCRYPT_KEY_SIZE_AES_256   = 0x00000100;
 
const sal_uInt32 ENCRYPT_PROVIDER_TYPE_AES  = 0x00000018;
const sal_uInt32 ENCRYPT_PROVIDER_TYPE_RC4  = 0x00000001;
 
// version of encryption info used in MS Office 1997 (major = 1, minor = 1)
const sal_uInt32 VERSION_INFO_1997_FORMAT       = 0x00010001;
// version of encryption info used in MS Office 2007 (major = 3, minor = 2)
const sal_uInt32 VERSION_INFO_2007_FORMAT       = 0x00020003;
// version of encryption info used in MS Office 2007 SP2 and older (major = 4, minor = 2)
const sal_uInt32 VERSION_INFO_2007_FORMAT_SP2   = 0x00020004;
 
// version of encryption info - agile (major = 4, minor = 4)
const sal_uInt32 VERSION_INFO_AGILE         = 0x00040004;
 
const sal_uInt32 AGILE_ENCRYPTION_RESERVED  = 0x00000040;
 
const sal_uInt32 SALT_LENGTH                    = 16;
const sal_uInt32 ENCRYPTED_VERIFIER_LENGTH      = 16;
 
struct MSFILTER_DLLPUBLIC EncryptionStandardHeader
{
    sal_uInt32 flags;
    sal_uInt32 sizeExtra;       // 0
    sal_uInt32 algId;           // if flag AES && CRYPTOAPI this defaults to 128-bit AES
    sal_uInt32 algIdHash;       // 0: determine by flags - defaults to SHA-1 if not external
    sal_uInt32 keyBits;         // key size in bits: 0 (determine by flags), 128, 192, 256
    sal_uInt32 providedType;    // AES or RC4
    sal_uInt32 reserved1;       // 0
    sal_uInt32 reserved2;       // 0
 
    EncryptionStandardHeader();
};
 
struct MSFILTER_DLLPUBLIC EncryptionVerifierAES
{
    sal_uInt32 saltSize;                                                // must be 0x00000010
    sal_uInt8  salt[SALT_LENGTH] = {};                                  // random generated salt value
    sal_uInt8  encryptedVerifier[ENCRYPTED_VERIFIER_LENGTH] = {};       // randomly generated verifier value
    sal_uInt32 encryptedVerifierHashSize;                               // actually written hash size - depends on algorithm
    sal_uInt8  encryptedVerifierHash[comphelper::SHA256_HASH_LENGTH] = {};          // verifier value hash - itself also encrypted
 
    EncryptionVerifierAES();
};
 
struct MSFILTER_DLLPUBLIC EncryptionVerifierRC4
{
    sal_uInt32 saltSize;                                                // must be 0x00000010
    sal_uInt8  salt[SALT_LENGTH] = {};                                  // random generated salt value
    sal_uInt8  encryptedVerifier[ENCRYPTED_VERIFIER_LENGTH] = {};       // randomly generated verifier value
    sal_uInt32 encryptedVerifierHashSize;                               // actually written hash size - depends on algorithm
    sal_uInt8  encryptedVerifierHash[comphelper::SHA1_HASH_LENGTH] = {};            // verifier value hash - itself also encrypted
 
    EncryptionVerifierRC4();
};
 
struct MSFILTER_DLLPUBLIC StandardEncryptionInfo
{
    EncryptionStandardHeader header;
    EncryptionVerifierAES    verifier;
};
 
struct MSFILTER_DLLPUBLIC RC4EncryptionInfo
{
    EncryptionStandardHeader header;
    EncryptionVerifierRC4 verifier;
};
 
} // namespace msfilter
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */