Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
DocumentServer-v-9.2.0/core/OfficeCryptReader/source/ECMACryptFile.cpp
Yajbir Singh f1b860b25c
Some checks failed
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

1115 lines
37 KiB
C++
Raw Permalink Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2023
*
* This program is a free software product. You can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License (AGPL)
* version 3 as published by the Free Software Foundation. In accordance with
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
* that Ascensio System SIA expressly excludes the warranty of non-infringement
* of any third-party rights.
*
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
* street, Riga, Latvia, EU, LV-1050.
*
* The interactive user interfaces in modified source and object code versions
* of the Program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU AGPL version 3.
*
* Pursuant to Section 7(b) of the License you must retain the original Product
* logo when distributing the program. Pursuant to Section 7(e) we decline to
* grant you any rights under trademark law for use of our trademarks.
*
* All the Product's GUI elements, including illustrations and icon sets, as
* well as technical writing content are licensed under the terms of the
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
*
*/
#include "ECMACryptFile.h"
#include "CryptTransform.h"
#include "../../Common/3dParty/pole/pole.h"
#include "../../OOXML/Base/Base.h"
#include "../../DesktopEditor/common/File.h"
#include "../../DesktopEditor/common/SystemUtils.h"
#include "../../DesktopEditor/xml/include/xmlutils.h"
#include "../../MsBinaryFile/DocFile/MemoryStream.h"
#include "simple_xml_writer.h"
#include "../../Common/cfcpp/compoundfile.h"
//CRYPT::_ecmaCryptData cryptDataGlobal; for Test
#define USE_MSSTORAGE
using namespace CRYPT;
#define GETBIT(from, num) ((from & (1 << num)) != 0)
#define SETBIT(to, num, setorclear) {setorclear ? to |= (1 << num) : to &= ~(1 << num);}
#define WritingElement_ReadAttributes_Start(Reader) \
if ( Reader.GetAttributesCount() <= 0 )\
return false;\
if ( !Reader.MoveToFirstAttribute() )\
return false;\
std::string wsName = Reader.GetNameA();\
while( !wsName.empty() )\
{
#define WritingElement_ReadAttributes_Read_if(Reader, AttrName, Value) \
if ( AttrName == wsName )\
{\
Value = Reader.GetTextA();\
}
#define WritingElement_ReadAttributes_Read_else_if(Reader, AttrName, Value) \
else if ( AttrName == wsName )\
Value = Reader.GetTextA();
#define WritingElement_ReadAttributes_ReadSingle(Reader, AttrName, Value) \
if ( AttrName == wsName )\
{\
Value = Reader.GetTextA();\
break;\
}
#define WritingElement_ReadAttributes_End(Reader) \
if ( !Reader.MoveToNextAttribute() ) \
break;\
wsName = Reader.GetNameA();\
}\
Reader.MoveToElement();
std::wstring ReadUnicodeLP(POLE::Stream *pStream)
{
if (!pStream) return L"";
_UINT32 length = 0;
pStream->read((unsigned char*)&length, 4);
unsigned char* Data = new unsigned char[length * 2];
pStream->read(Data, length * 2);
std::wstring res;
if (sizeof(wchar_t) == 4)
{
unsigned int nLength = length;
wchar_t* ptr = new wchar_t [length];
UTF16* pStrUtf16 = (UTF16*) Data;
UTF32 *pStrUtf32 = (UTF32 *) ptr;
const UTF16 *pStrUtf16_Conv = pStrUtf16;
UTF32 *pStrUtf32_Conv = pStrUtf32;
ConversionResult eUnicodeConversionResult = ConvertUTF16toUTF32 (&pStrUtf16_Conv, &pStrUtf16[nLength]
, &pStrUtf32_Conv, &pStrUtf32 [nLength], strictConversion);
if (conversionOK != eUnicodeConversionResult)
{
}
res = std::wstring(ptr, length);
delete []ptr;
}
else
res = std::wstring((wchar_t*)Data, length);
return res;
}
void ReadMapEntry(POLE::Stream *pStream, ECMACryptFile::_mapEntry & m)
{
if (!pStream) return;
_UINT32 length = 0;
pStream->read((unsigned char*)&length, 4);
_UINT32 refCount = 0;
pStream->read((unsigned char*)&refCount, 4);
for (_UINT32 i = 0 ; i < refCount; i++)
{
ECMACryptFile::_refComponent r;
pStream->read((unsigned char*)&r.type, 4);
r.ref = ReadUnicodeLP(pStream);
m.refComponents.push_back(r);
}
m.dataSpaceName= ReadUnicodeLP(pStream);
}
std::string DecodeBase64(const std::string & value)
{
int nLength = 0;
unsigned char *pData = NULL;
std::string result;
NSFile::CBase64Converter::Decode(value.c_str(), (int)value.length(), pData, nLength);
if (pData)
{
result = std::string((char*)pData, nLength);
delete []pData; pData = NULL;
}
return result;
}
std::string EncodeBase64(const std::string & value)
{
int nLength = 0;
char *pData = NULL;
std::string result;
NSFile::CBase64Converter::Encode((BYTE*)value.c_str(), (int)value.length(), pData, nLength, NSBase64::B64_BASE64_FLAG_NOCRLF);
if (pData)
{
result = std::string(pData, nLength);
delete []pData; pData = NULL;
}
return result;
}
//-----------------------------------------------------------------------------------------------------------------------
struct _keyEncryptor
{
std::string spinCount;
std::string saltSize;
std::string blockSize;
std::string keyBits;
std::string hashSize;
std::string cipherAlgorithm;
std::string cipherChaining;
std::string hashAlgorithm;
std::string saltValue;
std::string encryptedVerifierHashInput;
std::string encryptedVerifierHashValue;
std::string encryptedKeyValue;
};
struct _dataIntegrity
{
std::string encryptedHmacKey;
std::string encryptedHmacValue;
};
bool ReadXmlEncryptionInfo(const std::string & xml_string, _ecmaCryptData & cryptData)
{
XmlUtils::CXmlLiteReader xmlReader;
if (!xmlReader.FromStringA(xml_string))
return false;
if ( !xmlReader.ReadNextNode() )
return false;
_dataIntegrity dataIntegrity;
_keyEncryptor keyData;
std::vector<_keyEncryptor> keyEncryptors;
int nCurDepth = xmlReader.GetDepth();
while( xmlReader.ReadNextSiblingNode( nCurDepth ) )
{
std::wstring sName = xmlReader.GetName();
if ( L"keyData" == sName )
{
WritingElement_ReadAttributes_Start( xmlReader)
WritingElement_ReadAttributes_Read_if ( xmlReader, "saltSize", keyData.saltSize )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "blockSize", keyData.blockSize )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "keyBits", keyData.keyBits )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "hashSize", keyData.hashSize )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "cipherAlgorithm", keyData.cipherAlgorithm )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "cipherChaining", keyData.cipherChaining )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "hashAlgorithm", keyData.hashAlgorithm )
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "saltValue", keyData.saltValue )
WritingElement_ReadAttributes_End( xmlReader )
}
else if ( L"dataIntegrity" == sName )
{
WritingElement_ReadAttributes_Start( xmlReader)
WritingElement_ReadAttributes_Read_if ( xmlReader, "encryptedHmacKey", dataIntegrity.encryptedHmacKey)
WritingElement_ReadAttributes_Read_else_if ( xmlReader, "encryptedHmacValue", dataIntegrity.encryptedHmacValue)
WritingElement_ReadAttributes_End( xmlReader )
}
else if (L"keyEncryptors" == sName)
{
while( xmlReader.ReadNextSiblingNode( nCurDepth + 1 ) )
{
sName = xmlReader.GetName();
if (L"keyEncryptor" == sName)
{
while( xmlReader.ReadNextSiblingNode( nCurDepth + 2 ) )
{
sName = xmlReader.GetName();
if (L"p:encryptedKey" == sName)
{
_keyEncryptor k;
WritingElement_ReadAttributes_Start( xmlReader)
WritingElement_ReadAttributes_Read_if ( xmlReader, "spinCount", k.spinCount )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "saltSize", k.saltSize )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "blockSize", k.blockSize )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "keyBits", k.keyBits )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "hashSize", k.hashSize )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "cipherAlgorithm", k.cipherAlgorithm )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "cipherChaining", k.cipherChaining )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "hashAlgorithm", k.hashAlgorithm )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "saltValue", k.saltValue )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "encryptedVerifierHashInput", k.encryptedVerifierHashInput )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "encryptedVerifierHashValue", k.encryptedVerifierHashValue )
WritingElement_ReadAttributes_Read_else_if( xmlReader, "encryptedKeyValue", k.encryptedKeyValue )
WritingElement_ReadAttributes_End( xmlReader )
keyEncryptors.push_back(k);
}
}
}
}
}
}
if (keyEncryptors.empty()) return false;
cryptData.spinCount = atoi(keyEncryptors[0].spinCount.c_str());
cryptData.blockSize = atoi(keyEncryptors[0].blockSize.c_str());
cryptData.hashSize = atoi(keyEncryptors[0].hashSize.c_str());
cryptData.saltSize = atoi(keyEncryptors[0].saltSize.c_str());
cryptData.keySize = atoi(keyEncryptors[0].keyBits.c_str() ) / 8;
cryptData.saltValue = DecodeBase64(keyEncryptors[0].saltValue);
cryptData.encryptedKeyValue = DecodeBase64(keyEncryptors[0].encryptedKeyValue);
cryptData.encryptedVerifierInput = DecodeBase64(keyEncryptors[0].encryptedVerifierHashInput);
cryptData.encryptedVerifierValue = DecodeBase64(keyEncryptors[0].encryptedVerifierHashValue);
if (keyEncryptors[0].hashAlgorithm == "SHA1") cryptData.hashAlgorithm = CRYPT_METHOD::SHA1;
else if (keyEncryptors[0].hashAlgorithm == "SHA224") cryptData.hashAlgorithm = CRYPT_METHOD::SHA224;
else if (keyEncryptors[0].hashAlgorithm == "SHA256") cryptData.hashAlgorithm = CRYPT_METHOD::SHA256;
else if (keyEncryptors[0].hashAlgorithm == "SHA384") cryptData.hashAlgorithm = CRYPT_METHOD::SHA384;
else if (keyEncryptors[0].hashAlgorithm == "SHA512") cryptData.hashAlgorithm = CRYPT_METHOD::SHA512;
else if (keyEncryptors[0].hashAlgorithm == "MD5") cryptData.hashAlgorithm = CRYPT_METHOD::MD5;
if (keyEncryptors[0].cipherAlgorithm == "AES")
{
cryptData.cipherAlgorithm = CRYPT_METHOD::AES_CBC;
//if (keyEncryptors[0].cipherChaining == "ChainingModeCBC") cryptData.cipherAlgorithm = CRYPT_METHOD::AES_CBC;
if (keyEncryptors[0].cipherChaining == "ChainingModeCFB") cryptData.dataCipherAlgorithm = CRYPT_METHOD::AES_CFB;
}
else if (keyEncryptors[0].cipherAlgorithm == "RC4")
{
cryptData.dataCipherAlgorithm = CRYPT_METHOD::RC4;
}
else if (keyEncryptors[0].cipherAlgorithm == "DES")
{
cryptData.dataCipherAlgorithm = CRYPT_METHOD::DES_CBC;
//if (keyEncryptors[0].cipherChaining == "ChainingModeCBC") cryptData.cipherAlgorithm = CRYPT_METHOD::DES_CBC;
if (keyEncryptors[0].cipherChaining == "ChainingModeECB") cryptData.cipherAlgorithm = CRYPT_METHOD::DES_ECB;
}
//---------------------------------------------------------------------------------------------------------------
cryptData.encryptedHmacKey = DecodeBase64(dataIntegrity.encryptedHmacKey);
cryptData.encryptedHmacValue = DecodeBase64(dataIntegrity.encryptedHmacValue);
//---------------------------------------------------------------------------------------------------------------
cryptData.dataSaltValue = DecodeBase64(keyData.saltValue);
cryptData.dataBlockSize = atoi(keyData.blockSize.c_str());
cryptData.dataHashSize = atoi(keyData.hashSize.c_str());
cryptData.dataSaltSize = atoi(keyData.saltSize.c_str());
cryptData.dataKeySize = atoi(keyData.keyBits.c_str()) / 8;
if (keyData.cipherAlgorithm == "AES")
{
cryptData.cipherAlgorithm = CRYPT_METHOD::AES_CBC;
//if (keyData.cipherChaining == "ChainingModeCBC") cryptData.cipherAlgorithm = CRYPT_METHOD::AES_CBC;
if (keyData.cipherChaining == "ChainingModeCFB") cryptData.dataCipherAlgorithm = CRYPT_METHOD::AES_CFB;
}
else if (keyData.cipherAlgorithm == "RC4")
{
cryptData.dataCipherAlgorithm = CRYPT_METHOD::RC4;
}
else if (keyData.cipherAlgorithm == "DES")
{
cryptData.dataCipherAlgorithm = CRYPT_METHOD::DES_CBC;
//if (keyData.cipherChaining == "ChainingModeCBC") cryptData.cipherAlgorithm = CRYPT_METHOD::DES_CBC;
if (keyData.cipherChaining == "ChainingModeECB") cryptData.cipherAlgorithm = CRYPT_METHOD::DES_ECB;
}
if (keyData.hashAlgorithm == "SHA1") cryptData.dataHashAlgorithm = CRYPT_METHOD::SHA1;
else if (keyData.hashAlgorithm == "SHA224") cryptData.dataHashAlgorithm = CRYPT_METHOD::SHA224;
else if (keyData.hashAlgorithm == "SHA256") cryptData.dataHashAlgorithm = CRYPT_METHOD::SHA256;
else if (keyData.hashAlgorithm == "SHA384") cryptData.dataHashAlgorithm = CRYPT_METHOD::SHA384;
else if (keyData.hashAlgorithm == "SHA512") cryptData.dataHashAlgorithm = CRYPT_METHOD::SHA512;
else if (keyData.hashAlgorithm == "MD5") cryptData.dataHashAlgorithm = CRYPT_METHOD::MD5;
return true;
}
bool WriteXmlEncryptionInfo(const _ecmaCryptData & cryptData, std::string & xml_string)
{
XmlUtils::CXmlWriter xmlWriter;
_dataIntegrity dataIntegrity;
_keyEncryptor keyData;
keyData.spinCount = std::to_string(cryptData.spinCount);
keyData.blockSize = std::to_string(cryptData.blockSize);
keyData.hashSize = std::to_string(cryptData.hashSize);
keyData.saltSize = std::to_string(cryptData.saltSize);
keyData.keyBits = std::to_string(cryptData.keySize * 8);
keyData.saltValue = EncodeBase64(cryptData.dataSaltValue);
switch(cryptData.cipherAlgorithm)
{
case CRYPT_METHOD::RC4:
keyData.cipherAlgorithm = "RC4";
break;
case CRYPT_METHOD::AES_CBC:
keyData.cipherAlgorithm = "AES";
keyData.cipherChaining = "ChainingModeCBC";
break;
case CRYPT_METHOD::AES_ECB:
keyData.cipherAlgorithm = "AES";
keyData.cipherChaining = "ChainingModeECB";
break;
case CRYPT_METHOD::AES_CFB:
keyData.cipherAlgorithm = "AES";
keyData.cipherChaining = "ChainingModeCFB";
break;
case CRYPT_METHOD::DES_CBC:
keyData.cipherAlgorithm = "DES";
keyData.cipherChaining = "ChainingModeCBC";
break;
case CRYPT_METHOD::DES_ECB:
keyData.cipherAlgorithm = "DES";
keyData.cipherChaining = "ChainingModeECB";
break;
break;
}
switch(cryptData.hashAlgorithm)
{
case CRYPT_METHOD::SHA1: keyData.hashAlgorithm = "SHA1"; break;
case CRYPT_METHOD::SHA224: keyData.hashAlgorithm = "SHA224"; break;
case CRYPT_METHOD::SHA256: keyData.hashAlgorithm = "SHA256"; break;
case CRYPT_METHOD::SHA384: keyData.hashAlgorithm = "SHA384"; break;
case CRYPT_METHOD::SHA512: keyData.hashAlgorithm = "SHA512"; break;
case CRYPT_METHOD::MD5: keyData.hashAlgorithm = "MD5"; break;
}
std::vector<_keyEncryptor> keyEncryptors;
keyEncryptors.push_back(keyData);
keyEncryptors[0].saltValue = EncodeBase64(cryptData.saltValue);
keyEncryptors[0].encryptedKeyValue = EncodeBase64(cryptData.encryptedKeyValue);
keyEncryptors[0].encryptedVerifierHashInput = EncodeBase64(cryptData.encryptedVerifierInput);
keyEncryptors[0].encryptedVerifierHashValue = EncodeBase64(cryptData.encryptedVerifierValue);
dataIntegrity.encryptedHmacKey = EncodeBase64(cryptData.encryptedHmacKey);
dataIntegrity.encryptedHmacValue = EncodeBase64(cryptData.encryptedHmacValue);
std::stringstream stream;
CP_XML_WRITER(stream)
{
CP_XML_NODE("encryption")
{
CP_XML_ATTR("xmlns", "http://schemas.microsoft.com/office/2006/encryption");
CP_XML_ATTR("xmlns:p", "http://schemas.microsoft.com/office/2006/keyEncryptor/password");
CP_XML_ATTR("xmlns:c", "http://schemas.microsoft.com/office/2006/keyEncryptor/certificate");
CP_XML_NODE("keyData")
{
CP_XML_ATTR("saltSize", keyData.saltSize);
CP_XML_ATTR("blockSize", keyData.blockSize);
CP_XML_ATTR("keyBits", keyData.keyBits);
CP_XML_ATTR("hashSize", keyData.hashSize);
CP_XML_ATTR("cipherAlgorithm", keyData.cipherAlgorithm);
if (false == keyData.cipherChaining.empty())
{
CP_XML_ATTR("cipherChaining", keyData.cipherChaining);
}
CP_XML_ATTR("hashAlgorithm", keyData.hashAlgorithm);
CP_XML_ATTR("saltValue", keyData.saltValue);
}
CP_XML_NODE("dataIntegrity")
{
CP_XML_ATTR("encryptedHmacKey", dataIntegrity.encryptedHmacKey);
CP_XML_ATTR("encryptedHmacValue", dataIntegrity.encryptedHmacValue);
}
int i = 0;
CP_XML_NODE("keyEncryptors")
{
CP_XML_NODE("keyEncryptor")
{
CP_XML_ATTR("uri", "http://schemas.microsoft.com/office/2006/keyEncryptor/password");
CP_XML_NODE("p:encryptedKey")
{
CP_XML_ATTR("spinCount", keyEncryptors[i].spinCount );
CP_XML_ATTR("saltSize", keyEncryptors[i].saltSize );
CP_XML_ATTR("blockSize", keyEncryptors[i].blockSize );
CP_XML_ATTR("keyBits", keyEncryptors[i].keyBits );
CP_XML_ATTR("hashSize", keyEncryptors[i].hashSize );
CP_XML_ATTR("cipherAlgorithm", keyEncryptors[i].cipherAlgorithm );
CP_XML_ATTR("cipherChaining", keyEncryptors[i].cipherChaining );
CP_XML_ATTR("hashAlgorithm", keyEncryptors[i].hashAlgorithm );
CP_XML_ATTR("saltValue", keyEncryptors[i].saltValue );
CP_XML_ATTR("encryptedVerifierHashInput", keyEncryptors[i].encryptedVerifierHashInput );
CP_XML_ATTR("encryptedVerifierHashValue", keyEncryptors[i].encryptedVerifierHashValue );
CP_XML_ATTR("encryptedKeyValue", keyEncryptors[i].encryptedKeyValue );
}
}
}
}
}
xml_string = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n" + stream.str();
return true;
}
bool WriteStandartEncryptionInfo(unsigned char* data, int &size, _ecmaCryptData & cryptData)
{
if (!data || size < 1) return false;
MemoryStream mem_stream(data, size, false);
_UINT32 SizeHeader = 0, Flags = 0, SizeExtra = 0, AlgID = 0, AlgIDHash = 0, KeySize = 0, ProviderType = 0, Reserved1 = 0, Reserved2 = 0;
bool fCryptoAPI = true, fDocProps = false, fExternal = false, fAES = cryptData.cipherAlgorithm != CRYPT_METHOD::RC4;
SETBIT(Flags, 2, fCryptoAPI);
SETBIT(Flags, 3, fDocProps);
SETBIT(Flags, 4, fExternal);
SETBIT(Flags, 5, fAES);
mem_stream.WriteUInt32(SizeHeader);
KeySize = (cryptData.keySize == 5) ? 0 : cryptData.keySize * 8;
std::string provider;// to utf16
switch(cryptData.cipherAlgorithm)
{
case CRYPT_METHOD::RC4:
{
ProviderType = 0x0001;
AlgID = 0x6801;
}break;
case CRYPT_METHOD::DES_ECB:
case CRYPT_METHOD::DES_CBC:
{
ProviderType = 0;//0x0018;
AlgID = 0x6601;
}break;
case CRYPT_METHOD::AES_ECB:
case CRYPT_METHOD::AES_CBC:
{
ProviderType = 0x0018;
switch(KeySize)
{
case 128: AlgID = 0x660E; break;
case 192: AlgID = 0x660F; break;
case 256: AlgID = 0x6610; break;
}
break;
}break;
}
//ProviderType = 0x0018;
switch(ProviderType)
{
case 0x0001: provider = "Microsoft Strong Cryptographic Provider"; break;
case 0x0018: provider = "Microsoft Enhanced RSA and AES Cryptographic Provider"; break;
}
switch(cryptData.hashAlgorithm)
{
case CRYPT_METHOD::MD5: AlgIDHash = 0x8003; break;
case CRYPT_METHOD::SHA1: AlgIDHash = 0x8004; break;
case CRYPT_METHOD::SHA256: AlgIDHash = 0x8004; break;
case CRYPT_METHOD::SHA384: AlgIDHash = 0x800D; break;
case CRYPT_METHOD::SHA512: AlgIDHash = 0x800E; break;
}
mem_stream.WriteUInt32(Flags);
mem_stream.WriteUInt32(SizeExtra);
mem_stream.WriteUInt32(AlgID);
mem_stream.WriteUInt32(AlgIDHash);
mem_stream.WriteUInt32(KeySize);
mem_stream.WriteUInt32(ProviderType);
mem_stream.WriteUInt32(Reserved1);
mem_stream.WriteUInt32(Reserved2);
for (size_t i = 0; i < provider.length(); ++i)
{
mem_stream.WriteByte((unsigned char)provider[i]);
mem_stream.WriteByte((unsigned char)0);
}
mem_stream.WriteByte((unsigned char)0); //null terminate
mem_stream.WriteByte((unsigned char)0);
SizeHeader = mem_stream.GetPosition() - 4;
//EncryptionVerifier
mem_stream.WriteUInt32((_UINT32)cryptData.saltSize);
mem_stream.WriteBytes((unsigned char*)cryptData.saltValue.c_str(), cryptData.saltSize);
mem_stream.WriteBytes((unsigned char*)cryptData.encryptedVerifierInput.c_str(), 0x10);
mem_stream.WriteUInt32((_UINT32)cryptData.hashSize);
//int szEncryptedVerifierHash = (ProviderType == 0x0001) ? 0x14 : 0x20; //RC4 | AES(DES) .. md5?
mem_stream.WriteBytes((unsigned char*)cryptData.encryptedVerifierValue.c_str(), (int)cryptData.encryptedVerifierValue.length()/*szEncryptedVerifierHash*/);
size = mem_stream.GetPosition();
mem_stream.Seek(0);
mem_stream.WriteUInt32(SizeHeader);
return true;
}
bool ReadStandartEncryptionInfo(unsigned char* data, int size, _ecmaCryptData & cryptData)
{
if (!data || size < 36) return false;
MemoryStream mem_stream(data, size, false);
//EncryptionHeader
int HeaderSize = mem_stream.ReadUInt32();
int Flags = mem_stream.ReadUInt32();
int SizeExtra = mem_stream.ReadUInt32();
int AlgID = mem_stream.ReadUInt32();
int AlgIDHash = mem_stream.ReadUInt32();
int KeySize = mem_stream.ReadUInt32();
int ProviderType= mem_stream.ReadUInt32();
int Reserved1 = mem_stream.ReadUInt32();
int Reserved2 = mem_stream.ReadUInt32();
int pos = mem_stream.GetPosition();
while(pos < size - 1)
{
if (data[pos] == 0 && data[pos + 1] == 0)
{
break;
}
pos+=2;//unicode null-terminate string
}
int szCSPName = pos - mem_stream.GetPosition() + 2;
unsigned char* strData = mem_stream.ReadBytes(szCSPName, true);
if (strData)
{
delete []strData;
}
//EncryptionVerifier
cryptData.saltSize = mem_stream.ReadUInt32();
cryptData.saltValue = std::string((char*)data + mem_stream.GetPosition(), cryptData.saltSize);
mem_stream.ReadBytes(cryptData.saltSize, false);
cryptData.encryptedVerifierInput = std::string((char*)data + mem_stream.GetPosition(), 0x10);
mem_stream.ReadBytes(0x10, false);
cryptData.hashSize = mem_stream.ReadUInt32();
unsigned long szEncryptedVerifierHash = (ProviderType == 0x0001) ? 0x14 : 0x20; // RC4 | AES(DES)
unsigned long szEncryptedVerifierHashMax = mem_stream.GetSize() - mem_stream.GetPosition();
cryptData.encryptedVerifierValue = std::string((char*)data + mem_stream.GetPosition(), (std::max)(szEncryptedVerifierHash, szEncryptedVerifierHashMax));
mem_stream.ReadBytes(szEncryptedVerifierHash, false);
pos = mem_stream.GetPosition();
//------------------------------------------------------------------------------------------
switch(AlgIDHash)
{
case 0x8003:
cryptData.hashAlgorithm = CRYPT_METHOD::MD5; break;
case 0x0000:
case 0x8004:
cryptData.hashAlgorithm = CRYPT_METHOD::SHA1; break;
case 0x800C:
cryptData.hashAlgorithm = CRYPT_METHOD::SHA256; break;
case 0x800D:
cryptData.hashAlgorithm = CRYPT_METHOD::SHA384; break;
case 0x800E:
cryptData.hashAlgorithm = CRYPT_METHOD::SHA512; break;
}
cryptData.spinCount = 50000;
switch(AlgID)
{
case 0x6801:
cryptData.cipherAlgorithm = CRYPT_METHOD::RC4;
if (KeySize == 0) cryptData.keySize = 5; //40 bit
else cryptData.keySize = KeySize / 8;
break;
case 0x6601:
cryptData.cipherAlgorithm = CRYPT_METHOD::DES_ECB;
cryptData.keySize = 8;
break;
case 0x660E:
cryptData.cipherAlgorithm = CRYPT_METHOD::AES_ECB;
cryptData.keySize = 128 /8;
break;
case 0x660F:
cryptData.cipherAlgorithm = CRYPT_METHOD::AES_ECB;
cryptData.keySize = 192 /8;
break;
case 0x6610:
cryptData.cipherAlgorithm = CRYPT_METHOD::AES_ECB;
cryptData.keySize = 256 /8;
break;
}
cryptData.dataHashAlgorithm = cryptData.hashAlgorithm;
cryptData.dataBlockSize = cryptData.blockSize;
cryptData.dataCipherAlgorithm = cryptData.cipherAlgorithm;
cryptData.dataHashSize = cryptData.hashSize;
cryptData.dataKeySize = cryptData.keySize;
cryptData.dataSaltSize = cryptData.saltSize;
return true;
}
bool ReadExtensibleEncryptionInfo(unsigned char* data, int size, _ecmaCryptData & cryptData)
{
return false;
}
//--------------------------------------------------------------
bool ECMACryptFile::EncryptOfficeFile(const std::wstring &file_name_inp, const std::wstring &file_name_out, const std::wstring &password, const std::wstring &documentID)
{
_ecmaCryptData cryptData;
std::wstring sApplication = NSSystemUtils::GetEnvVariable(NSSystemUtils::gc_EnvMethodEncrypt);
//if (sApplication == L"Weak")
//{
// cryptData.bAgile = false;
// cryptData.cipherAlgorithm = CRYPT_METHOD::DES_ECB;
// cryptData.hashAlgorithm = CRYPT_METHOD::SHA1;
// cryptData.keySize = 0x08;
// cryptData.hashSize = 0x14;
// cryptData.blockSize = 0x10;
// cryptData.saltSize = 0x10;
// cryptData.spinCount = 50000;
//}
//else
{
cryptData.bAgile = true;
cryptData.spinCount = 100000;
cryptData.cipherAlgorithm = cryptData.dataCipherAlgorithm = CRYPT_METHOD::AES_CBC;
cryptData.hashAlgorithm = cryptData.dataHashAlgorithm = CRYPT_METHOD::SHA512;
cryptData.keySize = cryptData.dataKeySize = 0x20;
cryptData.hashSize = cryptData.dataHashSize = 0x40;
cryptData.blockSize = cryptData.dataBlockSize = 0x10;
cryptData.saltSize = cryptData.dataSaltSize = 0x10;
}
//cryptData.bAgile = true;
//cryptData.cipherAlgorithm = CRYPT_METHOD::DES_CBC;
////cryptData.hashAlgorithm = CRYPT_METHOD::SHA512;
////cryptData.keySize = 0x08;
////cryptData.hashSize = 0x40;
////cryptData.blockSize = 0x10;
////cryptData.saltSize = 0x10;
//cryptData.hashAlgorithm = CRYPT_METHOD::SHA1;
//cryptData.keySize = 0x08;
//cryptData.hashSize = 0x14;
//cryptData.blockSize = 0x10;
//cryptData.saltSize = 0x10;
//cryptData.bAgile = false;
//cryptData.cipherAlgorithm = CRYPT_METHOD::AES_ECB;
//cryptData.hashAlgorithm = CRYPT_METHOD::SHA1;
//cryptData.keySize = 0x10;
//cryptData.hashSize = 0x14;
//cryptData.blockSize = 0x10;
//cryptData.saltSize = 0x10;
//cryptData.spinCount = 50000;
//cryptData.bAgile = false;
//cryptData.cipherAlgorithm = CRYPT_METHOD::RC4;
//cryptData.hashAlgorithm = CRYPT_METHOD::SHA1;
//cryptData.keySize = 7;
//cryptData.hashSize = 0x14;
//cryptData.blockSize = 0x10;
//cryptData.saltSize = 0x10;
//cryptData.spinCount = 50000;
//cryptData.bAgile = false;
//cryptData.cipherAlgorithm = CRYPT_METHOD::DES_ECB;
//cryptData.hashAlgorithm = CRYPT_METHOD::SHA1;
//cryptData.keySize = 0x08;
//cryptData.hashSize = 0x14;
//cryptData.blockSize = 0x10;
//cryptData.saltSize = 0x10;
//cryptData.spinCount = 50000;
ECMAEncryptor cryptor;
//cryptor.SetCryptData(cryptDataGlobal); //for test !!!
cryptor.SetCryptData(cryptData); //basic settings
cryptor.SetPassword(password);
NSFile::CFileBinary file;
if (!file.OpenFile(file_name_inp)) return false;
_UINT64 lengthFileSize = file.GetFileSize();
DWORD lengthData = lengthFileSize, lengthDataRead = 0 ;
unsigned char* data = new unsigned char[lengthData];
unsigned char* data_out = NULL;
file.ReadFile(data, lengthData, lengthDataRead);
file.CloseFile();
lengthData = cryptor.Encrypt(data, lengthData, data_out);
delete[]data; data = NULL;
if (NULL == data_out)
{
return false;
}
cryptor.UpdateDataIntegrity(data_out, lengthData);
bool bLargeFile = (lengthData > 3 * 1024 * 1024);
//-------------------------------------------------------------------
CFCPP::CompoundFile *pStorageNew = new CFCPP::CompoundFile(CFCPP::Ver_3, CFCPP::Default);
//-------------------------------------------------------------------
std::shared_ptr<CFCPP::CFStream> oPackage = pStorageNew->RootStorage()->AddStream(L"EncryptedPackage");
oPackage->Write((char*)data_out, 0, lengthData);
if (data_out)
{
delete []data_out;
data_out = NULL;
}
cryptor.GetCryptData(cryptData);
std::shared_ptr<CFCPP::CFStream> oInfo = pStorageNew->RootStorage()->AddStream(L"EncryptionInfo");
if (cryptData.bAgile)
{
_UINT16 VersionInfoMajor = 0x0004, VersionInfoMinor = 0x0004; //agile
std::streamsize position = 0;
oInfo->Write((char*)&VersionInfoMajor, position, 2); position += 2;
oInfo->Write((char*)&VersionInfoMinor, position, 2); position += 2;
_UINT32 nEncryptionInfoFlags = 64;
oInfo->Write((char*)&nEncryptionInfoFlags, position, 4); position += 4;
std::string strXml;
WriteXmlEncryptionInfo(cryptData, strXml);
oInfo->Write(strXml.c_str(), position, strXml.length()); position += strXml.length();
}
else
{
_UINT16 VersionInfoMajor = 0x0004, VersionInfoMinor = 0x0002; // standart
std::streamsize position = 0;
oInfo->Write((char*)&VersionInfoMajor, position, 2); position += 2;
oInfo->Write((char*)&VersionInfoMinor, position, 2); position += 2;
_UINT32 nEncryptionInfoFlags = 0;
bool fCryptoAPI = true, fDocProps = false, fExternal = false, fAES = cryptData.cipherAlgorithm != CRYPT_METHOD::RC4;
SETBIT(nEncryptionInfoFlags, 2, fCryptoAPI);
SETBIT(nEncryptionInfoFlags, 3, fDocProps);
SETBIT(nEncryptionInfoFlags, 4, fExternal);
SETBIT(nEncryptionInfoFlags, 5, fAES);
oInfo->Write((char*)&nEncryptionInfoFlags, position, 4); position += 4;
int nEncryptionInfoSize = 4096;
unsigned char* byteEncryptionInfo = new unsigned char[nEncryptionInfoSize];
WriteStandartEncryptionInfo(byteEncryptionInfo, nEncryptionInfoSize, cryptData);
oInfo->Write((char*)byteEncryptionInfo, position, 4); position += nEncryptionInfoSize;
delete[]byteEncryptionInfo;
}
//-------------------------------------------------------------------
if (false == documentID.empty())
{
std::string utfDocumentID = NSFile::CUtf8Converter::GetUtf8StringFromUnicode(documentID);
std::shared_ptr<CFCPP::CFStream> oDocumentID = pStorageNew->RootStorage()->AddStream(L"DocumentID");
oDocumentID->Write(utfDocumentID.c_str(), 0, utfDocumentID.length());
}
//-------------------------------------------------------------------
bool result = pStorageNew->Save(file_name_out);
pStorageNew->Close();
delete pStorageNew;
//
////test back---------------------------------------------------------------------------------test back
// ECMADecryptor decryptor;
//
// decryptor.SetCryptData(cryptData);
//
// if (decryptor.SetPassword(password))
// {
// unsigned char* data_out2 = NULL;
// decryptor.Decrypt(data_out, lengthData, data_out2, 0);
//
// bool bDataIntegrity = decryptor.CheckDataIntegrity(data_out, lengthData);
//
// NSFile::CFileBinary test;
//
// test.CreateFileW(file_name_out + L"-back.oox");
// test.WriteFile(data_out2, lengthFileSize);
// test.CloseFile();
// }
////test back---------------------------------------------------------------------------------test back
return result;
}
bool ECMACryptFile::DecryptOfficeFile(const std::wstring &file_name_inp, const std::wstring &file_name_out, const std::wstring &password, bool & bDataIntegrity)
{
bDataIntegrity = false;
POLE::Storage *pStorage = new POLE::Storage(file_name_inp.c_str());
if (!pStorage)return false;
if (!pStorage->open())
{
delete pStorage;
return false;
}
//-------------------------------------------------------------------------------------------
_ecmaCryptData cryptData;
bool result = false;
POLE::Stream *pStream = new POLE::Stream(pStorage, L"EncryptionInfo");
if (pStream)
{
if (pStream->fail() || pStream->size() < 8)
{
delete pStream;
delete pStorage;
return false;
}
_UINT16 VersionInfoMajor = 0, VersionInfoMinor = 0;
pStream->read((unsigned char*)&VersionInfoMajor, 2);
pStream->read((unsigned char*)&VersionInfoMinor, 2);
_UINT32 nEncryptionInfoFlags = 0;
pStream->read((unsigned char*)&nEncryptionInfoFlags, 4);
int nEncryptionInfoSize = pStream->size() - 8;
unsigned char* byteEncryptionInfo = new unsigned char[nEncryptionInfoSize];
if (!byteEncryptionInfo)
{
delete pStream;
delete pStorage;
return false;
}
nEncryptionInfoSize = pStream->read(byteEncryptionInfo, nEncryptionInfoSize);
delete pStream;
if (VersionInfoMajor == 0x0004 && VersionInfoMinor == 0x0004)
{//agile info
std::string xml_string((char*) byteEncryptionInfo, nEncryptionInfoSize);
delete []byteEncryptionInfo;
cryptData.bAgile = true;
result = ReadXmlEncryptionInfo(xml_string, cryptData);
}
else
{
cryptData.bAgile = false;
bool fCryptoAPI = GETBIT(nEncryptionInfoFlags, 2);
bool fDocProps = GETBIT(nEncryptionInfoFlags, 3);
bool fExternal = GETBIT(nEncryptionInfoFlags, 4);
bool fAES = GETBIT(nEncryptionInfoFlags, 5);
if ((VersionInfoMajor == 0x0003 || VersionInfoMajor == 0x0004) && VersionInfoMinor == 0x0003) //extensible info
{
result = ReadExtensibleEncryptionInfo(byteEncryptionInfo, nEncryptionInfoSize, cryptData);
}
else if ((VersionInfoMajor == 0x0003 || VersionInfoMajor == 0x0004) && VersionInfoMinor == 0x0002) //standart info
{
result = ReadStandartEncryptionInfo(byteEncryptionInfo, nEncryptionInfoSize, cryptData);
}
else
{
// look in DocFormat
}
delete []byteEncryptionInfo;
}
}
if (!result)
{
delete pStorage;
return false;
}
//------------------------------------------------------------------------------------------------------------
ECMADecryptor decryptor;
decryptor.SetCryptData(cryptData);
if (!decryptor.SetPassword(password))
{
if (password.empty())
{
if (!decryptor.SetPassword(L"VelvetSweatshop"))
return false;
}
else
return false;
}
//------------------------------------------------------------------------------------------------------------
pStream = new POLE::Stream(pStorage, L"EncryptedPackage");
if ((pStream) && (pStream->size() > 0))
{
_UINT64 lengthData, lengthRead = pStream->size();
unsigned char* data = new unsigned char[lengthRead];
unsigned char* data_out = NULL;
_UINT64 readTrue = pStream->read(data, lengthRead);
_UINT64 readData = readTrue - 8;
lengthData = (std::min)(*((_UINT64*)data), readData);
decryptor.Decrypt(data + 8, (int)readData, data_out, 0);
if (data_out)
{
NSFile::CFileBinary f;
f.CreateFileW(file_name_out);
f.WriteFile(data_out, lengthData);
f.CloseFile();
delete []data_out;
result = true;
}
bDataIntegrity = decryptor.CheckDataIntegrity(data, readTrue);
delete pStream;
delete []data;
}
//-------------------------------------------------------------------
delete pStorage;
//cryptDataGlobal = cryptData; // for encrypt like sample & test
return result;
}
std::string ECMACryptFile::ReadAdditional(const std::wstring &file_name, const std::wstring &addit_name)
{
POLE::Storage *pStorage = new POLE::Storage(file_name.c_str());
if (!pStorage->open(false, false))
{
delete pStorage;
return "";
}
std::string result;
POLE::Stream *pStream = new POLE::Stream(pStorage, addit_name);
if ((pStream) && (pStream->size() > 0))
{
_UINT64 lengthData, size = pStream->size();
char* data = new char[size];
lengthData = pStream->read((unsigned char*)data, size);
result = std::string(data, lengthData);
delete []data;
delete pStream;
}
delete pStorage;
return result;
}
bool ECMACryptFile::WriteAdditional(const std::wstring &file_name, const std::wstring &addit_name, const std::string &addit_info)
{
try
{
CFCPP::CompoundFile *pStorage = new CFCPP::CompoundFile(file_name, CFCPP::Update, (CFCPP::SectorRecycle | CFCPP::NoValidationException | CFCPP::EraseFreeSectors));
if (!pStorage)return false;
std::shared_ptr<CFCPP::CFStream> pAddit = pStorage->RootStorage()->GetStream(addit_name);
if (pAddit)
{
pStorage->RootStorage()->Delete(addit_name);
}
pAddit = pStorage->RootStorage()->AddStream(addit_name);
pAddit->Write(addit_info.c_str(), 0, addit_info.size());
pStorage->Commit();
//todooo_2 flush
pStorage->Save(file_name + L"~");
pStorage->Close();
delete pStorage;
//todooo_1 rename
//NSFile::CFileBinary::Rename(file_name + L"~", file_name);
NSFile::CFileBinary::Copy(file_name + L"~", file_name);
NSFile::CFileBinary::Remove(file_name + L"~");
}
catch (...)
{
return false;
}
//POLE::Storage *pStorage = new POLE::Storage(file_name.c_str());
//
//if (!pStorage)return false;
//if (!pStorage->open(true, false))
//{
// delete pStorage;
// return false;
//}
//POLE::Stream *pStream = new POLE::Stream(pStorage, addit_name, true, addit_info.size());
//
//pStream->write((unsigned char*)addit_info.c_str(), addit_info.size());
//pStream->setSize(addit_info.size());
//pStream->flush();
//delete pStream;
//pStorage->close();
//delete pStorage;
return true;
}
bool TestOdfProtect(const std::wstring &passward, const std::string &salt, const std::string &hash, int count)
{
CRYPT::ODFWriteProtect test;
CRYPT::_odfWriteProtectData ver1;
ver1.hashAlgorithm = CRYPT_METHOD::PBKDF2;
ver1.hashValue = DecodeBase64(hash);
ver1.saltValue = DecodeBase64(salt);
ver1.spinCount = count;
test.SetCryptData(ver1);
test.SetPassword(passward);
bool result_ver1 = test.Verify();
return result_ver1;
}
Reference in New Issue View Git Blame Copy Permalink