/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define VBA_EXPORT_DEBUG 0 #define VBA_USE_ORIGINAL_WM_STREAM 0 #define VBA_USE_ORIGINAL_DIR_STREAM 0 #define VBA_USE_ORIGINAL_PROJECT_STREAM 0 #define VBA_USE_ORIGINAL_VBA_PROJECT 0 /* Enable to see VBA Encryption work. For now the input data and length values * for encryption correspond to the case when the VBA macro is not protected. */ #define VBA_ENCRYPTION 1 namespace { void exportString(SvStream& rStrm, std::u16string_view rString, const rtl_TextEncoding eTextEncoding) { OString aStringCorrectCodepage = OUStringToOString(rString, eTextEncoding); rStrm.WriteOString(aStringCorrectCodepage); } void exportUTF16String(SvStream& rStrm, const OUString& rString) { sal_Int32 n = rString.getLength(); const sal_Unicode* pString = rString.getStr(); for (sal_Int32 i = 0; i < n; ++i) { sal_Unicode character = pString[i]; rStrm.WriteUnicode(character); } } bool isWorkbook(const css::uno::Reference& xInterface) { css::uno::Reference xWorkbook(xInterface, css::uno::UNO_QUERY); return xWorkbook.is(); } OUString createHexStringFromDigit(sal_uInt8 nDigit) { OUString aString = OUString::number( nDigit, 16 ); if(aString.getLength() == 1) aString = OUString::number(0) + aString; return aString.toAsciiUpperCase(); } } VBACompressionChunk::VBACompressionChunk(SvStream& rCompressedStream, const sal_uInt8* pData, std::size_t nChunkSize) : mrCompressedStream(rCompressedStream) , mpUncompressedData(pData) , mpCompressedChunkStream(nullptr) , mnChunkSize(nChunkSize) , mnCompressedCurrent(0) , mnCompressedEnd(0) , mnDecompressedCurrent(0) , mnDecompressedEnd(0) { } static void setUInt16(sal_uInt8* pBuffer, size_t nPos, sal_uInt16 nVal) { pBuffer[nPos] = nVal & 0xFF; pBuffer[nPos+1] = (nVal & 0xFF00) >> 8; } sal_uInt16 VBACompressionChunk::handleHeader(bool bCompressed) { // handle header bytes size_t nSize = mnCompressedCurrent; sal_uInt16 nHeader = 0; PackCompressedChunkSize(nSize, nHeader); PackCompressedChunkFlag(bCompressed, nHeader); PackCompressedChunkSignature(nHeader); return nHeader; } // section 2.4.1.3.7 void VBACompressionChunk::write() { mnDecompressedCurrent = 0; mnCompressedCurrent = 2; mnCompressedEnd = 4098; mnDecompressedEnd = std::min(4096, mnChunkSize); // if that stream becomes larger than 4096 bytes then // we use the uncompressed stream sal_uInt8 pCompressedChunkStream[4098]; mpCompressedChunkStream = pCompressedChunkStream; while (mnDecompressedCurrent < mnDecompressedEnd && mnCompressedCurrent < mnCompressedEnd) { // compress token sequence compressTokenSequence(); } if (mnDecompressedCurrent < mnDecompressedEnd) { sal_uInt64 nChunkStart = mrCompressedStream.Tell(); mrCompressedStream.WriteUInt16(0); writeRawChunk(); mrCompressedStream.Seek(nChunkStart); sal_uInt16 nHeader = handleHeader(false); mrCompressedStream.WriteUInt16(nHeader); } else { sal_uInt16 nHeader = handleHeader(true); setUInt16(pCompressedChunkStream, 0, nHeader); // copy the compressed stream to our output stream mrCompressedStream.WriteBytes(pCompressedChunkStream, mnCompressedCurrent); } } // section 2.4.1.3.13 void VBACompressionChunk::PackCompressedChunkSize(size_t nSize, sal_uInt16& rHeader) { sal_uInt16 nTemp1 = rHeader & 0xF000; sal_uInt16 nTemp2 = nSize - 3; rHeader = nTemp1 | nTemp2; } // section 2.4.1.3.16 void VBACompressionChunk::PackCompressedChunkFlag(bool bCompressed, sal_uInt16& rHeader) { sal_uInt16 nTemp1 = rHeader & 0x7FFF; sal_uInt16 nTemp2 = static_cast(bCompressed) << 15; rHeader = nTemp1 | nTemp2; } // section 2.4.1.3.14 void VBACompressionChunk::PackCompressedChunkSignature(sal_uInt16& rHeader) { sal_Int32 nTemp = rHeader & 0x8FFFF; rHeader = nTemp | 0x3000; } // section 2.4.1.3.8 void VBACompressionChunk::compressTokenSequence() { sal_uInt64 nFlagByteIndex = mnCompressedCurrent; sal_uInt8 nFlagByte = 0; ++mnCompressedCurrent; for (size_t index = 0; index <= 7; ++index) { if (mnDecompressedCurrent < mnDecompressedEnd && mnCompressedCurrent < mnCompressedEnd) { compressToken(index, nFlagByte); } } mpCompressedChunkStream[nFlagByteIndex] = nFlagByte; } // section 2.4.1.3.9 void VBACompressionChunk::compressToken(size_t index, sal_uInt8& nFlagByte) { size_t nLength = 0; size_t nOffset = 0; match(nLength, nOffset); if (nOffset != 0) { if (mnCompressedCurrent + 1 < mnCompressedEnd) { sal_uInt16 nToken = CopyToken(nLength, nOffset); setUInt16(mpCompressedChunkStream, mnCompressedCurrent, nToken); SetFlagBit(index, true, nFlagByte); mnCompressedCurrent += 2; mnDecompressedCurrent += nLength; } else { mnCompressedCurrent = mnCompressedEnd; } } else { if (mnCompressedCurrent + 1 < mnCompressedEnd) { mpCompressedChunkStream[mnCompressedCurrent] = mpUncompressedData[mnDecompressedCurrent]; ++mnCompressedCurrent; ++mnDecompressedCurrent; } else { mnCompressedCurrent = mnCompressedEnd; } } } // section 2.4.1.3.18 void VBACompressionChunk::SetFlagBit(size_t index, bool bVal, sal_uInt8& rFlag) { size_t nTemp1 = static_cast(bVal) << index; sal_uInt8 nTemp2 = rFlag & (~nTemp1); rFlag = nTemp2 | nTemp1; } // section 2.4.1.3.19.3 sal_uInt16 VBACompressionChunk::CopyToken(size_t nLength, size_t nOffset) { sal_uInt16 nLengthMask = 0; sal_uInt16 nOffsetMask = 0; sal_uInt16 nBitCount = 0; sal_uInt16 nMaxLength; CopyTokenHelp(nLengthMask, nOffsetMask, nBitCount, nMaxLength); sal_uInt16 nTemp1 = nOffset -1; sal_uInt16 nTemp2 = 16 - nBitCount; sal_uInt16 nTemp3 = nLength - 3; sal_uInt16 nToken = (nTemp1 << nTemp2) | nTemp3; return nToken; } // section 2.4.1.3.19.4 void VBACompressionChunk::match(size_t& rLength, size_t& rOffset) { size_t nBestLen = 0; sal_Int32 nCandidate = mnDecompressedCurrent - 1; sal_Int32 nBestCandidate = nCandidate; while (nCandidate >= 0) { sal_Int32 nC = nCandidate; sal_Int32 nD = mnDecompressedCurrent; size_t nLen = 0; while (nD < static_cast(mnChunkSize) // TODO: check if this needs to be including a minus -1 && mpUncompressedData[nC] == mpUncompressedData[nD]) { ++nLen; ++nC; ++nD; } if (nLen > nBestLen) { nBestLen = nLen; nBestCandidate = nCandidate; } --nCandidate; } if (nBestLen >= 3) { sal_uInt16 nMaximumLength = 0; sal_uInt16 nLengthMask, nOffsetMask, nBitCount; CopyTokenHelp(nLengthMask, nOffsetMask, nBitCount, nMaximumLength); rLength = std::min(nMaximumLength, nBestLen); rOffset = mnDecompressedCurrent - nBestCandidate; } else { rLength = 0; rOffset = 0; } } // section 2.4.1.3.19.1 void VBACompressionChunk::CopyTokenHelp(sal_uInt16& rLengthMask, sal_uInt16& rOffsetMask, sal_uInt16& rBitCount, sal_uInt16& rMaximumLength) { sal_uInt16 nDifference = mnDecompressedCurrent; assert(nDifference <= 4096); assert(nDifference >= 1); if (nDifference >= 2049) rBitCount = 12; else if (nDifference >= 1025) rBitCount = 11; else if (nDifference >= 513) rBitCount = 10; else if (nDifference >= 257) rBitCount = 9; else if (nDifference >= 129) rBitCount = 8; else if (nDifference >= 65) rBitCount = 7; else if (nDifference >= 33) rBitCount = 6; else if (nDifference >= 17) rBitCount = 5; else rBitCount = 4; rLengthMask = 0xffff >> rBitCount; rOffsetMask = ~rLengthMask; rMaximumLength = rLengthMask + 3; } // section 2.4.1.3.10 void VBACompressionChunk::writeRawChunk() { // we need to use up to 4096 bytes of the original stream // and fill the rest with padding mrCompressedStream.WriteBytes(mpUncompressedData, mnChunkSize); std::size_t nPadding = 4096 - mnChunkSize; for (size_t i = 0; i < nPadding; ++i) { mrCompressedStream.WriteUInt8(0); } } VBACompression::VBACompression(SvStream& rCompressedStream, SvMemoryStream& rUncompressedStream): mrCompressedStream(rCompressedStream), mrUncompressedStream(rUncompressedStream) { } // section 2.4.1.3.6 void VBACompression::write() { // section 2.4.1.1.1 mrCompressedStream.WriteUInt8(0x01); // signature byte of a compressed container bool bStreamNotEnded = true; const sal_uInt8* pData = static_cast(mrUncompressedStream.GetData()); std::size_t nSize = mrUncompressedStream.GetEndOfData(); std::size_t nRemainingSize = nSize; while(bStreamNotEnded) { std::size_t nChunkSize = std::min(nRemainingSize, 4096); VBACompressionChunk aChunk(mrCompressedStream, &pData[nSize - nRemainingSize], nChunkSize); aChunk.write(); // update the uncompressed chunk start marker nRemainingSize -= nChunkSize; bStreamNotEnded = nRemainingSize != 0; } } // section 2.4.3 #if VBA_ENCRYPTION VBAEncryption::VBAEncryption(const sal_uInt8* pData, const sal_uInt16 length, SvStream& rEncryptedData, sal_uInt8 nProjKey, const rtl_TextEncoding eTextEncoding) :mpData(pData) ,mnLength(length) ,mrEncryptedData(rEncryptedData) ,mnUnencryptedByte1(0) ,mnEncryptedByte1(0) ,mnEncryptedByte2(0) ,mnProjKey(nProjKey) ,mnIgnoredLength(0) ,mnSeed(0x00) ,mnVersionEnc(0) ,meTextEncoding(eTextEncoding) { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(0, 255); mnSeed = dis(gen); } void VBAEncryption::writeSeed() { exportString(mrEncryptedData, createHexStringFromDigit(mnSeed), meTextEncoding); } void VBAEncryption::writeVersionEnc() { static const sal_uInt8 mnVersion = 2; // the encrypted version mnVersionEnc = mnSeed ^ mnVersion; exportString(mrEncryptedData, createHexStringFromDigit(mnVersionEnc), meTextEncoding); } sal_uInt8 VBAEncryption::calculateProjKey(const OUString& rProjectKey) { sal_uInt8 nProjKey = 0; sal_Int32 n = rProjectKey.getLength(); const sal_Unicode* pString = rProjectKey.getStr(); for (sal_Int32 i = 0; i < n; ++i) { sal_Unicode character = pString[i]; nProjKey += character; } return nProjKey; } void VBAEncryption::writeProjKeyEnc() { sal_uInt8 nProjKeyEnc = mnSeed ^ mnProjKey; exportString(mrEncryptedData, createHexStringFromDigit(nProjKeyEnc), meTextEncoding); mnUnencryptedByte1 = mnProjKey; mnEncryptedByte1 = nProjKeyEnc; // ProjKeyEnc mnEncryptedByte2 = mnVersionEnc; // VersionEnc } void VBAEncryption::writeIgnoredEnc() { mnIgnoredLength = (mnSeed & 6) / 2; for(sal_Int32 i = 1; i <= mnIgnoredLength; ++i) { sal_uInt8 nTempValue = 0xBE; // Any value can be assigned here sal_uInt8 nByteEnc = nTempValue ^ (mnEncryptedByte2 + mnUnencryptedByte1); exportString(mrEncryptedData, createHexStringFromDigit(nByteEnc), meTextEncoding); mnEncryptedByte2 = mnEncryptedByte1; mnEncryptedByte1 = nByteEnc; mnUnencryptedByte1 = nTempValue; } } void VBAEncryption::writeDataLengthEnc() { sal_uInt16 temp = mnLength; for(sal_Int8 i = 0; i < 4; ++i) { sal_uInt8 nByte = temp & 0xFF; sal_uInt8 nByteEnc = nByte ^ (mnEncryptedByte2 + mnUnencryptedByte1); exportString(mrEncryptedData, createHexStringFromDigit(nByteEnc), meTextEncoding); mnEncryptedByte2 = mnEncryptedByte1; mnEncryptedByte1 = nByteEnc; mnUnencryptedByte1 = nByte; temp >>= 8; } } void VBAEncryption::writeDataEnc() { for(sal_Int16 i = 0; i < mnLength; i++) { sal_uInt8 nByteEnc = mpData[i] ^ (mnEncryptedByte2 + mnUnencryptedByte1); exportString(mrEncryptedData, createHexStringFromDigit(nByteEnc), meTextEncoding); mnEncryptedByte2 = mnEncryptedByte1; mnEncryptedByte1 = nByteEnc; mnUnencryptedByte1 = mpData[i]; } } void VBAEncryption::write() { writeSeed(); writeVersionEnc(); writeProjKeyEnc(); writeIgnoredEnc(); writeDataLengthEnc(); writeDataEnc(); } #endif VbaExport::VbaExport(css::uno::Reference const & xModel): mxModel(xModel) { } namespace { // section 2.3.4.2.1.1 void writePROJECTSYSKIND(SvStream& rStrm) { rStrm.WriteUInt16(0x0001); // id rStrm.WriteUInt32(0x00000004); // size rStrm.WriteUInt32(0x00000001); // SysKind, hard coded to 32-bin windows for now } // section 2.3.4.2.1.2 void writePROJECTLCID(SvStream& rStrm) { rStrm.WriteUInt16(0x0002); // id rStrm.WriteUInt32(0x00000004); // size rStrm.WriteUInt32(0x00000409); // Lcid } // section 2.3.4.2.1.3 void writePROJECTLCIDINVOKE(SvStream& rStrm) { rStrm.WriteUInt16(0x0014); // id rStrm.WriteUInt32(0x00000004); // size rStrm.WriteUInt32(0x00000409); // LcidInvoke } // section 2.3.4.2.1.4 void writePROJECTCODEPAGE(SvStream& rStrm, const rtl_TextEncoding eTextEncoding) { rStrm.WriteUInt16(0x0003); // id rStrm.WriteUInt32(0x00000002); // size rStrm.WriteUInt16(rtl_getWindowsCodePageFromTextEncoding(eTextEncoding)); // CodePage } //section 2.3.4.2.1.5 void writePROJECTNAME(SvStream& rStrm, const OUString& name, const rtl_TextEncoding eTextEncoding) { rStrm.WriteUInt16(0x0004); // id sal_uInt32 sizeOfProjectName = name.getLength(); rStrm.WriteUInt32(sizeOfProjectName); // sizeOfProjectName exportString(rStrm, name, eTextEncoding); // ProjectName } //section 2.3.4.2.1.6 void writePROJECTDOCSTRING(SvStream& rStrm) { rStrm.WriteUInt16(0x0005); // id rStrm.WriteUInt32(0x00000000); // sizeOfDocString rStrm.WriteUInt16(0x0040); // Reserved rStrm.WriteUInt32(0x00000000); // sizeOfDocStringUnicode, MUST be even } //section 2.3.4.2.1.7 void writePROJECTHELPFILEPATH(SvStream& rStrm) { rStrm.WriteUInt16(0x0006); // id rStrm.WriteUInt32(0x00000000); // sizeOfHelpFile1 rStrm.WriteUInt16(0x003D); // Reserved rStrm.WriteUInt32(0x00000000); // sizeOfHelpFile2 } //section 2.3.4.2.1.8 void writePROJECTHELPCONTEXT(SvStream& rStrm) { rStrm.WriteUInt16(0x0007); // id rStrm.WriteUInt32(0x00000004); // size rStrm.WriteUInt32(0x00000000); // HelpContext } //section 2.3.4.2.1.9 void writePROJECTLIBFLAGS(SvStream& rStrm) { rStrm.WriteUInt16(0x0008); // id rStrm.WriteUInt32(0x00000004); // size rStrm.WriteUInt32(0x00000000); // ProjectLibFlags } //section 2.3.4.2.1.10 void writePROJECTVERSION(SvStream& rStrm) { rStrm.WriteUInt16(0x0009); // id rStrm.WriteUInt32(0x00000004); // Reserved rStrm.WriteUInt32(1467127224); // VersionMajor // TODO: where is this magic number coming from rStrm.WriteUInt16(5); // VersionMinor // TODO: where is this magic number coming from } //section 2.3.4.2.1.11 void writePROJECTCONSTANTS(SvStream& rStrm) { rStrm.WriteUInt16(0x000C); // id rStrm.WriteUInt32(0x00000000); // sizeOfConstants rStrm.WriteUInt16(0x003C); // Reserved rStrm.WriteUInt32(0x00000000); // sizeOfConstantsUnicode } // section 2.3.4.2.1 void writePROJECTINFORMATION(SvStream& rStrm, const OUString& projectName, const rtl_TextEncoding eTextEncoding) { writePROJECTSYSKIND(rStrm); writePROJECTLCID(rStrm); writePROJECTLCIDINVOKE(rStrm); writePROJECTCODEPAGE(rStrm, eTextEncoding); writePROJECTNAME(rStrm, projectName, eTextEncoding); writePROJECTDOCSTRING(rStrm); writePROJECTHELPFILEPATH(rStrm); writePROJECTHELPCONTEXT(rStrm); writePROJECTLIBFLAGS(rStrm); writePROJECTVERSION(rStrm); writePROJECTCONSTANTS(rStrm); } // section 2.3.4.2.2.2 void writeREFERENCENAME(SvStream& rStrm, const OUString& name, const rtl_TextEncoding eTextEncoding) { rStrm.WriteUInt16(0x0016); // id sal_Int32 size = name.getLength(); rStrm.WriteUInt32(size); // sizeOfName exportString(rStrm, name, eTextEncoding); // name rStrm.WriteUInt16(0x003E); // reserved sal_Int32 unicodesize = size * 2; rStrm.WriteUInt32(unicodesize); // sizeOfNameUnicode exportUTF16String(rStrm, name); // nameUnicode } // section 2.3.4.2.2.5 void writeREFERENCEREGISTERED(SvStream& rStrm, const OUString& libid, const rtl_TextEncoding eTextEncoding) { rStrm.WriteUInt16(0x000D); // id sal_Int32 sizeOfLibid = libid.getLength(); sal_Int32 size = sizeOfLibid + 10; // size of Libid, sizeOfLibid(4 bytes), reserved 1(4 bytes) and reserved 2(2 bytes) rStrm.WriteUInt32(size); // size rStrm.WriteUInt32(sizeOfLibid); // sizeOfLibid exportString(rStrm, libid, eTextEncoding); // Libid rStrm.WriteUInt32(0x00000000); // reserved 1 rStrm.WriteUInt16(0x0000); // reserved 2 } // section 2.3.4.2.2.1 void writeREFERENCE(SvStream& rStrm, const OUString& name, const OUString& libid, const rtl_TextEncoding eTextEncoding) { writeREFERENCENAME(rStrm, name, eTextEncoding); writeREFERENCEREGISTERED(rStrm, libid, eTextEncoding); } // section 2.3.4.2.2 void writePROJECTREFERENCES(SvStream& rStrm, const rtl_TextEncoding eTextEncoding) { // TODO: find out where these references are coming from writeREFERENCE(rStrm, "stdole", "*\\G{00020430-0000-0000-C000-000000000046}#2.0#0#C:\\Windows\\SysWOW64\\stdole2.tlb#OLE Automation", eTextEncoding); writeREFERENCE(rStrm, "Office", "*\\G{2DF8D04C-5BFA-101B-BDE5-00AA0044DE52}#2.0#0#C:\\Program Files (x86)\\Common Files\\Microsoft Shared\\OFFICE14\\MSO.DLL#Microsoft Office 14.0 Object Library", eTextEncoding); } // section 2.3.4.2.3.1 void writePROJECTCOOKIE(SvStream& rStrm) { rStrm.WriteUInt16(0x0013); // id rStrm.WriteUInt32(0x00000002); // size rStrm.WriteUInt16(0xFFFF); // cookie } // section 2.3.4.2.3.2.1 void writeMODULENAME(SvStream& rStrm, const OUString& name, const rtl_TextEncoding eTextEncoding) { rStrm.WriteUInt16(0x0019); // id sal_Int32 n = name.getLength(); // sizeOfModuleName rStrm.WriteUInt32(n); exportString(rStrm, name, eTextEncoding); // ModuleName } // section 2.3.4.2.3.2.2 void writeMODULENAMEUNICODE(SvStream& rStrm, const OUString& name) { rStrm.WriteUInt16(0x0047); // id sal_Int32 n = name.getLength() * 2; // sizeOfModuleNameUnicode // TODO: better calculation for unicode string length rStrm.WriteUInt32(n); exportUTF16String(rStrm, name); // ModuleNameUnicode } // section 2.3.4.2.3.2.3 void writeMODULESTREAMNAME(SvStream& rStrm, const OUString& streamName, const rtl_TextEncoding eTextEncoding) { rStrm.WriteUInt16(0x001A); // id sal_Int32 n = streamName.getLength(); // sizeOfStreamName rStrm.WriteUInt32(n); exportString(rStrm, streamName, eTextEncoding); // StreamName rStrm.WriteUInt16(0x0032); // reserved rStrm.WriteUInt32(n * 2); // sizeOfStreamNameUnicode // TODO: better calculation for unicode string length exportUTF16String(rStrm, streamName); // StreamNameUnicode } // section 2.3.4.2.3.2.4 void writeMODULEDOCSTRING(SvStream& rStrm) { rStrm.WriteUInt16(0x001C); // id rStrm.WriteUInt32(0x00000000); // sizeOfDocString rStrm.WriteUInt16(0x0048); // reserved rStrm.WriteUInt32(0x00000000); // sizeOfDocStringUnicode } // section 2.3.4.2.3.2.5 void writeMODULEOFFSET(SvStream& rStrm) { rStrm.WriteUInt16(0x0031); // id rStrm.WriteUInt32(0x00000004); // sizeOfTextOffset rStrm.WriteUInt32(0x00000000); // TextOffset } // section 2.3.4.2.3.2.6 void writeMODULEHELPCONTEXT(SvStream& rStrm) { rStrm.WriteUInt16(0x001E); // id rStrm.WriteUInt32(0x00000004); // sizeOfHelpContext rStrm.WriteUInt32(0x00000000); // HelpContext } // section 2.3.4.2.3.2.7 void writeMODULECOOKIE(SvStream& rStrm) { rStrm.WriteUInt16(0x002C); // id rStrm.WriteUInt32(0x00000002); // sizeOfHelpContext rStrm.WriteUInt16(0xFFFF); // HelpContext } // section 2.3.4.2.3.2.8 void writeMODULETYPE(SvStream& rStrm, const sal_uInt16 type) { if(type == 1) rStrm.WriteUInt16(0x0021); // id for a procedural module else rStrm.WriteUInt16(0x0022); // id for document, class or design module rStrm.WriteUInt32(0x00000000); // reserved } // section 2.3.4.2.3.2 void writePROJECTMODULE(SvStream& rStrm, const OUString& name, const sal_uInt16 type, const rtl_TextEncoding eTextEncoding) { writeMODULENAME(rStrm, name, eTextEncoding); writeMODULENAMEUNICODE(rStrm, name); writeMODULESTREAMNAME(rStrm, name, eTextEncoding); writeMODULEDOCSTRING(rStrm); writeMODULEOFFSET(rStrm); writeMODULEHELPCONTEXT(rStrm); writeMODULECOOKIE(rStrm); writeMODULETYPE(rStrm, type); rStrm.WriteUInt16(0x002B); // terminator rStrm.WriteUInt32(0x00000000); // reserved } // section 2.3.4.2.3 void writePROJECTMODULES(SvStream& rStrm, const css::uno::Reference& xNameContainer, const std::vector& rLibraryMap, const rtl_TextEncoding eTextEncoding) { const css::uno::Sequence aElementNames = xNameContainer->getElementNames(); sal_Int32 n = aElementNames.getLength(); css::uno::Reference xModuleInfo(xNameContainer, css::uno::UNO_QUERY); assert(xModuleInfo.is()); // TODO: this whole part is document specific rStrm.WriteUInt16(0x000F); // id rStrm.WriteUInt32(0x00000002); // size of Count sal_Int16 count = n; // Number of modules // TODO: this is dependent on the document rStrm.WriteUInt16(count); // Count writePROJECTCOOKIE(rStrm); for (sal_Int32 i = 0; i < n; ++i) { const OUString& rModuleName = aElementNames[rLibraryMap[i]]; css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(rModuleName); writePROJECTMODULE(rStrm, rModuleName, aModuleInfo.ModuleType, eTextEncoding); } } // section 2.3.4.2 void exportDirStream(SvStream& rStrm, const css::uno::Reference& xNameContainer, const std::vector& rLibraryMap, const OUString& projectName, const rtl_TextEncoding eTextEncoding) { SvMemoryStream aDirStream(4096, 4096); writePROJECTINFORMATION(aDirStream, projectName, eTextEncoding); writePROJECTREFERENCES(aDirStream, eTextEncoding); writePROJECTMODULES(aDirStream, xNameContainer, rLibraryMap, eTextEncoding); aDirStream.WriteUInt16(0x0010); // terminator aDirStream.WriteUInt32(0x00000000); // reserved #if VBA_EXPORT_DEBUG static const OUStringLiteral aDirFileName(u"/tmp/vba_dir_out.bin"); SvFileStream aDirStreamDebug(aDirFileName, StreamMode::READWRITE); aDirStream.Seek(0); aDirStreamDebug.WriteStream(aDirStream); #endif VBACompression aCompression(rStrm, aDirStream); aCompression.write(); } // section 2.3.4.3 Module Stream void exportModuleStream(SvStream& rStrm, const OUString& rSourceCode, const OUString& aElementName, css::script::ModuleInfo const& rInfo, const rtl_TextEncoding eTextEncoding) { SvMemoryStream aModuleStream(4096, 4096); exportString(aModuleStream, OUStringConcatenation("Attribute VB_Name = \"" + aElementName + "\"\r\n"), eTextEncoding); if (rInfo.ModuleType == 4) { if (isWorkbook(rInfo.ModuleObject)) exportString(aModuleStream, u"Attribute VB_Base = \"0{00020819-0000-0000-C000-000000000046}\"\r\n", eTextEncoding); else exportString(aModuleStream, u"Attribute VB_Base = \"0{00020820-0000-0000-C000-000000000046}\"\r\n", eTextEncoding); exportString(aModuleStream, u"Attribute VB_GlobalNameSpace = False\r\n", eTextEncoding); exportString(aModuleStream, u"Attribute VB_Creatable = False\r\n", eTextEncoding); exportString(aModuleStream, u"Attribute VB_PredeclaredId = True\r\n", eTextEncoding); exportString(aModuleStream, u"Attribute VB_Exposed = True\r\n", eTextEncoding); exportString(aModuleStream, u"Attribute VB_TemplateDerived = False\r\n", eTextEncoding); exportString(aModuleStream, u"Attribute VB_Customizable = True\r\n", eTextEncoding); } OUString aSourceCode = rSourceCode.replaceFirst("Option VBASupport 1\n", ""); const sal_Int32 nPos = aSourceCode.indexOf("Rem Attribute VBA_ModuleType="); const sal_Int32 nEndPos = nPos != -1 ? aSourceCode.indexOf("\n", nPos) : -1; if (nPos != -1 && nEndPos != -1) aSourceCode = aSourceCode.replaceAt(nPos, nEndPos - nPos+1, u""); aSourceCode = aSourceCode.replaceAll("\n", "\r\n"); exportString(aModuleStream, aSourceCode, eTextEncoding); #if VBA_EXPORT_DEBUG OUString aModuleFileName("/tmp/vba_" + aElementName + "_out.bin"); SvFileStream aModuleStreamDebug(aModuleFileName, StreamMode::READWRITE); aModuleStream.Seek(0); aModuleStreamDebug.WriteStream(aModuleStream); #endif VBACompression aCompression(rStrm, aModuleStream); aCompression.write(); } // section 2.3.4.1 _VBA_PROJECT Stream void exportVBAProjectStream(SvStream& rStrm) { rStrm.WriteUInt16(0x61CC); // Reserved1 rStrm.WriteUInt16(0xFFFF); // Version rStrm.WriteUInt8(0x00); // Reserved2 rStrm.WriteUInt16(0x0000); // Undefined } // section 2.3.1 PROJECT Stream void exportPROJECTStream(SvStream& rStrm, const css::uno::Reference& xNameContainer, const OUString& projectName, const std::vector& rLibraryMap, const rtl_TextEncoding eTextEncoding) { const css::uno::Sequence aElementNames = xNameContainer->getElementNames(); sal_Int32 n = aElementNames.getLength(); css::uno::Reference xModuleInfo(xNameContainer, css::uno::UNO_QUERY); assert(xModuleInfo.is()); // section 2.3.1.1ProjectProperties // section 2.3.1.2 ProjectId exportString(rStrm, u"ID=\"", eTextEncoding); OUString aProjectID = OStringToOUString(comphelper::xml::generateGUIDString(), RTL_TEXTENCODING_UTF8); exportString(rStrm, aProjectID, eTextEncoding); exportString(rStrm, u"\"\r\n", eTextEncoding); // section 2.3.1.3 ProjectModule for (sal_Int32 i = 0; i < n; ++i) { const OUString& rModuleName = aElementNames[rLibraryMap[i]]; css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(rModuleName); if(aModuleInfo.ModuleType == 1) { exportString(rStrm, OUStringConcatenation("Module=" + rModuleName + "\r\n"), eTextEncoding); } else if(aModuleInfo.ModuleType == 4) { exportString(rStrm, OUStringConcatenation("Document=" + rModuleName + "/&H00000000\r\n"), eTextEncoding); } } // section 2.3.1.11 ProjectName exportString(rStrm, OUStringConcatenation("Name=\"" + projectName + "\"\r\n"), eTextEncoding); // section 2.3.1.12 ProjectHelpId exportString(rStrm, u"HelpContextID=\"0\"\r\n", eTextEncoding); // section 2.3.1.14 ProjectVersionCompat32 exportString(rStrm, u"VersionCompatible32=\"393222000\"\r\n", eTextEncoding); // section 2.3.1.15 ProjectProtectionState #if VBA_ENCRYPTION exportString(rStrm, u"CMG=\"", eTextEncoding); SvMemoryStream aProtectedStream(4096, 4096); aProtectedStream.WriteUInt32(0x00000000); const sal_uInt8* pData = static_cast(aProtectedStream.GetData()); sal_uInt8 nProjKey = VBAEncryption::calculateProjKey(aProjectID); VBAEncryption aProtectionState(pData, 4, rStrm, nProjKey, eTextEncoding); aProtectionState.write(); exportString(rStrm, u"\"\r\n", eTextEncoding); #else exportString(rStrm, "CMG=\"BEBC9256EEAAA8AEA8AEA8AEA8AE\"\r\n", eTextEncoding); #endif // section 2.3.1.16 ProjectPassword #if VBA_ENCRYPTION exportString(rStrm, u"DPB=\"", eTextEncoding); aProtectedStream.Seek(0); aProtectedStream.WriteUInt8(0x00); pData = static_cast(aProtectedStream.GetData()); VBAEncryption aProjectPassword(pData, 1, rStrm, nProjKey, eTextEncoding); aProjectPassword.write(); exportString(rStrm, u"\"\r\n", eTextEncoding); #else exportString(rStrm, "DPB=\"7C7E5014B0D3B1D3B1D3\"\r\n", eTextEncoding); #endif // section 2.3.1.17 ProjectVisibilityState #if VBA_ENCRYPTION exportString(rStrm, u"GC=\"", eTextEncoding); aProtectedStream.Seek(0); aProtectedStream.WriteUInt8(0xFF); pData = static_cast(aProtectedStream.GetData()); VBAEncryption aVisibilityState(pData, 1, rStrm, nProjKey, eTextEncoding); aVisibilityState.write(); exportString(rStrm, u"\"\r\n\r\n", eTextEncoding); #else exportString(rStrm, "GC=\"3A3816DAD5DBD5DB2A\"\r\n\r\n", eTextEncoding); #endif // section 2.3.1.18 HostExtenders exportString(rStrm, u"[Host Extender Info]\r\n" "&H00000001={3832D640-CF90-11CF-8E43-00A0C911005A};VBE;&H00000000\r\n\r\n", eTextEncoding); // section 2.3.1.19 ProjectWorkspace exportString(rStrm, u"[Workspace]\r\n", eTextEncoding); for (sal_Int32 i = 0; i < n; ++i) { const OUString& rModuleName = aElementNames[rLibraryMap[i]]; css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(rModuleName); if(aModuleInfo.ModuleType == 1) { exportString(rStrm, OUStringConcatenation(rModuleName + "=25, 25, 1439, 639, \r\n"), eTextEncoding); } else { exportString(rStrm, OUStringConcatenation(rModuleName + "=0, 0, 0, 0, C\r\n"), eTextEncoding); } } } // section 2.3.3.1 NAMEMAP void writeNAMEMAP(SvStream& rStrm, const css::uno::Sequence& rElementNames, const std::vector& rLibraryMap, const rtl_TextEncoding eTextEncoding) { int n = rElementNames.getLength(); for(sal_Int32 i = 0; i < n; ++i) { const OUString& rModuleName = rElementNames[rLibraryMap[i]]; exportString(rStrm, rModuleName, eTextEncoding); rStrm.WriteUInt8(0x00); // terminator exportUTF16String(rStrm, rModuleName); rStrm.WriteUInt16(0x0000); // terminator } } // section 2.3.3 PROJECTwm Stream void exportPROJECTwmStream(SvStream& rStrm, const css::uno::Sequence& rElementNames, const std::vector& rLibraryMap, const rtl_TextEncoding eTextEncoding) { writeNAMEMAP(rStrm, rElementNames, rLibraryMap, eTextEncoding); rStrm.WriteUInt16(0x0000); // terminator } void getCorrectExportOrder(const css::uno::Reference& xNameContainer, std::vector& rLibraryMap) { const css::uno::Sequence aElementNames = xNameContainer->getElementNames(); sal_Int32 n = aElementNames.getLength(); css::uno::Reference xModuleInfo(xNameContainer, css::uno::UNO_QUERY); sal_Int32 nCurrentId = 0; // first all the non-document modules for (sal_Int32 i = 0; i < n; ++i) { css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(aElementNames[i]); if (aModuleInfo.ModuleType != 4) { rLibraryMap[nCurrentId] = i; ++nCurrentId; } } sal_Int32 nWorkbookIndex = -1; // then possibly the workbook module for (sal_Int32 i = 0; i < n; ++i) { css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(aElementNames[i]); bool bWorkbook = isWorkbook(aModuleInfo.ModuleObject); if (bWorkbook) { nWorkbookIndex = i; rLibraryMap[nCurrentId] = i; ++nCurrentId; } } // then the remaining modules for (sal_Int32 i = 0; i < n; ++i) { if (i == nWorkbookIndex) continue; css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(aElementNames[i]); if (aModuleInfo.ModuleType == 4) { rLibraryMap[nCurrentId] = i; ++nCurrentId; } } } } #if VBA_USE_ORIGINAL_WM_STREAM || VBA_USE_ORIGINAL_DIR_STREAM \ || VBA_USE_ORIGINAL_PROJECT_STREAM || VBA_USE_ORIGINAL_VBA_PROJECT \ || VBA_USE_ORIGINAL_DIR_STREAM void addFileStreamToSotStream(const OUString& rPath, SotStorageStream& rStream) { SvFileStream aFileStream(rPath, StreamMode::READWRITE); rStream.WriteStream(aFileStream); } #endif void VbaExport::exportVBA(SotStorage* pRootStorage) { css::uno::Reference xNameContainer = getBasicLibrary(); if (!xNameContainer.is()) { return; } const css::uno::Sequence aElementNames = xNameContainer->getElementNames(); sal_Int32 n = aElementNames.getLength(); // get the number of modules // export the elements in the order MSO expects them // we store the index of the std::vector aLibraryMap(n, 0); getCorrectExportOrder(xNameContainer, aLibraryMap); // start here with the VBA export tools::SvRef xVBAStream = pRootStorage->OpenSotStorage("VBA", StreamMode::READWRITE); tools::SvRef pDirStream = xVBAStream->OpenSotStream("dir", StreamMode::READWRITE); tools::SvRef pVBAProjectStream = xVBAStream->OpenSotStream("_VBA_PROJECT", StreamMode::READWRITE); tools::SvRef pPROJECTStream = pRootStorage->OpenSotStream("PROJECT", StreamMode::READWRITE); tools::SvRef pPROJECTwmStream = pRootStorage->OpenSotStream("PROJECTwm", StreamMode::READWRITE); const rtl_TextEncoding eTextEncoding = getVBATextEncoding(); #if VBA_USE_ORIGINAL_WM_STREAM OUString aProjectwmPath = "/home/moggi/Documents/testfiles/vba/PROJECTwm"; addFileStreamToSotStream(aProjectwmPath, *pPROJECTwmStream); #else exportPROJECTwmStream(*pPROJECTwmStream, aElementNames, aLibraryMap, eTextEncoding); #endif #if VBA_USE_ORIGINAL_DIR_STREAM OUString aDirPath = "/home/moggi/Documents/testfiles/vba/VBA/dir"; addFileStreamToSotStream(aDirPath, *pDirStream); #else exportDirStream(*pDirStream, xNameContainer, aLibraryMap, getProjectName(), eTextEncoding); #endif #if VBA_USE_ORIGINAL_PROJECT_STREAM OUString aProjectPath = "/home/moggi/Documents/testfiles/vba/PROJECT"; addFileStreamToSotStream(aProjectPath, *pPROJECTStream); #else exportPROJECTStream(*pPROJECTStream, xNameContainer, getProjectName(), aLibraryMap, eTextEncoding); #endif #if VBA_USE_ORIGINAL_VBA_PROJECT OUString a_VBA_ProjectPath = "/home/moggi/Documents/testfiles/vba/VBA/_VBA_PROJECT"; addFileStreamToSotStream(a_VBA_ProjectPath, *pVBAProjectStream); #else exportVBAProjectStream(*pVBAProjectStream); #endif #if VBA_USE_ORIGINAL_DIR_STREAM OUString aModule1Path = "/home/moggi/Documents/testfiles/vba/VBA/Module1"; OUString aSheet1Path = "/home/moggi/Documents/testfiles/vba/VBA/Sheet1"; OUString aSheet2Path = "/home/moggi/Documents/testfiles/vba/VBA/Sheet2"; OUString aSheet3Path = "/home/moggi/Documents/testfiles/vba/VBA/Sheet3"; OUString aWorkbookPath = "/home/moggi/Documents/testfiles/vba/VBA/ThisWorkbook"; tools::SvRef pModule1Stream = xVBAStream->OpenSotStream("Module1", StreamMode::READWRITE); tools::SvRef pSheet1Stream = xVBAStream->OpenSotStream("Sheet1", StreamMode::READWRITE); tools::SvRef pSheet2Stream = xVBAStream->OpenSotStream("Sheet2", StreamMode::READWRITE); tools::SvRef pSheet3Stream = xVBAStream->OpenSotStream("Sheet3", StreamMode::READWRITE); tools::SvRef pWorkbookStream = xVBAStream->OpenSotStream("ThisWorkbook", StreamMode::READWRITE); addFileStreamToSotStream(aModule1Path, *pModule1Stream); addFileStreamToSotStream(aSheet1Path, *pSheet1Stream); addFileStreamToSotStream(aSheet2Path, *pSheet2Stream); addFileStreamToSotStream(aSheet3Path, *pSheet3Stream); addFileStreamToSotStream(aWorkbookPath, *pWorkbookStream); pModule1Stream->Commit(); pSheet1Stream->Commit(); pSheet2Stream->Commit(); pSheet3Stream->Commit(); pWorkbookStream->Commit(); #else css::uno::Reference xModuleInfo(xNameContainer, css::uno::UNO_QUERY); for (sal_Int32 i = 0; i < n; ++i) { const OUString& rModuleName = aElementNames[aLibraryMap[i]]; tools::SvRef pModuleStream = xVBAStream->OpenSotStream(rModuleName, StreamMode::READWRITE); css::uno::Any aCode = xNameContainer->getByName(rModuleName); css::script::ModuleInfo aModuleInfo = xModuleInfo->getModuleInfo(rModuleName); OUString aSourceCode; aCode >>= aSourceCode; exportModuleStream(*pModuleStream, aSourceCode, rModuleName, aModuleInfo, eTextEncoding); pModuleStream->Commit(); } #endif pVBAProjectStream->Commit(); pDirStream->Commit(); xVBAStream->Commit(); pPROJECTStream->Commit(); pPROJECTwmStream->Commit(); pRootStorage->Commit(); } css::uno::Reference VbaExport::getLibraryContainer() const { oox::PropertySet aDocProp(mxModel); css::uno::Reference xLibContainer(aDocProp.getAnyProperty(oox::PROP_BasicLibraries), css::uno::UNO_QUERY); return xLibContainer; } css::uno::Reference VbaExport::getBasicLibrary() const { css::uno::Reference xLibrary; try { css::uno::Reference xLibContainer = getLibraryContainer(); OUString aProjectName = getProjectName(); xLibrary.set( xLibContainer->getByName(aProjectName), css::uno::UNO_QUERY_THROW ); } catch(...) { } return xLibrary; } bool VbaExport::containsVBAProject() { css::uno::Reference xLibContainer = getLibraryContainer(); if (!xLibContainer.is()) return false; css::uno::Reference xVbaCompatibility (xLibContainer, css::uno::UNO_QUERY); if (!xVbaCompatibility.is()) return false; bool bVBACompatibility = xVbaCompatibility->getVBACompatibilityMode(); return bVBACompatibility; } OUString VbaExport::getProjectName() const { css::uno::Reference xVbaCompatibility(getLibraryContainer(), css::uno::UNO_QUERY); if (xVbaCompatibility.is()) return xVbaCompatibility->getProjectName(); return OUString(); } rtl_TextEncoding VbaExport::getVBATextEncoding() const { rtl_TextEncoding aTextEncoding = osl_getThreadTextEncoding(); css::uno::Reference xProps(getLibraryContainer(), css::uno::UNO_QUERY); if (xProps.is()) try { xProps->getPropertyValue("VBATextEncoding") >>= aTextEncoding; } catch (const css::uno::Exception&) { } return aTextEncoding; } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */