oox/qa/unit/CryptoTest.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
  10 #include <cppunit/plugin/TestPlugIn.h>
  11 #include <cppunit/extensions/HelperMacros.h>
  12 #include <cppunit/TestFixture.h>
  13
  14 #include <algorithm>
  15 #include <tools/stream.hxx>
  16 #include <unotools/streamwrap.hxx>
  17
  18 #include <oox/crypto/Standard2007Engine.hxx>
  19 #include <oox/crypto/AgileEngine.hxx>
  20 #include <oox/helper/binaryinputstream.hxx>
  21 #include <oox/helper/binaryoutputstream.hxx>
  22
  23 using namespace css;
  24
  25 class CryptoTest : public CppUnit::TestFixture
  26 {
  27 public:
  28     void testCryptoHash();
  29     void testRoundUp();
  30     void testStandard2007();
  31     void testAgileEncryptionVerifier();
  32     void testAgileEncrpytionInfoWritingAndParsing();
  33     void testAgileDataIntegrityHmacKey();
  34     void testAgileEncryptingAndDecrypting();
  35
  36     CPPUNIT_TEST_SUITE(CryptoTest);
  37     CPPUNIT_TEST(testCryptoHash);
  38     CPPUNIT_TEST(testRoundUp);
  39     CPPUNIT_TEST(testStandard2007);
  40     CPPUNIT_TEST(testAgileEncryptionVerifier);
  41     CPPUNIT_TEST(testAgileEncrpytionInfoWritingAndParsing);
  42     CPPUNIT_TEST(testAgileDataIntegrityHmacKey);
  43     CPPUNIT_TEST(testAgileEncryptingAndDecrypting);
  44     CPPUNIT_TEST_SUITE_END();
  45 };
  46
  47 namespace
  48 {
  49 std::string toString(std::vector<sal_uInt8> const& aInput)
  50 {
  51     std::stringstream aStream;
  52     for (auto const& aValue : aInput)
  53     {
  54         aStream << std::setw(2) << std::setfill('0') << std::hex << static_cast<int>(aValue);
  55     }
  56
  57     return aStream.str();
  58 }
  59 }
  60
  61 void CryptoTest::testCryptoHash()
  62 {
  63     // Check examples from Wikipedia (https://en.wikipedia.org/wiki/HMAC)
  64     OString aContentString("The quick brown fox jumps over the lazy dog");
  65     std::vector<sal_uInt8> aContent(aContentString.getStr(),
  66                                     aContentString.getStr() + aContentString.getLength());
  67     std::vector<sal_uInt8> aKey = { 'k', 'e', 'y' };
  68     {
  69         oox::core::CryptoHash aCryptoHash(aKey, oox::core::CryptoHashType::SHA1);
  70         aCryptoHash.update(aContent);
  71         std::vector<sal_uInt8> aHash = aCryptoHash.finalize();
  72         CPPUNIT_ASSERT_EQUAL(std::string("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9"),
  73                              toString(aHash));
  74     }
  75
  76     {
  77         oox::core::CryptoHash aCryptoHash(aKey, oox::core::CryptoHashType::SHA256);
  78         aCryptoHash.update(aContent);
  79         std::vector<sal_uInt8> aHash = aCryptoHash.finalize();
  80         CPPUNIT_ASSERT_EQUAL(
  81             std::string("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8"),
  82             toString(aHash));
  83     }
  84
  85     {
  86         oox::core::CryptoHash aCryptoHash(aKey, oox::core::CryptoHashType::SHA512);
  87         aCryptoHash.update(aContent);
  88         std::vector<sal_uInt8> aHash = aCryptoHash.finalize();
  89         CPPUNIT_ASSERT_EQUAL(
  90             std::string("b42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549"
  91                         "f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3a"),
  92             toString(aHash));
  93     }
  94 }
  95
  96 void CryptoTest::testRoundUp()
  97 {
  98     CPPUNIT_ASSERT_EQUAL(16, oox::core::roundUp(16, 16));
  99     CPPUNIT_ASSERT_EQUAL(32, oox::core::roundUp(32, 16));
 100     CPPUNIT_ASSERT_EQUAL(64, oox::core::roundUp(64, 16));
 101
 102     CPPUNIT_ASSERT_EQUAL(16, oox::core::roundUp(01, 16));
 103     CPPUNIT_ASSERT_EQUAL(32, oox::core::roundUp(17, 16));
 104     CPPUNIT_ASSERT_EQUAL(32, oox::core::roundUp(31, 16));
 105 }
 106
 107 void CryptoTest::testStandard2007()
 108 {
 109     oox::core::Standard2007Engine aEngine;
 110     {
 111         aEngine.setupEncryption("Password");
 112
 113         SvMemoryStream aEncryptionInfo;
 114         oox::BinaryXOutputStream aBinaryEncryptionInfoOutputStream(
 115             new utl::OSeekableOutputStreamWrapper(aEncryptionInfo), false);
 116
 117         aEngine.writeEncryptionInfo(aBinaryEncryptionInfoOutputStream);
 118         aBinaryEncryptionInfoOutputStream.close();
 119
 120         CPPUNIT_ASSERT_EQUAL(sal_uInt64(224), aEncryptionInfo.GetSize());
 121     }
 122
 123     SvMemoryStream aUnencryptedInput;
 124     SvMemoryStream aEncryptedStream;
 125
 126     OString aTestString = OUStringToOString("1234567890ABCDEFG", RTL_TEXTENCODING_UTF8);
 127
 128     aUnencryptedInput.WriteBytes(aTestString.getStr(), aTestString.getLength() + 1);
 129     aUnencryptedInput.Seek(STREAM_SEEK_TO_BEGIN);
 130
 131     {
 132         uno::Reference<io::XInputStream> xInputStream(
 133             new utl::OSeekableInputStreamWrapper(aUnencryptedInput));
 134         uno::Reference<io::XOutputStream> xOutputStream(
 135             new utl::OSeekableOutputStreamWrapper(aEncryptedStream));
 136
 137         aEngine.encrypt(xInputStream, xOutputStream, aUnencryptedInput.GetSize());
 138
 139         xOutputStream->flush();
 140
 141         const sal_uInt8* pData = static_cast<const sal_uInt8*>(aEncryptedStream.GetData());
 142         sal_uInt64 nSize = aEncryptedStream.GetSize();
 143
 144         std::vector<sal_uInt8> aData(nSize);
 145         std::copy(pData, pData + nSize, aData.data());
 146
 147         CPPUNIT_ASSERT_EQUAL(sal_uInt64(40), nSize);
 148     }
 149
 150     aEncryptedStream.Seek(STREAM_SEEK_TO_BEGIN);
 151     SvMemoryStream aUnencryptedOutput;
 152
 153     {
 154         oox::BinaryXInputStream aBinaryInputStream(
 155             new utl::OSeekableInputStreamWrapper(aEncryptedStream), true);
 156         oox::BinaryXOutputStream aBinaryOutputStream(
 157             new utl::OSeekableOutputStreamWrapper(aUnencryptedOutput), true);
 158
 159         aEngine.decrypt(aBinaryInputStream, aBinaryOutputStream);
 160         aBinaryOutputStream.close();
 161         aBinaryInputStream.close();
 162
 163         const sal_Char* pData = static_cast<const sal_Char*>(aUnencryptedOutput.GetData());
 164         sal_uInt64 nSize = aUnencryptedOutput.GetSize();
 165
 166         CPPUNIT_ASSERT_EQUAL(sal_uInt64(18), nSize);
 167
 168         OString aString(pData);
 169
 170         CPPUNIT_ASSERT_EQUAL(aTestString, aString);
 171     }
 172 }
 173
 174 void CryptoTest::testAgileEncryptionVerifier()
 175 {
 176     oox::core::AgileEngine aEngine;
 177
 178     OUString aPassword("Password");
 179
 180     aEngine.setupEncryptionParameters({ 100000, 16, 128, 20, 16, OUString("AES"),
 181                                         OUString("ChainingModeCBC"), OUString("SHA1") });
 182
 183     CPPUNIT_ASSERT_EQUAL(true, aEngine.generateAndEncryptVerifierHash(aPassword));
 184     CPPUNIT_ASSERT_EQUAL(false, aEngine.decryptAndCheckVerifierHash("Wrong"));
 185     CPPUNIT_ASSERT_EQUAL(true, aEngine.decryptAndCheckVerifierHash(aPassword));
 186
 187     aEngine.setupEncryptionParameters({ 100000, 16, 256, 64, 16, OUString("AES"),
 188                                         OUString("ChainingModeCBC"), OUString("SHA512") });
 189
 190     CPPUNIT_ASSERT_EQUAL(true, aEngine.generateAndEncryptVerifierHash(aPassword));
 191     CPPUNIT_ASSERT_EQUAL(false, aEngine.decryptAndCheckVerifierHash("Wrong"));
 192     CPPUNIT_ASSERT_EQUAL(true, aEngine.decryptAndCheckVerifierHash(aPassword));
 193 }
 194
 195 void CryptoTest::testAgileEncrpytionInfoWritingAndParsing()
 196 {
 197     OUString aPassword("Password");
 198     std::vector<sal_uInt8> aKeyDataSalt;
 199
 200     { // Preset AES128 - SHA1
 201         SvMemoryStream aEncryptionInfo;
 202         {
 203             oox::core::AgileEngine aEngine;
 204
 205             aEngine.setPreset(oox::core::AgileEncryptionPreset::AES_128_SHA1);
 206             aEngine.setupEncryption(aPassword);
 207             aKeyDataSalt = aEngine.getInfo().keyDataSalt;
 208
 209             oox::BinaryXOutputStream aBinaryEncryptionInfoOutputStream(
 210                 new utl::OSeekableOutputStreamWrapper(aEncryptionInfo), true);
 211
 212             aEngine.writeEncryptionInfo(aBinaryEncryptionInfoOutputStream);
 213             aBinaryEncryptionInfoOutputStream.close();
 214
 215             CPPUNIT_ASSERT_EQUAL(sal_uInt64(996), aEncryptionInfo.GetSize());
 216         }
 217
 218         aEncryptionInfo.Seek(STREAM_SEEK_TO_BEGIN);
 219
 220         {
 221             oox::core::AgileEngine aEngine;
 222
 223             uno::Reference<io::XInputStream> xInputStream(
 224                 new utl::OSeekableInputStreamWrapper(aEncryptionInfo));
 225
 226             xInputStream->skipBytes(4); // Encryption type -> Agile
 227
 228             CPPUNIT_ASSERT(aEngine.readEncryptionInfo(xInputStream));
 229
 230             oox::core::AgileEncryptionInfo& rInfo = aEngine.getInfo();
 231             CPPUNIT_ASSERT_EQUAL(sal_Int32(100000), rInfo.spinCount);
 232             CPPUNIT_ASSERT_EQUAL(sal_Int32(16), rInfo.saltSize);
 233             CPPUNIT_ASSERT_EQUAL(sal_Int32(128), rInfo.keyBits);
 234             CPPUNIT_ASSERT_EQUAL(sal_Int32(20), rInfo.hashSize);
 235             CPPUNIT_ASSERT_EQUAL(sal_Int32(16), rInfo.blockSize);
 236             CPPUNIT_ASSERT_EQUAL(OUString("AES"), rInfo.cipherAlgorithm);
 237             CPPUNIT_ASSERT_EQUAL(OUString("ChainingModeCBC"), rInfo.cipherChaining);
 238             CPPUNIT_ASSERT_EQUAL(OUString("SHA1"), rInfo.hashAlgorithm);
 239             CPPUNIT_ASSERT_EQUAL(toString(aKeyDataSalt), toString(rInfo.keyDataSalt));
 240
 241             CPPUNIT_ASSERT_EQUAL(false, aEngine.decryptAndCheckVerifierHash("Wrong"));
 242             CPPUNIT_ASSERT_EQUAL(true, aEngine.decryptAndCheckVerifierHash(aPassword));
 243         }
 244     }
 245
 246     { // Preset AES256 - SHA512
 247         SvMemoryStream aEncryptionInfo;
 248         {
 249             oox::core::AgileEngine aEngine;
 250
 251             aEngine.setPreset(oox::core::AgileEncryptionPreset::AES_256_SHA512);
 252             aEngine.setupEncryption(aPassword);
 253             aKeyDataSalt = aEngine.getInfo().keyDataSalt;
 254
 255             oox::BinaryXOutputStream aBinaryEncryptionInfoOutputStream(
 256                 new utl::OSeekableOutputStreamWrapper(aEncryptionInfo), true);
 257
 258             aEngine.writeEncryptionInfo(aBinaryEncryptionInfoOutputStream);
 259             aBinaryEncryptionInfoOutputStream.close();
 260
 261             CPPUNIT_ASSERT_EQUAL(sal_uInt64(1112), aEncryptionInfo.GetSize());
 262         }
 263
 264         aEncryptionInfo.Seek(STREAM_SEEK_TO_BEGIN);
 265
 266         {
 267             oox::core::AgileEngine aEngine;
 268
 269             uno::Reference<io::XInputStream> xInputStream(
 270                 new utl::OSeekableInputStreamWrapper(aEncryptionInfo));
 271
 272             xInputStream->skipBytes(4); // Encryption type -> Agile
 273
 274             CPPUNIT_ASSERT(aEngine.readEncryptionInfo(xInputStream));
 275
 276             oox::core::AgileEncryptionInfo& rInfo = aEngine.getInfo();
 277             CPPUNIT_ASSERT_EQUAL(sal_Int32(100000), rInfo.spinCount);
 278             CPPUNIT_ASSERT_EQUAL(sal_Int32(16), rInfo.saltSize);
 279             CPPUNIT_ASSERT_EQUAL(sal_Int32(256), rInfo.keyBits);
 280             CPPUNIT_ASSERT_EQUAL(sal_Int32(64), rInfo.hashSize);
 281             CPPUNIT_ASSERT_EQUAL(sal_Int32(16), rInfo.blockSize);
 282             CPPUNIT_ASSERT_EQUAL(OUString("AES"), rInfo.cipherAlgorithm);
 283             CPPUNIT_ASSERT_EQUAL(OUString("ChainingModeCBC"), rInfo.cipherChaining);
 284             CPPUNIT_ASSERT_EQUAL(OUString("SHA512"), rInfo.hashAlgorithm);
 285             CPPUNIT_ASSERT_EQUAL(toString(aKeyDataSalt), toString(rInfo.keyDataSalt));
 286
 287             CPPUNIT_ASSERT_EQUAL(false, aEngine.decryptAndCheckVerifierHash("Wrong"));
 288             CPPUNIT_ASSERT_EQUAL(true, aEngine.decryptAndCheckVerifierHash(aPassword));
 289         }
 290     }
 291 }
 292
 293 void CryptoTest::testAgileDataIntegrityHmacKey()
 294 {
 295     OUString aPassword("Password");
 296
 297     std::vector<sal_uInt8> aKeyDataSalt;
 298
 299     std::vector<sal_uInt8> aHmacKey;
 300     std::vector<sal_uInt8> aHmacEncryptedKey;
 301
 302     SvMemoryStream aEncryptionInfo;
 303     {
 304         oox::core::AgileEngine aEngine;
 305         aEngine.setupEncryption(aPassword);
 306         oox::BinaryXOutputStream aBinaryEncryptionInfoOutputStream(
 307             new utl::OSeekableOutputStreamWrapper(aEncryptionInfo), true);
 308         aEngine.writeEncryptionInfo(aBinaryEncryptionInfoOutputStream);
 309         aBinaryEncryptionInfoOutputStream.close();
 310
 311         aHmacKey = aEngine.getInfo().hmacKey;
 312         aKeyDataSalt = aEngine.getInfo().keyDataSalt;
 313         aHmacEncryptedKey = aEngine.getInfo().hmacEncryptedKey;
 314     }
 315
 316     aEncryptionInfo.Seek(STREAM_SEEK_TO_BEGIN);
 317
 318     {
 319         oox::core::AgileEngine aEngine;
 320
 321         uno::Reference<io::XInputStream> xInputStream(
 322             new utl::OSeekableInputStreamWrapper(aEncryptionInfo));
 323
 324         xInputStream->skipBytes(4); // Encryption type -> Agile
 325
 326         CPPUNIT_ASSERT(aEngine.readEncryptionInfo(xInputStream));
 327         CPPUNIT_ASSERT(aEngine.generateEncryptionKey(aPassword));
 328
 329         CPPUNIT_ASSERT_EQUAL(toString(aKeyDataSalt), toString(aEngine.getInfo().keyDataSalt));
 330
 331         CPPUNIT_ASSERT_EQUAL(toString(aHmacEncryptedKey),
 332                              toString(aEngine.getInfo().hmacEncryptedKey));
 333
 334         CPPUNIT_ASSERT_EQUAL(size_t(64), aHmacKey.size());
 335         CPPUNIT_ASSERT_EQUAL(toString(aHmacKey), toString(aEngine.getInfo().hmacKey));
 336     }
 337 }
 338
 339 void CryptoTest::testAgileEncryptingAndDecrypting()
 340 {
 341     OUString aPassword("Password");
 342
 343     SvMemoryStream aEncryptionInfo;
 344     SvMemoryStream aEncryptedStream;
 345
 346     OString aTestString = OUStringToOString("1234567890ABCDEFGH", RTL_TEXTENCODING_UTF8);
 347
 348     {
 349         oox::core::AgileEngine aEngine;
 350
 351         // Setup input
 352         SvMemoryStream aUnencryptedInput;
 353         uno::Reference<io::XInputStream> xInputStream(
 354             new utl::OSeekableInputStreamWrapper(aUnencryptedInput));
 355
 356         aUnencryptedInput.WriteBytes(aTestString.getStr(), aTestString.getLength() + 1);
 357         aUnencryptedInput.Seek(STREAM_SEEK_TO_BEGIN);
 358
 359         // Setup output
 360         uno::Reference<io::XOutputStream> xOutputStream(
 361             new utl::OSeekableOutputStreamWrapper(aEncryptedStream));
 362
 363         // Write content
 364         aEngine.setupEncryption(aPassword);
 365         aEngine.encrypt(xInputStream, xOutputStream, aUnencryptedInput.GetSize());
 366         xOutputStream->flush();
 367
 368         // Check content
 369         sal_uInt64 nSize = aEncryptedStream.GetSize();
 370
 371         CPPUNIT_ASSERT_EQUAL(sal_uInt64(40), nSize);
 372
 373         // Setup and write encryption info
 374         oox::BinaryXOutputStream aBinaryEncryptionInfoOutputStream(
 375             new utl::OSeekableOutputStreamWrapper(aEncryptionInfo), true);
 376         aEngine.writeEncryptionInfo(aBinaryEncryptionInfoOutputStream);
 377         aBinaryEncryptionInfoOutputStream.close();
 378     }
 379
 380     aEncryptedStream.Seek(STREAM_SEEK_TO_BEGIN);
 381     aEncryptionInfo.Seek(STREAM_SEEK_TO_BEGIN);
 382
 383     {
 384         oox::core::AgileEngine aEngine;
 385
 386         // Read encryption info
 387         uno::Reference<io::XInputStream> xEncryptionInfo(
 388             new utl::OSeekableInputStreamWrapper(aEncryptionInfo));
 389
 390         xEncryptionInfo->skipBytes(4); // Encryption type -> Agile
 391
 392         CPPUNIT_ASSERT(aEngine.readEncryptionInfo(xEncryptionInfo));
 393
 394         // Setup password
 395         CPPUNIT_ASSERT(aEngine.generateEncryptionKey(aPassword));
 396
 397         // Setup encrypted input stream
 398         oox::BinaryXInputStream aBinaryInputStream(
 399             new utl::OSeekableInputStreamWrapper(aEncryptedStream), true);
 400
 401         // Setup output stream
 402         SvMemoryStream aUnencryptedOutput;
 403         oox::BinaryXOutputStream aBinaryOutputStream(
 404             new utl::OSeekableOutputStreamWrapper(aUnencryptedOutput), true);
 405
 406         // Decrypt
 407         aEngine.decrypt(aBinaryInputStream, aBinaryOutputStream);
 408         aBinaryOutputStream.close();
 409         aBinaryInputStream.close();
 410
 411         // Check decrypted output
 412         CPPUNIT_ASSERT_EQUAL(sal_uInt64(19), aUnencryptedOutput.GetSize());
 413
 414         OString aString(static_cast<const sal_Char*>(aUnencryptedOutput.GetData()));
 415         CPPUNIT_ASSERT_EQUAL(aTestString, aString);
 416
 417         // Check data integrity
 418         CPPUNIT_ASSERT_EQUAL(true, aEngine.checkDataIntegrity());
 419     }
 420 }
 421
 422 CPPUNIT_TEST_SUITE_REGISTRATION(CryptoTest);
 423
 424 CPPUNIT_PLUGIN_IMPLEMENT();
 425
 426 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */