From e0c5d650ecf94b30b66584bdd9367dcacc0a6e94 Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Caol=C3=A1n=20McNamara?= <caolanm@redhat.com>

Date: Thu, 20 Oct 2016 11:19:58 +0100

Subject: [PATCH] implement CryptoAPI RC4+SHA1 encryption scheme for xls import

there might be other variants out there in practice, but this

works for default encrypted xls of excel 2013

(cherry picked from commit 1473ce030314027c01c98f513407ed0897328585)

contains...

be more c++y

(cherry picked from commit fcf7f503b64b2cf7dbef019fb43dde033e3538e8)

hash len is 20 for xls cryptoapi configuration

(cherry picked from commit 491884350ce74f36044b3348bd66356ad1c234af)

clarify hash lengths a bit more

(cherry picked from commit 8db1b13e721683d0263925c8e0300dd86a022814)

hash len isn't going to change depending on who implements it

(cherry picked from commit fcc846e8f29839eaace7e1d28746abea8f4b598a)

move some useful header information to mscodec for reuse

(cherry picked from commit fc514cbf30be1613fdf4d4b7c12cbd55ca08b9b0)

rework things in light of now available documentation

(cherry picked from commit 3fabbd0a22219464545f933fc28c869a6fa89546)

split MSCodec_Std97 into a baseclass MSCodec97

(cherry picked from commit 06916c839b16866b47235306d2db50850df0ad7c)

6e06b8578959b8147043179db57e875b1d98d57d

66cea4b9efb82d29e6c052ac11a6f2eaca823ce0

ee585cba4acad74c11d083085153e2af96c8894f

c7adf3ed3c8279cc93a06975d6fb337210d1af87

f5f75e27191017a8c6a3929e2a70d21840f157c6

a3c41a048169c78684800def94e53fc9f3201e30

91c0e1d1d95fbd1c68966650e7ac7d23276bcbe3

Change-Id: I673b00e111a734bc626ba3d3f6ecf9692f1ce7db

---

 filter/source/msfilter/mscodec.cxx        | 206 +++++++++++++++++++---------

 include/filter/msfilter/mscodec.hxx       | 215 ++++++++++++++++++++++++------

 include/oox/crypto/CryptTools.hxx         |   3 -

 include/oox/crypto/Standard2007Engine.hxx |  76 ++---------

 oox/source/crypto/CryptTools.cxx          |  14 +-

 oox/source/crypto/DocumentDecryption.cxx  |  22 +--

 oox/source/crypto/Standard2007Engine.cxx  |  67 ++++------

 sc/source/filter/excel/xicontent.cxx      | 106 ++++++++++++---

 sc/source/filter/excel/xistream.cxx       |  70 ++++++----

 sc/source/filter/inc/xistream.hxx         |  67 ++++++++--

 sc/source/filter/inc/xlcontent.hxx        |   2 -

 11 files changed, 553 insertions(+), 295 deletions(-)

diff --git a/filter/source/msfilter/mscodec.cxx b/filter/source/msfilter/mscodec.cxx

index 87dbf70..ade583a 100644

--- a/filter/source/msfilter/mscodec.cxx

+++ b/filter/source/msfilter/mscodec.cxx

@@ -247,28 +247,37 @@ void MSCodec_Xor95::Skip( sal_Size nBytes )

     mnOffset = (mnOffset + nBytes) & 0x0F;

 }

+MSCodec97::MSCodec97(size_t nHashLen)

+    : m_nHashLen(nHashLen)

+    , m_hCipher(rtl_cipher_create(rtl_Cipher_AlgorithmARCFOUR, rtl_Cipher_ModeStream))

+    , m_aDigestValue(nHashLen, 0)

+{

+    assert(m_hCipher != nullptr);

+    (void)memset (m_pDocId, 0, sizeof(m_pDocId));

+}

-

-MSCodec_Std97::MSCodec_Std97 ()

+MSCodec_Std97::MSCodec_Std97()

