[Libreoffice-commits] core.git: include/oox oox/source
Tomaž Vajngerl
tomaz.vajngerl at collabora.co.uk
Mon Jan 30 11:25:50 UTC 2017
include/oox/crypto/AgileEngine.hxx | 28 ++----
include/oox/crypto/Standard2007Engine.hxx | 3
oox/source/crypto/AgileEngine.cxx | 106 +++++++++++--------------
oox/source/crypto/CryptTools.cxx | 100 +++++++++++-------------
oox/source/crypto/DocumentDecryption.cxx | 125 +++++++++++++-----------------
oox/source/crypto/DocumentEncryption.cxx | 30 +++----
oox/source/crypto/Standard2007Engine.cxx | 95 ++++++++++------------
7 files changed, 224 insertions(+), 263 deletions(-)
New commits:
commit 5b30a94842388d136f645ed7d16a6941da86b760
Author: Tomaž Vajngerl <tomaz.vajngerl at collabora.co.uk>
Date: Sun Jan 22 22:26:41 2017 +0100
oox: clean-up crypto classes, use c++11 features
- remove "using namespace std;"
- &vector[0] to vector.data()
- use nullptr in OPENSSL
Change-Id: Ib4067b0256801f94d448bc8d3faf5a2902d694e5
Reviewed-on: https://gerrit.libreoffice.org/33629
Tested-by: Jenkins <ci at libreoffice.org>
Reviewed-by: Tomaž Vajngerl <quikee at gmail.com>
diff --git a/include/oox/crypto/AgileEngine.hxx b/include/oox/crypto/AgileEngine.hxx
index 57a3084..22233b0 100644
--- a/include/oox/crypto/AgileEngine.hxx
+++ b/include/oox/crypto/AgileEngine.hxx
@@ -26,25 +26,23 @@ namespace oox {
namespace oox {
namespace core {
-const sal_uInt32 SEGMENT_LENGTH = 4096;
-
struct AgileEncryptionInfo
{
- sal_Int32 spinCount;
- sal_Int32 saltSize;
- sal_Int32 keyBits;
- sal_Int32 hashSize;
- sal_Int32 blockSize;
+ sal_Int32 spinCount;
+ sal_Int32 saltSize;
+ sal_Int32 keyBits;
+ sal_Int32 hashSize;
+ sal_Int32 blockSize;
OUString cipherAlgorithm;
OUString cipherChaining;
OUString hashAlgorithm;
- std::vector<sal_uInt8> keyDataSalt;
- std::vector<sal_uInt8> saltValue;
- std::vector<sal_uInt8> encryptedVerifierHashInput;
- std::vector<sal_uInt8> encryptedVerifierHashValue;
- std::vector<sal_uInt8> encryptedKeyValue;
+ std::vector<sal_uInt8> keyDataSalt;
+ std::vector<sal_uInt8> saltValue;
+ std::vector<sal_uInt8> encryptedVerifierHashInput;
+ std::vector<sal_uInt8> encryptedVerifierHashValue;
+ std::vector<sal_uInt8> encryptedKeyValue;
};
class AgileEngine : public CryptoEngine
@@ -54,8 +52,7 @@ class AgileEngine : public CryptoEngine
void calculateHashFinal(const OUString& rPassword, std::vector<sal_uInt8>& aHashFinal);
void calculateBlock(
- const sal_uInt8* rBlock,
- sal_uInt32 aBlockSize,
+ std::vector<sal_uInt8> const & rBlock,
std::vector<sal_uInt8>& rHashFinal,
std::vector<sal_uInt8>& rInput,
std::vector<sal_uInt8>& rOutput);
@@ -63,8 +60,7 @@ class AgileEngine : public CryptoEngine
static Crypto::CryptoType cryptoType(const AgileEncryptionInfo& rInfo);
public:
- AgileEngine();
- virtual ~AgileEngine() override;
+ AgileEngine() = default;
AgileEncryptionInfo& getInfo() { return mInfo;}
diff --git a/include/oox/crypto/Standard2007Engine.hxx b/include/oox/crypto/Standard2007Engine.hxx
index 42998b4..40aba81 100644
--- a/include/oox/crypto/Standard2007Engine.hxx
+++ b/include/oox/crypto/Standard2007Engine.hxx
@@ -33,8 +33,7 @@ class Standard2007Engine : public CryptoEngine
bool calculateEncryptionKey(const OUString& rPassword);
public:
- Standard2007Engine();
- virtual ~Standard2007Engine() override;
+ Standard2007Engine() = default;
msfilter::StandardEncryptionInfo& getInfo() { return mInfo;}
diff --git a/oox/source/crypto/AgileEngine.cxx b/oox/source/crypto/AgileEngine.cxx
index 3897b87..9c1095a 100644
--- a/oox/source/crypto/AgileEngine.cxx
+++ b/oox/source/crypto/AgileEngine.cxx
@@ -16,34 +16,23 @@
namespace oox {
namespace core {
-using namespace std;
-
namespace {
-const sal_uInt8 constBlock1[] = { 0xfe, 0xa7, 0xd2, 0x76, 0x3b, 0x4b, 0x9e, 0x79 };
-const sal_uInt8 constBlock2[] = { 0xd7, 0xaa, 0x0f, 0x6d, 0x30, 0x61, 0x34, 0x4e };
-const sal_uInt8 constBlock3[] = { 0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, 0xd6 };
+const sal_uInt32 constSegmentLength = 4096;
-bool hashCalc( std::vector<sal_uInt8>& output,
- std::vector<sal_uInt8>& input,
- const OUString& algorithm )
+bool hashCalc(std::vector<sal_uInt8>& output,
+ std::vector<sal_uInt8>& input,
+ const OUString& sAlgorithm )
{
- if (algorithm == "SHA1")
+ if (sAlgorithm == "SHA1")
return Digest::sha1(output, input);
- else if (algorithm == "SHA512")
+ else if (sAlgorithm == "SHA512")
return Digest::sha512(output, input);
return false;
}
} // namespace
-AgileEngine::AgileEngine() :
- CryptoEngine()
-{}
-
-AgileEngine::~AgileEngine()
-{}
-
Crypto::CryptoType AgileEngine::cryptoType(const AgileEncryptionInfo& rInfo)
{
if (rInfo.keyBits == 128 && rInfo.cipherAlgorithm == "AES" && rInfo.cipherChaining == "ChainingModeCBC")
@@ -54,39 +43,35 @@ Crypto::CryptoType AgileEngine::cryptoType(const AgileEncryptionInfo& rInfo)
}
void AgileEngine::calculateBlock(
- const sal_uInt8* rBlock,
- sal_uInt32 aBlockSize,
- vector<sal_uInt8>& rHashFinal,
- vector<sal_uInt8>& rInput,
- vector<sal_uInt8>& rOutput)
+ std::vector<sal_uInt8> const & rBlock,
+ std::vector<sal_uInt8>& rHashFinal,
+ std::vector<sal_uInt8>& rInput,
+ std::vector<sal_uInt8>& rOutput)
{
- vector<sal_uInt8> hash(mInfo.hashSize, 0);
- vector<sal_uInt8> salt = mInfo.saltValue;
- vector<sal_uInt8> dataFinal(mInfo.hashSize + aBlockSize, 0);
+ std::vector<sal_uInt8> hash(mInfo.hashSize, 0);
+ std::vector<sal_uInt8> dataFinal(mInfo.hashSize + rBlock.size(), 0);
std::copy(rHashFinal.begin(), rHashFinal.end(), dataFinal.begin());
- std::copy(
- rBlock,
- rBlock + aBlockSize,
- dataFinal.begin() + mInfo.hashSize);
+ std::copy(rBlock.begin(), rBlock.end(), dataFinal.begin() + mInfo.hashSize);
hashCalc(hash, dataFinal, mInfo.hashAlgorithm);
sal_Int32 keySize = mInfo.keyBits / 8;
- vector<sal_uInt8> key(keySize, 0);
+ std::vector<sal_uInt8> key(keySize, 0);
std::copy(hash.begin(), hash.begin() + keySize, key.begin());
- Decrypt aDecryptor(key, salt, cryptoType(mInfo));
+ Decrypt aDecryptor(key, mInfo.saltValue, cryptoType(mInfo));
aDecryptor.update(rOutput, rInput);
}
-void AgileEngine::calculateHashFinal(const OUString& rPassword, vector<sal_uInt8>& aHashFinal)
+void AgileEngine::calculateHashFinal(const OUString& rPassword, std::vector<sal_uInt8>& aHashFinal)
{
sal_Int32 saltSize = mInfo.saltSize;
- vector<sal_uInt8> salt = mInfo.saltValue;
+ std::vector<sal_uInt8>& salt = mInfo.saltValue;
+
sal_uInt32 passwordByteLength = rPassword.getLength() * 2;
- vector<sal_uInt8> initialData(saltSize + passwordByteLength);
+ std::vector<sal_uInt8> initialData(saltSize + passwordByteLength);
std::copy(salt.begin(), salt.end(), initialData.begin());
const sal_uInt8* passwordByteArray = reinterpret_cast<const sal_uInt8*>(rPassword.getStr());
@@ -96,15 +81,15 @@ void AgileEngine::calculateHashFinal(const OUString& rPassword, vector<sal_uInt8
passwordByteArray + passwordByteLength,
initialData.begin() + saltSize);
- vector<sal_uInt8> hash(mInfo.hashSize, 0);
+ std::vector<sal_uInt8> hash(mInfo.hashSize, 0);
hashCalc(hash, initialData, mInfo.hashAlgorithm);
- vector<sal_uInt8> data(mInfo.hashSize + 4, 0);
+ std::vector<sal_uInt8> data(mInfo.hashSize + 4, 0);
for (sal_Int32 i = 0; i < mInfo.spinCount; i++)
{
- ByteOrderConverter::writeLittleEndian( &data[0], i );
+ ByteOrderConverter::writeLittleEndian(data.data(), i);
std::copy(hash.begin(), hash.end(), data.begin() + 4);
hashCalc(hash, data, mInfo.hashAlgorithm);
}
@@ -114,60 +99,63 @@ void AgileEngine::calculateHashFinal(const OUString& rPassword, vector<sal_uInt8
bool AgileEngine::generateEncryptionKey(const OUString& rPassword)
{
+ static const std::vector<sal_uInt8> constBlock1{ 0xfe, 0xa7, 0xd2, 0x76, 0x3b, 0x4b, 0x9e, 0x79 };
+ static const std::vector<sal_uInt8> constBlock2{ 0xd7, 0xaa, 0x0f, 0x6d, 0x30, 0x61, 0x34, 0x4e };
+ static const std::vector<sal_uInt8> constBlock3{ 0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, 0xd6 };
+
mKey.clear();
mKey.resize(mInfo.keyBits / 8, 0);
- vector<sal_uInt8> hashFinal(mInfo.hashSize, 0);
+ std::vector<sal_uInt8> hashFinal(mInfo.hashSize, 0);
calculateHashFinal(rPassword, hashFinal);
- vector<sal_uInt8> encryptedHashInput = mInfo.encryptedVerifierHashInput;
- vector<sal_uInt8> hashInput(mInfo.saltSize, 0);
- calculateBlock(constBlock1, sizeof(constBlock1), hashFinal, encryptedHashInput, hashInput);
+ std::vector<sal_uInt8>& encryptedHashInput = mInfo.encryptedVerifierHashInput;
+ std::vector<sal_uInt8> hashInput(mInfo.saltSize, 0);
+ calculateBlock(constBlock1, hashFinal, encryptedHashInput, hashInput);
- vector<sal_uInt8> encryptedHashValue = mInfo.encryptedVerifierHashValue;
- vector<sal_uInt8> hashValue(encryptedHashValue.size(), 0);
- calculateBlock(constBlock2, sizeof(constBlock2), hashFinal, encryptedHashValue, hashValue);
+ std::vector<sal_uInt8>& encryptedHashValue = mInfo.encryptedVerifierHashValue;
+ std::vector<sal_uInt8> hashValue(encryptedHashValue.size(), 0);
+ calculateBlock(constBlock2, hashFinal, encryptedHashValue, hashValue);
- vector<sal_uInt8> hash(mInfo.hashSize, 0);
+ std::vector<sal_uInt8> hash(mInfo.hashSize, 0);
hashCalc(hash, hashInput, mInfo.hashAlgorithm);
if (std::equal (hash.begin(), hash.end(), hashValue.begin()) )
{
- vector<sal_uInt8> encryptedKeyValue = mInfo.encryptedKeyValue;
- calculateBlock(constBlock3, sizeof(constBlock3), hashFinal, encryptedKeyValue, mKey);
+ std::vector<sal_uInt8>& encryptedKeyValue = mInfo.encryptedKeyValue;
+ calculateBlock(constBlock3, hashFinal, encryptedKeyValue, mKey);
return true;
}
return false;
}
-bool AgileEngine::decrypt(
- BinaryXInputStream& aInputStream,
- BinaryXOutputStream& aOutputStream)
+bool AgileEngine::decrypt(BinaryXInputStream& aInputStream,
+ BinaryXOutputStream& aOutputStream)
{
sal_uInt32 totalSize = aInputStream.readuInt32(); // Document unencrypted size - 4 bytes
- aInputStream.skip( 4 ); // Reserved 4 Bytes
+ aInputStream.skip(4); // Reserved 4 Bytes
- vector<sal_uInt8> keyDataSalt = mInfo.keyDataSalt;
+ std::vector<sal_uInt8>& keyDataSalt = mInfo.keyDataSalt;
sal_uInt32 saltSize = mInfo.saltSize;
sal_uInt32 keySize = mInfo.keyBits / 8;
sal_uInt32 segment = 0;
- vector<sal_uInt8> saltWithBlockKey(saltSize + sizeof(segment), 0);
+ std::vector<sal_uInt8> saltWithBlockKey(saltSize + sizeof(segment), 0);
std::copy(keyDataSalt.begin(), keyDataSalt.end(), saltWithBlockKey.begin());
- vector<sal_uInt8> hash(mInfo.hashSize, 0);
- vector<sal_uInt8> iv(keySize, 0);
+ std::vector<sal_uInt8> hash(mInfo.hashSize, 0);
+ std::vector<sal_uInt8> iv(keySize, 0);
- vector<sal_uInt8> inputBuffer (SEGMENT_LENGTH);
- vector<sal_uInt8> outputBuffer(SEGMENT_LENGTH);
+ std::vector<sal_uInt8> inputBuffer(constSegmentLength);
+ std::vector<sal_uInt8> outputBuffer(constSegmentLength);
sal_uInt32 inputLength;
sal_uInt32 outputLength;
sal_uInt32 remaining = totalSize;
- while( (inputLength = aInputStream.readMemory( &inputBuffer[0], SEGMENT_LENGTH )) > 0 )
+ while ((inputLength = aInputStream.readMemory(inputBuffer.data(), constSegmentLength)) > 0)
{
sal_uInt8* segmentBegin = reinterpret_cast<sal_uInt8*>(&segment);
sal_uInt8* segmentEnd = segmentBegin + sizeof(segment);
@@ -182,7 +170,7 @@ bool AgileEngine::decrypt(
outputLength = aDecryptor.update(outputBuffer, inputBuffer, inputLength);
sal_uInt32 writeLength = outputLength > remaining ? remaining : outputLength;
- aOutputStream.writeMemory( &outputBuffer[0], writeLength );
+ aOutputStream.writeMemory(outputBuffer.data(), writeLength);
remaining -= outputLength;
segment++;
diff --git a/oox/source/crypto/CryptTools.cxx b/oox/source/crypto/CryptTools.cxx
index 4bb3ec2..b1e3345 100644
--- a/oox/source/crypto/CryptTools.cxx
+++ b/oox/source/crypto/CryptTools.cxx
@@ -15,8 +15,6 @@
namespace oox {
namespace core {
-using namespace std;
-
Crypto::Crypto()
#if USE_TLS_NSS
: mContext(nullptr)
@@ -61,7 +59,7 @@ const EVP_CIPHER* Crypto::getCipher(CryptoType type)
#endif
#if USE_TLS_NSS
-void Crypto::setupContext(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoType type, CK_ATTRIBUTE_TYPE operation)
+void Crypto::setupContext(std::vector<sal_uInt8>& key, std::vector<sal_uInt8>& iv, CryptoType type, CK_ATTRIBUTE_TYPE operation)
{
CK_MECHANISM_TYPE mechanism = static_cast<CK_ULONG>(-1);
@@ -70,7 +68,7 @@ void Crypto::setupContext(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoT
if(iv.empty())
ivItem.data = nullptr;
else
- ivItem.data = &iv[0];
+ ivItem.data = iv.data();
ivItem.len = iv.size();
SECItem* pIvItem = nullptr;
@@ -92,37 +90,37 @@ void Crypto::setupContext(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoT
break;
}
- PK11SlotInfo* pSlot( PK11_GetBestSlot( mechanism, nullptr ) );
+ PK11SlotInfo* pSlot(PK11_GetBestSlot(mechanism, nullptr));
if (!pSlot)
throw css::uno::RuntimeException("NSS Slot failure", css::uno::Reference<css::uno::XInterface>());
SECItem keyItem;
keyItem.type = siBuffer;
- keyItem.data = &key[0];
+ keyItem.data = key.data();
keyItem.len = key.size();
- mSymKey = PK11_ImportSymKey( pSlot, mechanism, PK11_OriginUnwrap, CKA_ENCRYPT, &keyItem, nullptr );
- mSecParam = PK11_ParamFromIV( mechanism, pIvItem );
- mContext = PK11_CreateContextBySymKey( mechanism, operation, mSymKey, mSecParam );
+ mSymKey = PK11_ImportSymKey(pSlot, mechanism, PK11_OriginUnwrap, CKA_ENCRYPT, &keyItem, nullptr);
+ mSecParam = PK11_ParamFromIV(mechanism, pIvItem);
+ mContext = PK11_CreateContextBySymKey(mechanism, operation, mSymKey, mSecParam);
}
#endif // USE_TLS_NSS
// DECRYPT
-Decrypt::Decrypt(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoType type) :
- Crypto()
+Decrypt::Decrypt(std::vector<sal_uInt8>& key, std::vector<sal_uInt8>& iv, CryptoType type)
+ : Crypto()
{
#if USE_TLS_OPENSSL
- EVP_CIPHER_CTX_init( &mContext );
+ EVP_CIPHER_CTX_init(&mContext);
const EVP_CIPHER* cipher = getCipher(type);
if (iv.empty())
- EVP_DecryptInit_ex( &mContext, cipher, NULL, &key[0], 0 );
+ EVP_DecryptInit_ex(&mContext, cipher, nullptr, key.data(), 0);
else
- EVP_DecryptInit_ex( &mContext, cipher, NULL, &key[0], &iv[0] );
- EVP_CIPHER_CTX_set_padding( &mContext, 0 );
+ EVP_DecryptInit_ex(&mContext, cipher, nullptr, key.data(), iv.data());
+ EVP_CIPHER_CTX_set_padding(&mContext, 0);
#endif
#if USE_TLS_NSS
@@ -130,27 +128,27 @@ Decrypt::Decrypt(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoType type)
#endif // USE_TLS_NSS
}
-sal_uInt32 Decrypt::update(vector<sal_uInt8>& output, vector<sal_uInt8>& input, sal_uInt32 inputLength)
+sal_uInt32 Decrypt::update(std::vector<sal_uInt8>& output, std::vector<sal_uInt8>& input, sal_uInt32 inputLength)
{
int outputLength = 0;
sal_uInt32 actualInputLength = inputLength == 0 || inputLength > input.size() ? input.size() : inputLength;
#if USE_TLS_OPENSSL
- (void)EVP_DecryptUpdate( &mContext, &output[0], &outputLength, &input[0], actualInputLength );
+ (void)EVP_DecryptUpdate(&mContext, output.data(), &outputLength, input.data(), actualInputLength);
#endif // USE_TLS_OPENSSL
#if USE_TLS_NSS
- (void)PK11_CipherOp( mContext, &output[0], &outputLength, actualInputLength, &input[0], actualInputLength );
+ (void)PK11_CipherOp( mContext, output.data(), &outputLength, actualInputLength, input.data(), actualInputLength );
#endif // USE_TLS_NSS
return static_cast<sal_uInt32>(outputLength);
}
-sal_uInt32 Decrypt::aes128ecb(vector<sal_uInt8>& output, vector<sal_uInt8>& input, vector<sal_uInt8>& key)
+sal_uInt32 Decrypt::aes128ecb(std::vector<sal_uInt8>& output, std::vector<sal_uInt8>& input, std::vector<sal_uInt8>& key)
{
sal_uInt32 outputLength = 0;
- vector<sal_uInt8> iv;
+ std::vector<sal_uInt8> iv;
Decrypt crypto(key, iv, Crypto::AES_128_ECB);
outputLength = crypto.update(output, input);
return outputLength;
@@ -158,19 +156,19 @@ sal_uInt32 Decrypt::aes128ecb(vector<sal_uInt8>& output, vector<sal_uInt8>& inpu
// ENCRYPT
-Encrypt::Encrypt(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoType type) :
- Crypto()
+Encrypt::Encrypt(std::vector<sal_uInt8>& key, std::vector<sal_uInt8>& iv, CryptoType type)
+ : Crypto()
{
#if USE_TLS_OPENSSL
- EVP_CIPHER_CTX_init( &mContext );
+ EVP_CIPHER_CTX_init(&mContext);
const EVP_CIPHER* cipher = getCipher(type);
if (iv.empty())
- EVP_EncryptInit_ex( &mContext, cipher, NULL, &key[0], 0 );
+ EVP_EncryptInit_ex(&mContext, cipher, nullptr, key.data(), 0);
else
- EVP_EncryptInit_ex( &mContext, cipher, NULL, &key[0], &iv[0] );
- EVP_CIPHER_CTX_set_padding( &mContext, 0 );
+ EVP_EncryptInit_ex(&mContext, cipher, nullptr, key.data(), iv.data());
+ EVP_CIPHER_CTX_set_padding(&mContext, 0);
#endif
#if USE_TLS_NSS
@@ -178,18 +176,18 @@ Encrypt::Encrypt(vector<sal_uInt8>& key, vector<sal_uInt8>& iv, CryptoType type)
#endif // USE_TLS_NSS
}
-sal_uInt32 Encrypt::update(vector<sal_uInt8>& output, vector<sal_uInt8>& input, sal_uInt32 inputLength)
+sal_uInt32 Encrypt::update(std::vector<sal_uInt8>& output, std::vector<sal_uInt8>& input, sal_uInt32 inputLength)
{
int outputLength = 0;
sal_uInt32 actualInputLength = inputLength == 0 || inputLength > input.size() ? input.size() : inputLength;
#if USE_TLS_OPENSSL
- (void)EVP_EncryptUpdate( &mContext, &output[0], &outputLength, &input[0], actualInputLength );
+ (void)EVP_EncryptUpdate(&mContext, output.data(), &outputLength, input.data(), actualInputLength);
#endif // USE_TLS_OPENSSL
#if USE_TLS_NSS
- (void)PK11_CipherOp( mContext, &output[0], &outputLength, actualInputLength, &input[0], actualInputLength );
+ (void)PK11_CipherOp(mContext, output.data(), &outputLength, actualInputLength, input.data(), actualInputLength);
#endif // USE_TLS_NSS
return static_cast<sal_uInt32>(outputLength);
@@ -237,29 +235,29 @@ HASH_HashType lclNSSgetHashType(Digest::DigestType eType)
Digest::Digest(DigestType eType) :
meType(eType)
{
- #if USE_TLS_OPENSSL
+#if USE_TLS_OPENSSL
mpContext = EVP_MD_CTX_create();
EVP_DigestInit_ex(mpContext, lclOpenSSLgetEngine(eType), NULL);
- #endif
+#endif
- #if USE_TLS_NSS
+#if USE_TLS_NSS
NSS_NoDB_Init(nullptr);
mpContext = HASH_Create(lclNSSgetHashType(eType));
HASH_Begin(mpContext);
- #endif
+#endif
}
Digest::~Digest()
{
- #if USE_TLS_OPENSSL
+#if USE_TLS_OPENSSL
if(mpContext)
EVP_MD_CTX_destroy(mpContext);
- #endif
+#endif
- #if USE_TLS_NSS
+#if USE_TLS_NSS
if(mpContext)
HASH_Destroy(mpContext);
- #endif
+#endif
}
sal_uInt32 Digest::getLength()
@@ -278,33 +276,33 @@ sal_uInt32 Digest::getLength()
void Digest::update(std::vector<sal_uInt8>& input)
{
- #if USE_TLS_OPENSSL
- EVP_DigestUpdate(mpContext, &input[0], input.size());
- #endif
- #if USE_TLS_NSS
- HASH_Update(mpContext, &input[0], input.size());
- #endif
+#if USE_TLS_OPENSSL
+ EVP_DigestUpdate(mpContext, input.data(), input.size());
+#endif
+#if USE_TLS_NSS
+ HASH_Update(mpContext, input.data(), input.size());
+#endif
}
void Digest::finalize(std::vector<sal_uInt8>& digest)
{
digest.clear();
- #if USE_TLS_OPENSSL
+#if USE_TLS_OPENSSL
unsigned int digestWrittenLength;
digest.resize(getLength(), 0);
- EVP_DigestFinal_ex(mpContext, &digest[0], &digestWrittenLength);
- #endif
+ EVP_DigestFinal_ex(mpContext, digest.data(), &digestWrittenLength);
+#endif
- #if USE_TLS_NSS
+#if USE_TLS_NSS
unsigned int digestWrittenLength;
unsigned int digestLength = static_cast<unsigned int>(getLength());
digest.resize(digestLength, 0);
- HASH_End(mpContext, &digest[0], &digestWrittenLength, digestLength);
- #endif
+ HASH_End(mpContext, digest.data(), &digestWrittenLength, digestLength);
+#endif
}
-bool Digest::sha1(vector<sal_uInt8>& output, vector<sal_uInt8>& input)
+bool Digest::sha1(std::vector<sal_uInt8>& output, std::vector<sal_uInt8>& input)
{
bool aResult = false;
@@ -315,7 +313,7 @@ bool Digest::sha1(vector<sal_uInt8>& output, vector<sal_uInt8>& input)
return aResult;
}
-bool Digest::sha512(vector<sal_uInt8>& output, vector<sal_uInt8>& input)
+bool Digest::sha512(std::vector<sal_uInt8>& output, std::vector<sal_uInt8>& input)
{
bool aResult = false;
diff --git a/oox/source/crypto/DocumentDecryption.cxx b/oox/source/crypto/DocumentDecryption.cxx
index ed1111e..8f0084c 100644
--- a/oox/source/crypto/DocumentDecryption.cxx
+++ b/oox/source/crypto/DocumentDecryption.cxx
@@ -37,20 +37,15 @@ using namespace css::uno;
using namespace css::xml::sax;
using namespace css::xml;
-using namespace std;
-
-using ::comphelper::SequenceAsHashMap;
-using ::sax::Converter;
-
namespace {
-vector<sal_uInt8> convertToVector(Sequence<sal_Int8>& input)
+std::vector<sal_uInt8> convertToVector(Sequence<sal_Int8>& input)
{
- const sal_uInt8* inputArray = reinterpret_cast<const sal_uInt8*>( input.getConstArray() );
- return vector<sal_uInt8>(inputArray, inputArray + input.getLength());
+ const sal_uInt8* inputArray = reinterpret_cast<const sal_uInt8*>(input.getConstArray());
+ return std::vector<sal_uInt8>(inputArray, inputArray + input.getLength());
}
-class AgileTokenHandler : public cppu::WeakImplHelper< XFastTokenHandler >
+class AgileTokenHandler : public cppu::WeakImplHelper<XFastTokenHandler>
{
public:
virtual sal_Int32 SAL_CALL getTokenFromUTF8( const Sequence< sal_Int8 >& /*nIdentifier*/ ) override
@@ -64,7 +59,7 @@ public:
}
};
-class AgileDocumentHandler : public ::cppu::WeakImplHelper< XFastDocumentHandler >
+class AgileDocumentHandler : public ::cppu::WeakImplHelper<XFastDocumentHandler>
{
AgileEncryptionInfo& mInfo;
@@ -82,81 +77,78 @@ public:
void SAL_CALL startFastElement( sal_Int32 /*Element*/, const Reference< XFastAttributeList >& /*Attribs*/ ) override
{}
- void SAL_CALL startUnknownElement( const OUString& /*aNamespace*/, const OUString& aName, const Reference< XFastAttributeList >& aAttributeList ) override
+ void SAL_CALL startUnknownElement( const OUString& /*aNamespace*/, const OUString& rName, const Reference< XFastAttributeList >& aAttributeList ) override
{
- if(aName == "keyData")
+ if (rName == "keyData")
{
- Sequence<Attribute> aAttributes(aAttributeList->getUnknownAttributes());
-
- for (int i=0; i<aAttributes.getLength(); i++)
+ for (const Attribute& rAttribute : aAttributeList->getUnknownAttributes())
{
- if (aAttributes[i].Name == "saltValue")
+ if (rAttribute.Name == "saltValue")
{
Sequence<sal_Int8> keyDataSalt;
- Converter::decodeBase64(keyDataSalt, aAttributes[i].Value);
+ ::sax::Converter::decodeBase64(keyDataSalt, rAttribute.Value);
mInfo.keyDataSalt = convertToVector(keyDataSalt);
}
}
}
- else if(aName == "encryptedKey")
+ else if (rName == "encryptedKey")
{
- Sequence<Attribute> aAttributes(aAttributeList->getUnknownAttributes());
- for (int i=0; i<aAttributes.getLength(); i++)
+ for (const Attribute& rAttribute : aAttributeList->getUnknownAttributes())
{
- if (aAttributes[i].Name == "spinCount")
+ if (rAttribute.Name == "spinCount")
{
- Converter::convertNumber(mInfo.spinCount, aAttributes[i].Value);
+ ::sax::Converter::convertNumber(mInfo.spinCount, rAttribute.Value);
}
- else if (aAttributes[i].Name == "saltSize")
+ else if (rAttribute.Name == "saltSize")
{
- Converter::convertNumber(mInfo.saltSize, aAttributes[i].Value);
+ ::sax::Converter::convertNumber(mInfo.saltSize, rAttribute.Value);
}
- else if (aAttributes[i].Name == "blockSize")
+ else if (rAttribute.Name == "blockSize")
{
- Converter::convertNumber(mInfo.blockSize, aAttributes[i].Value);
+ ::sax::Converter::convertNumber(mInfo.blockSize, rAttribute.Value);
}
- else if (aAttributes[i].Name == "keyBits")
+ else if (rAttribute.Name == "keyBits")
{
- Converter::convertNumber(mInfo.keyBits, aAttributes[i].Value);
+ ::sax::Converter::convertNumber(mInfo.keyBits, rAttribute.Value);
}
- else if (aAttributes[i].Name == "hashSize")
+ else if (rAttribute.Name == "hashSize")
{
- Converter::convertNumber(mInfo.hashSize, aAttributes[i].Value);
+ ::sax::Converter::convertNumber(mInfo.hashSize, rAttribute.Value);
}
- else if (aAttributes[i].Name == "cipherAlgorithm")
+ else if (rAttribute.Name == "cipherAlgorithm")
{
- mInfo.cipherAlgorithm = aAttributes[i].Value;
+ mInfo.cipherAlgorithm = rAttribute.Value;
}
- else if (aAttributes[i].Name == "cipherChaining")
+ else if (rAttribute.Name == "cipherChaining")
{
- mInfo.cipherChaining = aAttributes[i].Value;
+ mInfo.cipherChaining = rAttribute.Value;
}
- else if (aAttributes[i].Name == "hashAlgorithm")
+ else if (rAttribute.Name == "hashAlgorithm")
{
- mInfo.hashAlgorithm = aAttributes[i].Value;
+ mInfo.hashAlgorithm = rAttribute.Value;
}
- else if (aAttributes[i].Name == "saltValue")
+ else if (rAttribute.Name == "saltValue")
{
Sequence<sal_Int8> saltValue;
- Converter::decodeBase64(saltValue, aAttributes[i].Value);
+ ::sax::Converter::decodeBase64(saltValue, rAttribute.Value);
mInfo.saltValue = convertToVector(saltValue);
}
- else if (aAttributes[i].Name == "encryptedVerifierHashInput")
+ else if (rAttribute.Name == "encryptedVerifierHashInput")
{
Sequence<sal_Int8> encryptedVerifierHashInput;
- Converter::decodeBase64(encryptedVerifierHashInput, aAttributes[i].Value);
+ ::sax::Converter::decodeBase64(encryptedVerifierHashInput, rAttribute.Value);
mInfo.encryptedVerifierHashInput = convertToVector(encryptedVerifierHashInput);
}
- else if (aAttributes[i].Name == "encryptedVerifierHashValue")
+ else if (rAttribute.Name == "encryptedVerifierHashValue")
{
Sequence<sal_Int8> encryptedVerifierHashValue;
- Converter::decodeBase64(encryptedVerifierHashValue, aAttributes[i].Value);
+ ::sax::Converter::decodeBase64(encryptedVerifierHashValue, rAttribute.Value);
mInfo.encryptedVerifierHashValue = convertToVector(encryptedVerifierHashValue);
}
- else if (aAttributes[i].Name == "encryptedKeyValue")
+ else if (rAttribute.Name == "encryptedKeyValue")
{
Sequence<sal_Int8> encryptedKeyValue;
- Converter::decodeBase64(encryptedKeyValue, aAttributes[i].Value);
+ ::sax::Converter::decodeBase64(encryptedKeyValue, rAttribute.Value);
mInfo.encryptedKeyValue = convertToVector(encryptedKeyValue);
}
}
@@ -206,15 +198,14 @@ bool DocumentDecryption::readAgileEncryptionInfo(Reference< XInputStream >& xInp
Reference<XFastDocumentHandler> xFastDocumentHandler( new AgileDocumentHandler(info) );
Reference<XFastTokenHandler> xFastTokenHandler ( new AgileTokenHandler );
- Reference<XFastParser> xParser(
- css::xml::sax::FastParser::create(mxContext));
+ Reference<XFastParser> xParser(css::xml::sax::FastParser::create(mxContext));
- xParser->setFastDocumentHandler( xFastDocumentHandler );
- xParser->setTokenHandler( xFastTokenHandler );
+ xParser->setFastDocumentHandler(xFastDocumentHandler);
+ xParser->setTokenHandler(xFastTokenHandler);
InputSource aInputSource;
aInputSource.aInputStream = xInputStream;
- xParser->parseStream( aInputSource );
+ xParser->parseStream(aInputSource);
// CHECK info data
if (2 > info.blockSize || info.blockSize > 4096)
@@ -256,14 +247,14 @@ bool DocumentDecryption::readStandard2007EncryptionInfo(BinaryInputStream& rStre
msfilter::StandardEncryptionInfo& info = engine->getInfo();
info.header.flags = rStream.readuInt32();
- if( getFlag( info.header.flags, msfilter::ENCRYPTINFO_EXTERNAL ) )
+ if (getFlag(info.header.flags, msfilter::ENCRYPTINFO_EXTERNAL))
return false;
sal_uInt32 nHeaderSize = rStream.readuInt32();
sal_uInt32 actualHeaderSize = sizeof(info.header);
- if( (nHeaderSize < actualHeaderSize) )
+ if (nHeaderSize < actualHeaderSize)
return false;
info.header.flags = rStream.readuInt32();
@@ -275,7 +266,7 @@ bool DocumentDecryption::readStandard2007EncryptionInfo(BinaryInputStream& rStre
info.header.reserved1 = rStream.readuInt32();
info.header.reserved2 = rStream.readuInt32();
- rStream.skip( nHeaderSize - actualHeaderSize );
+ rStream.skip(nHeaderSize - actualHeaderSize);
info.verifier.saltSize = rStream.readuInt32();
rStream.readArray(info.verifier.salt, SAL_N_ELEMENTS(info.verifier.salt));
@@ -283,25 +274,25 @@ bool DocumentDecryption::readStandard2007EncryptionInfo(BinaryInputStream& rStre
info.verifier.encryptedVerifierHashSize = rStream.readuInt32();
rStream.readArray(info.verifier.encryptedVerifierHash, SAL_N_ELEMENTS(info.verifier.encryptedVerifierHash));
- if( info.verifier.saltSize != 16 )
+ if (info.verifier.saltSize != 16)
return false;
// check flags and algorithm IDs, required are AES128 and SHA-1
- if( !getFlag( info.header.flags, msfilter::ENCRYPTINFO_CRYPTOAPI ) )
+ if (!getFlag(info.header.flags, msfilter::ENCRYPTINFO_CRYPTOAPI))
return false;
- if( !getFlag( info.header.flags, msfilter::ENCRYPTINFO_AES ) )
+ if (!getFlag(info.header.flags, msfilter::ENCRYPTINFO_AES))
return false;
// algorithm ID 0 defaults to AES128 too, if ENCRYPTINFO_AES flag is set
- if( info.header.algId != 0 && info.header.algId != msfilter::ENCRYPT_ALGO_AES128 )
+ if (info.header.algId != 0 && info.header.algId != msfilter::ENCRYPT_ALGO_AES128)
return false;
// hash algorithm ID 0 defaults to SHA-1 too
- if( info.header.algIdHash != 0 && info.header.algIdHash != msfilter::ENCRYPT_HASH_SHA1 )
+ if (info.header.algIdHash != 0 && info.header.algIdHash != msfilter::ENCRYPT_HASH_SHA1)
return false;
- if( info.verifier.encryptedVerifierHashSize != 20 )
+ if (info.verifier.encryptedVerifierHashSize != 20)
return false;
return !rStream.isEof();
@@ -309,14 +300,14 @@ bool DocumentDecryption::readStandard2007EncryptionInfo(BinaryInputStream& rStre
bool DocumentDecryption::readEncryptionInfo()
{
- if( !mrOleStorage.isStorage() )
+ if (!mrOleStorage.isStorage())
return false;
- Reference< XInputStream > xEncryptionInfo( mrOleStorage.openInputStream( "EncryptionInfo" ), UNO_SET_THROW );
+ Reference<XInputStream> xEncryptionInfo(mrOleStorage.openInputStream("EncryptionInfo"), UNO_SET_THROW);
bool bResult = false;
- BinaryXInputStream aBinaryInputStream( xEncryptionInfo, true );
+ BinaryXInputStream aBinaryInputStream(xEncryptionInfo, true);
sal_uInt32 aVersion = aBinaryInputStream.readuInt32();
@@ -341,7 +332,7 @@ bool DocumentDecryption::readEncryptionInfo()
Sequence<NamedValue> DocumentDecryption::createEncryptionData(const OUString& rPassword)
{
- SequenceAsHashMap aEncryptionData;
+ comphelper::SequenceAsHashMap aEncryptionData;
if (mCryptoType == AGILE)
{
@@ -360,16 +351,16 @@ bool DocumentDecryption::decrypt(const Reference<XStream>& xDocumentStream)
{
bool aResult = false;
- if( !mrOleStorage.isStorage() )
+ if (!mrOleStorage.isStorage())
return false;
// open the required input streams in the encrypted package
- Reference< XInputStream > xEncryptedPackage( mrOleStorage.openInputStream( "EncryptedPackage" ), UNO_SET_THROW );
+ Reference<XInputStream> xEncryptedPackage(mrOleStorage.openInputStream("EncryptedPackage"), UNO_SET_THROW);
// create temporary file for unencrypted package
- Reference< XOutputStream > xDecryptedPackage( xDocumentStream->getOutputStream(), UNO_SET_THROW );
- BinaryXOutputStream aDecryptedPackage( xDecryptedPackage, true );
- BinaryXInputStream aEncryptedPackage( xEncryptedPackage, true );
+ Reference<XOutputStream> xDecryptedPackage(xDocumentStream->getOutputStream(), UNO_SET_THROW);
+ BinaryXOutputStream aDecryptedPackage(xDecryptedPackage, true);
+ BinaryXInputStream aEncryptedPackage(xEncryptedPackage, true);
aResult = mEngine->decrypt(aEncryptedPackage, aDecryptedPackage);
diff --git a/oox/source/crypto/DocumentEncryption.cxx b/oox/source/crypto/DocumentEncryption.cxx
index d9bb07b..493fcbf 100644
--- a/oox/source/crypto/DocumentEncryption.cxx
+++ b/oox/source/crypto/DocumentEncryption.cxx
@@ -26,18 +26,18 @@ using namespace css::io;
using namespace css::lang;
using namespace css::uno;
-using namespace std;
-
-DocumentEncryption::DocumentEncryption(Reference< XStream > const & xDocumentStream, oox::ole::OleStorage& rOleStorage, const OUString& aPassword) :
- mxDocumentStream(xDocumentStream),
- mrOleStorage(rOleStorage),
- maPassword(aPassword)
+DocumentEncryption::DocumentEncryption(Reference<XStream> const & xDocumentStream,
+ oox::ole::OleStorage& rOleStorage,
+ const OUString& rPassword)
+ : mxDocumentStream(xDocumentStream)
+ , mrOleStorage(rOleStorage)
+ , maPassword(rPassword)
{}
bool DocumentEncryption::encrypt()
{
- Reference< XInputStream > xInputStream ( mxDocumentStream->getInputStream(), UNO_SET_THROW );
- Reference< XSeekable > xSeekable( xInputStream, UNO_QUERY );
+ Reference<XInputStream> xInputStream (mxDocumentStream->getInputStream(), UNO_SET_THROW);
+ Reference<XSeekable> xSeekable(xInputStream, UNO_QUERY);
if (!xSeekable.is())
return false;
@@ -47,8 +47,8 @@ bool DocumentEncryption::encrypt()
if (!mrOleStorage.isStorage())
return false;
- Reference< XOutputStream > xEncryptionInfo( mrOleStorage.openOutputStream( "EncryptionInfo" ), UNO_SET_THROW );
- BinaryXOutputStream aEncryptionInfoBinaryOutputStream( xEncryptionInfo, false );
+ Reference<XOutputStream> xEncryptionInfo(mrOleStorage.openOutputStream("EncryptionInfo"), UNO_SET_THROW);
+ BinaryXOutputStream aEncryptionInfoBinaryOutputStream(xEncryptionInfo, false);
mEngine.writeEncryptionInfo(maPassword, aEncryptionInfoBinaryOutputStream);
@@ -56,14 +56,14 @@ bool DocumentEncryption::encrypt()
xEncryptionInfo->flush();
xEncryptionInfo->closeOutput();
- Reference< XOutputStream > xEncryptedPackage( mrOleStorage.openOutputStream( "EncryptedPackage" ), UNO_SET_THROW );
- BinaryXOutputStream aEncryptedPackageStream( xEncryptedPackage, false );
+ Reference<XOutputStream> xEncryptedPackage(mrOleStorage.openOutputStream("EncryptedPackage"), UNO_SET_THROW);
+ BinaryXOutputStream aEncryptedPackageStream(xEncryptedPackage, false);
- BinaryXInputStream aDocumentInputStream( xInputStream, false );
+ BinaryXInputStream aDocumentInputStream(xInputStream, false);
aDocumentInputStream.seekToStart();
- aEncryptedPackageStream.WriteUInt32( aLength ); // size
- aEncryptedPackageStream.WriteUInt32( 0U ); // reserved
+ aEncryptedPackageStream.WriteUInt32(aLength); // size
+ aEncryptedPackageStream.WriteUInt32(0U); // reserved
mEngine.encrypt(aDocumentInputStream, aEncryptedPackageStream);
diff --git a/oox/source/crypto/Standard2007Engine.cxx b/oox/source/crypto/Standard2007Engine.cxx
index ecf9d8c..d95f315 100644
--- a/oox/source/crypto/Standard2007Engine.cxx
+++ b/oox/source/crypto/Standard2007Engine.cxx
@@ -20,8 +20,6 @@
namespace oox {
namespace core {
-using namespace std;
-
/* =========================================================================== */
/* Kudos to Caolan McNamara who provided the core decryption implementations. */
/* =========================================================================== */
@@ -31,23 +29,16 @@ namespace
void lclRandomGenerateValues(sal_uInt8* aArray, sal_uInt32 aSize)
{
TimeValue aTime;
- osl_getSystemTime( &aTime );
- rtlRandomPool aRandomPool = rtl_random_createPool ();
- rtl_random_addBytes ( aRandomPool, &aTime, 8 );
- rtl_random_getBytes ( aRandomPool, aArray, aSize );
- rtl_random_destroyPool ( aRandomPool );
+ osl_getSystemTime(&aTime);
+ rtlRandomPool aRandomPool = rtl_random_createPool();
+ rtl_random_addBytes(aRandomPool, &aTime, 8);
+ rtl_random_getBytes(aRandomPool, aArray, aSize);
+ rtl_random_destroyPool(aRandomPool);
}
static const OUString lclCspName = "Microsoft Enhanced RSA and AES Cryptographic Provider";
-} // namespace
-
-Standard2007Engine::Standard2007Engine() :
- CryptoEngine()
-{}
-
-Standard2007Engine::~Standard2007Engine()
-{}
+} // end anonymous namespace
bool Standard2007Engine::generateVerifier()
{
@@ -55,23 +46,23 @@ bool Standard2007Engine::generateVerifier()
if (mKey.size() != 16)
return false;
- vector<sal_uInt8> verifier(msfilter::ENCRYPTED_VERIFIER_LENGTH);
- vector<sal_uInt8> encryptedVerifier(msfilter::ENCRYPTED_VERIFIER_LENGTH);
+ std::vector<sal_uInt8> verifier(msfilter::ENCRYPTED_VERIFIER_LENGTH);
+ std::vector<sal_uInt8> encryptedVerifier(msfilter::ENCRYPTED_VERIFIER_LENGTH);
- lclRandomGenerateValues(&verifier[0], verifier.size());
+ lclRandomGenerateValues(verifier.data(), verifier.size());
- vector<sal_uInt8> iv;
+ std::vector<sal_uInt8> iv;
Encrypt aEncryptorVerifier(mKey, iv, Crypto::AES_128_ECB);
if (aEncryptorVerifier.update(encryptedVerifier, verifier) != msfilter::ENCRYPTED_VERIFIER_LENGTH)
return false;
std::copy(encryptedVerifier.begin(), encryptedVerifier.end(), mInfo.verifier.encryptedVerifier);
- vector<sal_uInt8> hash(msfilter::SHA1_HASH_LENGTH, 0);
+ std::vector<sal_uInt8> hash(msfilter::SHA1_HASH_LENGTH, 0);
mInfo.verifier.encryptedVerifierHashSize = msfilter::SHA1_HASH_LENGTH;
Digest::sha1(hash, verifier);
hash.resize(msfilter::SHA256_HASH_LENGTH, 0);
- vector<sal_uInt8> encryptedHash(msfilter::SHA256_HASH_LENGTH, 0);
+ std::vector<sal_uInt8> encryptedHash(msfilter::SHA256_HASH_LENGTH, 0);
Encrypt aEncryptorHash(mKey, iv, Crypto::AES_128_ECB);
aEncryptorHash.update(encryptedHash, hash, hash.size());
@@ -87,7 +78,7 @@ bool Standard2007Engine::calculateEncryptionKey(const OUString& rPassword)
const sal_uInt8* saltArray = mInfo.verifier.salt;
// Prepare initial data -> salt + password (in 16-bit chars)
- vector<sal_uInt8> initialData(saltSize + passwordByteLength);
+ std::vector<sal_uInt8> initialData(saltSize + passwordByteLength);
std::copy(saltArray, saltArray + saltSize, initialData.begin());
const sal_uInt8* passwordByteArray = reinterpret_cast<const sal_uInt8*>(rPassword.getStr());
@@ -98,17 +89,17 @@ bool Standard2007Engine::calculateEncryptionKey(const OUString& rPassword)
initialData.begin() + saltSize);
// use "hash" vector for result of sha1 hashing
- vector<sal_uInt8> hash(msfilter::SHA1_HASH_LENGTH, 0);
+ std::vector<sal_uInt8> hash(msfilter::SHA1_HASH_LENGTH, 0);
// calculate SHA1 hash of initialData
Digest::sha1(hash, initialData);
// data = iterator (4bytes) + hash
- vector<sal_uInt8> data(msfilter::SHA1_HASH_LENGTH + 4, 0);
+ std::vector<sal_uInt8> data(msfilter::SHA1_HASH_LENGTH + 4, 0);
for (sal_Int32 i = 0; i < 50000; ++i)
{
- ByteOrderConverter::writeLittleEndian( &data[0], i );
+ ByteOrderConverter::writeLittleEndian(data.data(), i);
std::copy(hash.begin(), hash.end(), data.begin() + 4);
Digest::sha1(hash, data);
}
@@ -118,8 +109,8 @@ bool Standard2007Engine::calculateEncryptionKey(const OUString& rPassword)
Digest::sha1(hash, data);
// derive key
- vector<sal_uInt8> buffer(64, 0x36);
- for( size_t i = 0; i < hash.size(); ++i )
+ std::vector<sal_uInt8> buffer(64, 0x36);
+ for (size_t i = 0; i < hash.size(); ++i)
buffer[i] ^= hash[i];
Digest::sha1(hash, buffer);
@@ -135,48 +126,47 @@ bool Standard2007Engine::generateEncryptionKey(const OUString& password)
calculateEncryptionKey(password);
- vector<sal_uInt8> encryptedVerifier(msfilter::ENCRYPTED_VERIFIER_LENGTH);
+ std::vector<sal_uInt8> encryptedVerifier(msfilter::ENCRYPTED_VERIFIER_LENGTH);
std::copy(
mInfo.verifier.encryptedVerifier,
mInfo.verifier.encryptedVerifier + msfilter::ENCRYPTED_VERIFIER_LENGTH,
encryptedVerifier.begin());
- vector<sal_uInt8> encryptedHash(msfilter::SHA256_HASH_LENGTH);
+ std::vector<sal_uInt8> encryptedHash(msfilter::SHA256_HASH_LENGTH);
std::copy(
mInfo.verifier.encryptedVerifierHash,
mInfo.verifier.encryptedVerifierHash + msfilter::SHA256_HASH_LENGTH,
encryptedHash.begin());
- vector<sal_uInt8> verifier(encryptedVerifier.size(), 0);
+ std::vector<sal_uInt8> verifier(encryptedVerifier.size(), 0);
Decrypt::aes128ecb(verifier, encryptedVerifier, mKey);
- vector<sal_uInt8> verifierHash(encryptedHash.size(), 0);
+ std::vector<sal_uInt8> verifierHash(encryptedHash.size(), 0);
Decrypt::aes128ecb(verifierHash, encryptedHash, mKey);
- vector<sal_uInt8> hash(msfilter::SHA1_HASH_LENGTH, 0);
+ std::vector<sal_uInt8> hash(msfilter::SHA1_HASH_LENGTH, 0);
Digest::sha1(hash, verifier);
- return std::equal( hash.begin(), hash.end(), verifierHash.begin() );
+ return std::equal(hash.begin(), hash.end(), verifierHash.begin());
}
-bool Standard2007Engine::decrypt(
- BinaryXInputStream& aInputStream,
- BinaryXOutputStream& aOutputStream)
+bool Standard2007Engine::decrypt(BinaryXInputStream& aInputStream,
+ BinaryXOutputStream& aOutputStream)
{
- aInputStream.skip(4); // Document unencrypted size - 4 bytes
- aInputStream.skip(4); // Reserved 4 Bytes
+ aInputStream.skip(4); // Document unencrypted size - 4 bytes
+ aInputStream.skip(4); // Reserved 4 Bytes
- vector<sal_uInt8> iv;
+ std::vector<sal_uInt8> iv;
Decrypt aDecryptor(mKey, iv, Crypto::AES_128_ECB);
- vector<sal_uInt8> inputBuffer (4096);
- vector<sal_uInt8> outputBuffer(4096);
+ std::vector<sal_uInt8> inputBuffer (4096);
+ std::vector<sal_uInt8> outputBuffer(4096);
sal_uInt32 inputLength;
sal_uInt32 outputLength;
- while( (inputLength = aInputStream.readMemory( &inputBuffer[0], inputBuffer.size() )) > 0 )
+ while ((inputLength = aInputStream.readMemory(inputBuffer.data(), inputBuffer.size())) > 0)
{
outputLength = aDecryptor.update(outputBuffer, inputBuffer, inputLength);
- aOutputStream.writeMemory( &outputBuffer[0], outputLength );
+ aOutputStream.writeMemory(outputBuffer.data(), outputLength);
}
return true;
}
@@ -207,9 +197,9 @@ void Standard2007Engine::writeEncryptionInfo(const OUString& password, BinaryXOu
sal_uInt32 encryptionHeaderSize = static_cast<sal_uInt32>(sizeof(msfilter::EncryptionStandardHeader));
- rStream.WriteUInt32( mInfo.header.flags );
+ rStream.WriteUInt32(mInfo.header.flags);
sal_uInt32 headerSize = encryptionHeaderSize + cspNameSize;
- rStream.WriteUInt32( headerSize );
+ rStream.WriteUInt32(headerSize);
rStream.writeMemory(&mInfo.header, encryptionHeaderSize);
rStream.writeUnicodeArray(lclCspName);
@@ -219,24 +209,23 @@ void Standard2007Engine::writeEncryptionInfo(const OUString& password, BinaryXOu
rStream.writeMemory(&mInfo.verifier, encryptionVerifierSize);
}
-void Standard2007Engine::encrypt(
- BinaryXInputStream& aInputStream,
- BinaryXOutputStream& aOutputStream)
+void Standard2007Engine::encrypt(BinaryXInputStream& aInputStream,
+ BinaryXOutputStream& aOutputStream)
{
- vector<sal_uInt8> inputBuffer(1024);
- vector<sal_uInt8> outputBuffer(1024);
+ std::vector<sal_uInt8> inputBuffer(1024);
+ std::vector<sal_uInt8> outputBuffer(1024);
sal_uInt32 inputLength;
sal_uInt32 outputLength;
- vector<sal_uInt8> iv;
+ std::vector<sal_uInt8> iv;
Encrypt aEncryptor(mKey, iv, Crypto::AES_128_ECB);
- while( (inputLength = aInputStream.readMemory( &inputBuffer[0], inputBuffer.size() )) > 0 )
+ while ((inputLength = aInputStream.readMemory(inputBuffer.data(), inputBuffer.size())) > 0)
{
inputLength = inputLength % 16 == 0 ? inputLength : ((inputLength / 16) * 16) + 16;
outputLength = aEncryptor.update(outputBuffer, inputBuffer, inputLength);
- aOutputStream.writeMemory( &outputBuffer[0], outputLength );
+ aOutputStream.writeMemory(outputBuffer.data(), outputLength);
}
}
More information about the Libreoffice-commits
mailing list