+    : MSCodec97(RTL_DIGEST_LENGTH_MD5)

 {

-    m_hCipher = rtl_cipher_create (

-        rtl_Cipher_AlgorithmARCFOUR, rtl_Cipher_ModeStream);

-    OSL_ASSERT(m_hCipher != nullptr);

+    m_hDigest = rtl_digest_create(rtl_Digest_AlgorithmMD5);

+    assert(m_hDigest != nullptr);

+}

-    m_hDigest = rtl_digest_create (

-        rtl_Digest_AlgorithmMD5);

-    OSL_ASSERT(m_hDigest != nullptr);

+MSCodec_CryptoAPI::MSCodec_CryptoAPI()

+    : MSCodec97(RTL_DIGEST_LENGTH_SHA1)

+{

+}

-    (void)memset (m_pDigestValue, 0, sizeof(m_pDigestValue));

-    (void)memset (m_pDocId, 0, sizeof(m_pDocId));

+MSCodec97::~MSCodec97()

+{

+    (void)memset(m_aDigestValue.data(), 0, m_aDigestValue.size());

+    (void)memset(m_pDocId, 0, sizeof(m_pDocId));

+    rtl_cipher_destroy(m_hCipher);

 }

-MSCodec_Std97::~MSCodec_Std97 ()

+MSCodec_Std97::~MSCodec_Std97()

 {

-    (void)memset (m_pDigestValue, 0, sizeof(m_pDigestValue));

-    (void)memset (m_pDocId, 0, sizeof(m_pDocId));

-    rtl_digest_destroy (m_hDigest);

-    rtl_cipher_destroy (m_hCipher);

+    rtl_digest_destroy(m_hDigest);

 }

 #if DEBUG_MSO_ENCRYPTION_STD97

@@ -285,7 +294,7 @@ static inline void lcl_PrintDigest(const sal_uInt8* /*pDigest*/, const char* /*m

 }

 #endif

-bool MSCodec_Std97::InitCodec( const uno::Sequence< beans::NamedValue >& aData )

+bool MSCodec97::InitCodec( const uno::Sequence< beans::NamedValue >& aData )

 {

 #if DEBUG_MSO_ENCRYPTION_STD97

     fprintf(stdout, "MSCodec_Std97::InitCodec: --begin\n");fflush(stdout);

@@ -294,16 +303,17 @@ bool MSCodec_Std97::InitCodec( const uno::Sequence< beans::NamedValue >& aData )

     ::comphelper::SequenceAsHashMap aHashData( aData );

     uno::Sequence< sal_Int8 > aKey = aHashData.getUnpackedValueOrDefault("STD97EncryptionKey", uno::Sequence< sal_Int8 >() );

-

-    if ( aKey.getLength() == RTL_DIGEST_LENGTH_MD5 )

+    const size_t nKeyLen = aKey.getLength();

+    if (nKeyLen == m_nHashLen)

     {

-        (void)memcpy( m_pDigestValue, aKey.getConstArray(), RTL_DIGEST_LENGTH_MD5 );

+        assert(m_aDigestValue.size() == m_nHashLen);

+        (void)memcpy(m_aDigestValue.data(), aKey.getConstArray(), m_nHashLen);

         uno::Sequence< sal_Int8 > aUniqueID = aHashData.getUnpackedValueOrDefault("STD97UniqueID", uno::Sequence< sal_Int8 >() );

         if ( aUniqueID.getLength() == 16 )

         {

             (void)memcpy( m_pDocId, aUniqueID.getConstArray(), 16 );

             bResult = true;

-            lcl_PrintDigest(m_pDigestValue, "digest value");

+            lcl_PrintDigest(m_aDigestValue.data(), "digest value");

             lcl_PrintDigest(m_pDocId, "DocId value");

         }

         else

@@ -315,10 +325,11 @@ bool MSCodec_Std97::InitCodec( const uno::Sequence< beans::NamedValue >& aData )

     return bResult;

 }

-uno::Sequence< beans::NamedValue > MSCodec_Std97::GetEncryptionData()

+uno::Sequence< beans::NamedValue > MSCodec97::GetEncryptionData()

 {

     ::comphelper::SequenceAsHashMap aHashData;

-    aHashData[ OUString( "STD97EncryptionKey" ) ] <<= uno::Sequence< sal_Int8 >( reinterpret_cast<sal_Int8*>(m_pDigestValue), RTL_DIGEST_LENGTH_MD5 );

+    assert(m_aDigestValue.size() == m_nHashLen);

+    aHashData[ OUString( "STD97EncryptionKey" ) ] <<= uno::Sequence< sal_Int8 >( reinterpret_cast<sal_Int8*>(m_aDigestValue.data()), m_nHashLen );

     aHashData[ OUString( "STD97UniqueID" ) ] <<= uno::Sequence< sal_Int8 >( reinterpret_cast<sal_Int8*>(m_pDocId), 16 );

     return aHashData.getAsConstNamedValueList();

@@ -334,26 +345,51 @@ void MSCodec_Std97::InitKey (

     uno::Sequence< sal_Int8 > aKey = ::comphelper::DocPasswordHelper::GenerateStd97Key(pPassData, pDocId);

     // Fill raw digest of above updates into DigestValue.

-    if ( aKey.getLength() == sizeof(m_pDigestValue) )

-        (void)memcpy ( m_pDigestValue, aKey.getConstArray(), sizeof(m_pDigestValue) );

+    const size_t nKeyLen = aKey.getLength();

+    if (m_aDigestValue.size() == nKeyLen)

+        (void)memcpy(m_aDigestValue.data(), aKey.getConstArray(), m_aDigestValue.size());

     else

-        memset( m_pDigestValue, 0, sizeof(m_pDigestValue) );

+        memset(m_aDigestValue.data(), 0, m_aDigestValue.size());

+

+    lcl_PrintDigest(m_aDigestValue.data(), "digest value");

+

+    (void)memcpy (m_pDocId, pDocId, 16);

+

+    lcl_PrintDigest(m_pDocId, "DocId value");

+}

+

+void MSCodec_CryptoAPI::InitKey (

+    const sal_uInt16 pPassData[16],

+    const sal_uInt8  pDocId[16])

+{

+    sal_uInt32 saltSize = 16;

+

+    // Prepare initial data -> salt + password (in 16-bit chars)

+    std::vector<sal_uInt8> initialData(pDocId, pDocId + saltSize);

+

+    // Fill PassData into KeyData.

+    for (sal_Int32 nInd = 0; nInd < 16 && pPassData[nInd]; ++nInd)

+    {

+        initialData.push_back(sal::static_int_cast<sal_uInt8>((pPassData[nInd] >> 0) & 0xff));

+        initialData.push_back(sal::static_int_cast<sal_uInt8>((pPassData[nInd] >> 8) & 0xff));

+    }

+

+    // calculate SHA1 hash of initialData

+    rtl_digest_SHA1(initialData.data(), initialData.size(), m_aDigestValue.data(), m_aDigestValue.size());

-    lcl_PrintDigest(m_pDigestValue, "digest value");

+    lcl_PrintDigest(m_aDigestValue.data(), "digest value");

     (void)memcpy (m_pDocId, pDocId, 16);

     lcl_PrintDigest(m_pDocId, "DocId value");

 }

-bool MSCodec_Std97::VerifyKey (

-    const sal_uInt8 pSaltData[16],

-    const sal_uInt8 pSaltDigest[16])

+bool MSCodec97::VerifyKey(const sal_uInt8* pSaltData, const sal_uInt8* pSaltDigest)

 {

     // both the salt data and salt digest (hash) come from the document being imported.

 #if DEBUG_MSO_ENCRYPTION_STD97

-    fprintf(stdout, "MSCodec_Std97::VerifyKey: \n");

+    fprintf(stdout, "MSCodec97::VerifyKey: \n");

     lcl_PrintDigest(pSaltData, "salt data");

     lcl_PrintDigest(pSaltDigest, "salt hash");

 #endif

@@ -361,35 +397,42 @@ bool MSCodec_Std97::VerifyKey (

     if (InitCipher(0))

     {

-        sal_uInt8 pDigest[RTL_DIGEST_LENGTH_MD5];

-        GetDigestFromSalt(pSaltData, pDigest);

+        std::vector<sal_uInt8> aDigest(m_nHashLen);

+        GetDigestFromSalt(pSaltData, aDigest.data());

-        sal_uInt8 pBuffer[16];

+        std::vector<sal_uInt8> aBuffer(m_nHashLen);

         // Decode original SaltDigest into Buffer.

-        rtl_cipher_decode (

-            m_hCipher, pSaltDigest, 16, pBuffer, sizeof(pBuffer));

+        rtl_cipher_decode(m_hCipher, pSaltDigest, m_nHashLen, aBuffer.data(), m_nHashLen);

         // Compare Buffer with computed Digest.

-        result = (memcmp (pBuffer, pDigest, sizeof(pDigest)) == 0);

+        result = (memcmp(aBuffer.data(), aDigest.data(), m_nHashLen) == 0);

         // Erase Buffer and Digest arrays.

-        rtl_secureZeroMemory (pBuffer, sizeof(pBuffer));

-        rtl_secureZeroMemory (pDigest, sizeof(pDigest));

+        rtl_secureZeroMemory(aBuffer.data(), m_nHashLen);

+        rtl_secureZeroMemory(aDigest.data(), m_nHashLen);

     }

     return result;

 }

-bool MSCodec_Std97::InitCipher (sal_uInt32 nCounter)

+void MSCodec_CryptoAPI::GetDigestFromSalt(const sal_uInt8* pSaltData, sal_uInt8* pDigest)

+{

+    std::vector<sal_uInt8> verifier(16);

+    rtl_cipher_decode(m_hCipher,

+        pSaltData, 16, verifier.data(), verifier.size());

+

+    rtl_digest_SHA1(verifier.data(), verifier.size(), pDigest, RTL_DIGEST_LENGTH_SHA1);

+}

+

+bool MSCodec_Std97::InitCipher(sal_uInt32 nCounter)

 {

-    rtlCipherError result;

     sal_uInt8      pKeyData[64]; // 512-bit message block

     // Initialize KeyData array.

     (void)memset (pKeyData, 0, sizeof(pKeyData));

     // Fill 40 bit of DigestValue into [0..4].

-    (void)memcpy (pKeyData, m_pDigestValue, 5);

+    (void)memcpy (pKeyData, m_aDigestValue.data(), 5);

     // Fill counter into [5..8].

     pKeyData[ 5] = sal_uInt8((nCounter >>  0) & 0xff);

@@ -407,7 +450,7 @@ bool MSCodec_Std97::InitCipher (sal_uInt32 nCounter)

         m_hDigest, pKeyData, RTL_DIGEST_LENGTH_MD5);

     // Initialize Cipher with KeyData (for decoding).

-    result = rtl_cipher_init (

+    rtlCipherError result = rtl_cipher_init (

         m_hCipher, rtl_Cipher_DirectionBoth,

         pKeyData, RTL_DIGEST_LENGTH_MD5, nullptr, 0);

@@ -417,12 +460,30 @@ bool MSCodec_Std97::InitCipher (sal_uInt32 nCounter)

     return (result == rtl_Cipher_E_None);

 }

-bool MSCodec_Std97::CreateSaltDigest( const sal_uInt8 nSaltData[16], sal_uInt8 nSaltDigest[16] )

+bool MSCodec_CryptoAPI::InitCipher(sal_uInt32 nCounter)

+{

+    // data = hash + iterator (4bytes)

+    std::vector<sal_uInt8> aKeyData(m_aDigestValue);

+    aKeyData.push_back(sal_uInt8((nCounter >>  0) & 0xff));

+    aKeyData.push_back(sal_uInt8((nCounter >>  8) & 0xff));

+    aKeyData.push_back(sal_uInt8((nCounter >> 16) & 0xff));

+    aKeyData.push_back(sal_uInt8((nCounter >> 24) & 0xff));

+

+    std::vector<sal_uInt8> hash(RTL_DIGEST_LENGTH_SHA1);

+    rtl_digest_SHA1(aKeyData.data(), aKeyData.size(), hash.data(), RTL_DIGEST_LENGTH_SHA1);

+

+    rtlCipherError result =

+        rtl_cipher_init(m_hCipher, rtl_Cipher_DirectionDecode,

+                        hash.data(), ENCRYPT_KEY_SIZE_AES_128/8, nullptr, 0);

+

+    return (result == rtl_Cipher_E_None);

+}

+

+void MSCodec_Std97::CreateSaltDigest( const sal_uInt8 nSaltData[16], sal_uInt8 nSaltDigest[16] )

 {

 #if DEBUG_MSO_ENCRYPTION_STD97

     lcl_PrintDigest(nSaltData, "salt data");

 #endif

-    bool result = false;

     if (InitCipher(0))

     {

@@ -434,35 +495,29 @@ bool MSCodec_Std97::CreateSaltDigest( const sal_uInt8 nSaltData[16], sal_uInt8 n

         (void)memcpy(nSaltDigest, pDigest, 16);

     }

-

-    return result;

 }

-bool MSCodec_Std97::Encode (

-    const void *pData,   sal_Size nDatLen,

-    sal_uInt8  *pBuffer, sal_Size nBufLen)

+bool MSCodec97::Encode (

+    const void *pData,   std::size_t nDatLen,

+    sal_uInt8  *pBuffer, std::size_t nBufLen)

 {

-    rtlCipherError result;

-

-    result = rtl_cipher_encode (

+    rtlCipherError result = rtl_cipher_encode(

         m_hCipher, pData, nDatLen, pBuffer, nBufLen);

     return (result == rtl_Cipher_E_None);

 }

-bool MSCodec_Std97::Decode (

-    const void *pData,   sal_Size nDatLen,

-    sal_uInt8  *pBuffer, sal_Size nBufLen)

+bool MSCodec97::Decode (

+    const void *pData,   std::size_t nDatLen,

+    sal_uInt8  *pBuffer, std::size_t nBufLen)

 {

-    rtlCipherError result;

-

-    result = rtl_cipher_decode (

+    rtlCipherError result = rtl_cipher_decode(

         m_hCipher, pData, nDatLen, pBuffer, nBufLen);

     return (result == rtl_Cipher_E_None);

 }

-bool MSCodec_Std97::Skip( sal_Size nDatLen )

+bool MSCodec97::Skip(std::size_t nDatLen)

 {

     sal_uInt8 pnDummy[ 1024 ];

     sal_Size nDatLeft = nDatLen;

@@ -478,7 +533,7 @@ bool MSCodec_Std97::Skip( sal_Size nDatLen )

     return bResult;

 }

-void MSCodec_Std97::GetDigestFromSalt( const sal_uInt8 pSaltData[16], sal_uInt8 pDigest[16] )

+void MSCodec_Std97::GetDigestFromSalt(const sal_uInt8* pSaltData, sal_uInt8* pDigest)

 {

     sal_uInt8 pBuffer[64];

     sal_uInt8 pDigestLocal[16];

@@ -537,12 +592,41 @@ void MSCodec_Std97::GetEncryptKey (

     }

 }

-void MSCodec_Std97::GetDocId( sal_uInt8 pDocId[16] )

+void MSCodec97::GetDocId( sal_uInt8 pDocId[16] )

 {

     if ( sizeof( m_pDocId ) == 16 )

         (void)memcpy( pDocId, m_pDocId, 16 );

 }

+EncryptionStandardHeader::EncryptionStandardHeader()

+{

+    flags        = 0;

+    sizeExtra    = 0;

+    algId        = 0;

+    algIdHash    = 0;

+    keyBits      = 0;

+    providedType = 0;

+    reserved1    = 0;

+    reserved2    = 0;

+}

+

+EncryptionVerifierAES::EncryptionVerifierAES()

+    : saltSize(SALT_LENGTH)

+    , encryptedVerifierHashSize(SHA1_HASH_LENGTH)

+{

+    memset(salt, 0, sizeof(salt));

+    memset(encryptedVerifier, 0, sizeof(encryptedVerifier));

+    memset(encryptedVerifierHash, 0, sizeof(encryptedVerifierHash));

+}

+

+EncryptionVerifierRC4::EncryptionVerifierRC4()

+    : saltSize(SALT_LENGTH)

+    , encryptedVerifierHashSize(SHA1_HASH_LENGTH)

+{

+    memset(salt, 0, sizeof(salt));

+    memset(encryptedVerifier, 0, sizeof(encryptedVerifier));

+    memset(encryptedVerifierHash, 0, sizeof(encryptedVerifierHash));

+}

 }

diff --git a/include/filter/msfilter/mscodec.hxx b/include/filter/msfilter/mscodec.hxx

index 4f5676b..4ab6c9b 100644

--- a/include/filter/msfilter/mscodec.hxx

+++ b/include/filter/msfilter/mscodec.hxx

@@ -26,6 +26,12 @@

 #include <rtl/cipher.h>

 #include <rtl/digest.h>

 #include <filter/msfilter/msfilterdllapi.h>

+#include <sal/types.h>

+#include <vector>

+

+namespace com { namespace sun { namespace star {

+    namespace beans { struct NamedValue; }

+} } }

 namespace msfilter {

@@ -172,20 +178,11 @@ public:

     virtual void                Decode( sal_uInt8* pnData, sal_Size nBytes ) override;

 };

-

-

-

-/** Encodes and decodes data from protected MSO 97+ documents.

-

-    This is a wrapper class around low level cryptographic functions from RTL.

-    Implementation is based on the wvDecrypt package by Caolan McNamara:

-    http://www.csn.ul.ie/~caolan/docs/wvDecrypt.html

- */

-class MSFILTER_DLLPUBLIC MSCodec_Std97

+class MSFILTER_DLLPUBLIC MSCodec97

 {

 public:

-    explicit            MSCodec_Std97();

-                        ~MSCodec_Std97();

+    MSCodec97(size_t nHashLen);

+    virtual ~MSCodec97();

     /** Initializes the algorithm with the encryption data.

@@ -193,7 +190,7 @@ public:

             The sequence contains the necessary data to initialize

             the codec.

      */

-    bool                InitCodec( const css::uno::Sequence< css::beans::NamedValue >& aData );

+    bool InitCodec(const css::uno::Sequence< css::beans::NamedValue >& aData);

     /** Retrieves the encryption data

@@ -203,7 +200,6 @@ public:

      */

     css::uno::Sequence< css::beans::NamedValue > GetEncryptionData();

-

     /** Initializes the algorithm with the specified password and document ID.

         @param pPassData

@@ -212,9 +208,9 @@ public:

         @param pDocId

             Unique document identifier read from or written to the file.

      */

-    void                InitKey(

-                            const sal_uInt16 pPassData[ 16 ],

-                            const sal_uInt8 pDocId[ 16 ] );

+    virtual void InitKey(const sal_uInt16 pPassData[16],

+                         const sal_uInt8 pDocId[16]) = 0;

+

     /** Verifies the validity of the password using the passed salt data.

@@ -230,9 +226,9 @@ public:

         @return

             true = Test was successful.

      */

-    bool                VerifyKey(

-                            const sal_uInt8 pSaltData[ 16 ],

-                            const sal_uInt8 pSaltDigest[ 16 ] );

+    bool VerifyKey(const sal_uInt8* pSaltData, const sal_uInt8* pSaltDigest);

+

+    virtual void GetDigestFromSalt(const sal_uInt8* pSaltData, sal_uInt8* pDigest) = 0;

     /** Rekeys the codec using the specified counter.

@@ -249,11 +245,7 @@ public:

         @param nCounter

             Block counter used to rekey the cipher.

      */

-    bool                InitCipher( sal_uInt32 nCounter );

-

-    /** Creates an MD5 digest of salt digest. */

-    bool                CreateSaltDigest(

-                            const sal_uInt8 nSaltData[16], sal_uInt8 nSaltDigest[16] );

+    virtual bool                InitCipher(sal_uInt32 nCounter) = 0;

     /** Encodes a block of memory.

@@ -277,9 +269,8 @@ public:

         @return

             true = Encoding was successful (no error occurred).

     */

-    bool                Encode(

-                            const void* pData, sal_Size nDatLen,

-                            sal_uInt8* pBuffer, sal_Size nBufLen );

+    bool                Encode(const void* pData, std::size_t nDatLen,

+                               sal_uInt8* pBuffer, std::size_t nBufLen);

     /** Decodes a block of memory.

@@ -303,9 +294,8 @@ public:

         @return

             true = Decoding was successful (no error occurred).

     */

-    bool                Decode(

-                            const void* pData, sal_Size nDatLen,

-                            sal_uInt8* pBuffer, sal_Size nBufLen );

+    bool                Decode(const void* pData, std::size_t nDatLen,

+                               sal_uInt8* pBuffer, std::size_t nBufLen);

     /** Lets the cipher skip a specific amount of bytes.

@@ -319,7 +309,66 @@ public:

         @param nDatLen

             Number of bytes to be skipped (cipher "seeks" forward).

      */

-    bool                Skip( sal_Size nDatLen );

+    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:

+    size_t              m_nHashLen;

+    rtlCipher           m_hCipher;

+    sal_uInt8           m_pDocId[16];

+    std::vector<sal_uInt8> m_aDigestValue;

+};

+

+/** Encodes and decodes data from protected MSO 97+ documents.

+

+    This is a wrapper class around low level cryptographic functions from RTL.

+    Implementation is based on the wvDecrypt package by Caolan McNamara:

+    http://www.csn.ul.ie/~caolan/docs/wvDecrypt.html

+ */

+class MSFILTER_DLLPUBLIC MSCodec_Std97 :  public MSCodec97

+{

+public:

+    MSCodec_Std97();

+    virtual ~MSCodec_Std97() override;

+

+    /** Initializes the algorithm with the specified password and document ID.

+

+        @param pPassData

+            Wide character array containing the password. Must be zero

+            terminated, which results in a maximum length of 15 characters.

+        @param pDocId

+            Unique document identifier read from or written to the file.

+     */

+    virtual void InitKey(const sal_uInt16 pPassData[16],

+                         const sal_uInt8 pDocId[16]) override;

+

+    /** Rekeys the codec using the specified counter.

+

+        After reading a specific amount of data the cipher algorithm needs to

+        be rekeyed using a counter that counts the data blocks.

+

+        The block size is for example 512 Bytes for Word files and 1024 Bytes

+        for Excel files.

+

+        @precond

+            The codec must be initialized with InitKey() before this function

+            can be used.

+

+        @param nCounter

+            Block counter used to rekey the cipher.

+     */

+    virtual bool InitCipher(sal_uInt32 nCounter) override;

+

+    /** Creates an MD5 digest of salt digest. */

+    void               CreateSaltDigest(

+                            const sal_uInt8 nSaltData[16], sal_uInt8 nSaltDigest[16] );

     /** Gets salt data and salt digest.

@@ -339,22 +388,108 @@ public:

                             sal_uInt8 pSaltData[16],

                             sal_uInt8 pSaltDigest[16]);

-    /* allows to get the unique document id from the codec

-     */

-    void                GetDocId( sal_uInt8 pDocId[16] );

-

-    void                GetDigestFromSalt( const sal_uInt8 pSaltData[16], sal_uInt8 pDigest[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;

-    rtlCipher           m_hCipher;

     rtlDigest           m_hDigest;

-    sal_uInt8           m_pDigestValue[ RTL_DIGEST_LENGTH_MD5 ];

-    sal_uInt8           m_pDocId[16];

 };

+class MSFILTER_DLLPUBLIC MSCodec_CryptoAPI :  public MSCodec97

+{

+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;

+};

+

+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 SALT_LENGTH                    = 16;

+const sal_uInt32 ENCRYPTED_VERIFIER_LENGTH      = 16;

+const sal_uInt32 SHA1_HASH_LENGTH = RTL_DIGEST_LENGTH_SHA1; // 20

+const sal_uInt32 SHA256_HASH_LENGTH = 32;

+const sal_uInt32 SHA512_HASH_LENGTH = 64;

+

+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[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[SHA1_HASH_LENGTH];                 // verifier value hash - itself also encrypted

+

+    EncryptionVerifierRC4();

+};

+

+struct MSFILTER_DLLPUBLIC StandardEncryptionInfo

+{

+    EncryptionStandardHeader header;

+    EncryptionVerifierAES    verifier;

+};

+

+struct MSFILTER_DLLPUBLIC RC4EncryptionInfo