private byte[] SetMiniStream(List <CompoundDocumentItem> dirs)
{
//Create the miniStream
using (var ms = RecyclableMemory.GetStream())
{
var bwMiniFATStream = new BinaryWriter(ms);
using (var msforBw = RecyclableMemory.GetStream())
{
var bwMiniFAT = new BinaryWriter(msforBw);
int pos = 0;
foreach (var entity in dirs)
{
if (entity.ObjectType != 5 && entity.StreamSize > 0 && entity.StreamSize <= _miniStreamCutoffSize)
{
bwMiniFATStream.Write(entity.Stream);
WriteStreamFullSector(bwMiniFATStream, miniFATSectorSize);
int size = _miniSectorSize;
entity.StartingSectorLocation = pos;
while (entity.StreamSize > size)
{
bwMiniFAT.Write(++pos);
size += _miniSectorSize;
}
bwMiniFAT.Write(END_OF_CHAIN);
pos++;
}
}
dirs[0].StreamSize = ms.Length;
dirs[0].Stream = ms.ToArray();
WriteStreamFullSector(bwMiniFAT, _sectorSize);
return(msforBw.ToArray());
}
}
}
public CompoundDocumentFile(byte[] file)
{
using (var ms = RecyclableMemory.GetStream(file))
{
LoadFromMemoryStream(ms);
}
}
private byte[] CreateTransformInfoPrimary()
{
using (var ms = RecyclableMemory.GetStream())
{
BinaryWriter bw = new BinaryWriter(ms);
string TransformID = "{FF9A3F03-56EF-4613-BDD5-5A41C1D07246}";
string TransformName = "Microsoft.Container.EncryptionTransform";
bw.Write(TransformID.Length * 2 + 12);
bw.Write((int)1);
bw.Write(TransformID.Length * 2);
bw.Write(UTF8Encoding.Unicode.GetBytes(TransformID));
bw.Write(TransformName.Length * 2);
bw.Write(UTF8Encoding.Unicode.GetBytes(TransformName + "\0"));
bw.Write((int)1); //ReaderVersion
bw.Write((int)1); //UpdaterVersion
bw.Write((int)1); //WriterVersion
bw.Write((int)0);
bw.Write((int)0);
bw.Write((int)0); //CipherMode
bw.Write((int)4); //Reserved
bw.Flush();
return(ms.ToArray());
}
}
internal static void LoadXmlSafe(XmlDocument xmlDoc, string xml, Encoding encoding)
{
using (var stream = RecyclableMemory.GetStream(encoding.GetBytes(xml)))
{
LoadXmlSafe(xmlDoc, stream);
}
}
private byte[] EncryptData(byte[] key, byte[] data, bool useDataSize)
{
#if (Core)
var aes = Aes.Create();
#else
RijndaelManaged aes = new RijndaelManaged();
#endif
aes.KeySize = key.Length * 8;
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.Zeros;
//Encrypt the data
var crypt = aes.CreateEncryptor(key, null);
using (var ms = RecyclableMemory.GetStream())
{
var cs = new CryptoStream(ms, crypt, CryptoStreamMode.Write);
cs.Write(data, 0, data.Length);
cs.FlushFinalBlock();
byte[] ret;
if (useDataSize)
{
ret = new byte[data.Length];
ms.Seek(0, SeekOrigin.Begin);
ms.Read(ret, 0, data.Length); //Truncate any padded Zeros
return(ret);
}
else
{
return(ms.ToArray());
}
}
}
private byte[] GetStream(int startingSectorLocation, long streamSize, List <int> FAT, List <byte[]> sectors)
{
using (var ms = RecyclableMemory.GetStream())
{
var bw = new BinaryWriter(ms);
var size = 0;
var nextSector = startingSectorLocation;
while (size < streamSize)
{
if (streamSize > size + sectors[nextSector].Length)
{
bw.Write(sectors[nextSector]);
size += sectors[nextSector].Length;
}
else
{
var part = new byte[streamSize - size];
Array.Copy(sectors[nextSector], part, (int)streamSize - size);
bw.Write(part);
size += part.Length;
}
nextSector = FAT[nextSector];
}
bw.Flush();
return(ms.ToArray());
}
}
internal void Read(byte[] doc)
{
using (var ms = RecyclableMemory.GetStream(doc))
{
Read(ms);
}
}
internal static byte[] GetImageAsByteArray(Image image)
{
using (var ms = RecyclableMemory.GetStream())
{
if (image.RawFormat.Guid == ImageFormat.Gif.Guid)
{
image.Save(ms, ImageFormat.Gif);
}
else if (image.RawFormat.Guid == ImageFormat.Bmp.Guid)
{
image.Save(ms, ImageFormat.Bmp);
}
else if (image.RawFormat.Guid == ImageFormat.Png.Guid)
{
image.Save(ms, ImageFormat.Png);
}
else if (image.RawFormat.Guid == ImageFormat.Tiff.Guid)
{
image.Save(ms, ImageFormat.Tiff);
}
else
{
image.Save(ms, ImageFormat.Jpeg);
}
return(ms.ToArray());
}
}
private byte[] DecryptAgileFromKey(EncryptionInfoAgile.EncryptionKeyData encr, byte[] key, byte[] encryptedData, long size, byte[] iv)
{
SymmetricAlgorithm decryptKey = GetEncryptionAlgorithm(encr);
decryptKey.BlockSize = encr.BlockSize << 3;
decryptKey.KeySize = encr.KeyBits;
#if (Core)
decryptKey.Mode = CipherMode.CBC;
#else
decryptKey.Mode = encr.CipherChaining == eChainingMode.ChainingModeCBC ? CipherMode.CBC : CipherMode.CFB;
#endif
decryptKey.Padding = PaddingMode.Zeros;
ICryptoTransform decryptor = decryptKey.CreateDecryptor(
FixHashSize(key, encr.KeyBits / 8),
FixHashSize(iv, encr.BlockSize, 0x36));
using (var dataStream = RecyclableMemory.GetStream(encryptedData))
{
CryptoStream cryptoStream = new CryptoStream(dataStream,
decryptor,
CryptoStreamMode.Read);
var decryptedData = new byte[size];
cryptoStream.Read(decryptedData, 0, (int)size);
return(decryptedData);
}
}
/// <summary>
/// Uncompress a GZip'ed byte array into a single string.
/// </summary>
///
/// <seealso cref="GZipStream.CompressString(String)"/>
/// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
///
/// <param name="compressed">
/// A buffer containing GZIP-compressed data.
/// </param>
///
/// <returns>The uncompressed string</returns>
public static String UncompressString(byte[] compressed)
{
using (var input = RecyclableMemory.GetStream(compressed))
{
Stream decompressor = new GZipStream(input, CompressionMode.Decompress);
return(ZlibBaseStream.UncompressString(compressed, decompressor));
}
}
public void WriteBlock(ByteBuffer block)
{
using (MemoryStream ms = RecyclableMemory.GetStream(_header_block.BigBlockSize.GetBigBlockSize()))
{
_header_block.WriteData(ms);
block.Write(ms.ToArray());
}
}
private byte[] GetContentHash(ExcelVbaProject proj)
{
//MS-OVBA 2.4.2
var enc = System.Text.Encoding.GetEncoding(proj.CodePage);
using (var ms = RecyclableMemory.GetStream())
{
BinaryWriter bw = new BinaryWriter(ms);
bw.Write(enc.GetBytes(proj.Name));
bw.Write(enc.GetBytes(proj.Constants));
foreach (var reference in proj.References)
{
if (reference.ReferenceRecordID == 0x0D)
{
bw.Write((byte)0x7B);
}
if (reference.ReferenceRecordID == 0x0E)
{
//var r = (ExcelVbaReferenceProject)reference;
//BinaryWriter bwTemp = new BinaryWriter(new MemoryStream());
//bwTemp.Write((uint)r.Libid.Length);
//bwTemp.Write(enc.GetBytes(r.Libid));
//bwTemp.Write((uint)r.LibIdRelative.Length);
//bwTemp.Write(enc.GetBytes(r.LibIdRelative));
//bwTemp.Write(r.MajorVersion);
//bwTemp.Write(r.MinorVersion);
foreach (byte b in BitConverter.GetBytes((uint)reference.Libid.Length)) //Length will never be an UInt with 4 bytes that aren't 0 (> 0x00FFFFFF), so no need for the rest of the properties.
{
if (b != 0)
{
bw.Write(b);
}
else
{
break;
}
}
}
}
foreach (var module in proj.Modules)
{
var lines = module.Code.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in lines)
{
if (!line.StartsWith("attribute", StringComparison.OrdinalIgnoreCase))
{
bw.Write(enc.GetBytes(line));
}
}
}
var buffer = ms.ToArray();
var hp = System.Security.Cryptography.MD5.Create();
return(hp.ComputeHash(buffer));
}
}
/// <summary>
/// Uncompress a DEFLATE'd byte array into a byte array.
/// </summary>
///
/// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
/// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
/// <seealso cref="GZipStream.UncompressBuffer(byte[])">GZipStream.UncompressBuffer(byte[])</seealso>
/// <seealso cref="ZlibStream.UncompressBuffer(byte[])">ZlibStream.UncompressBuffer(byte[])</seealso>
///
/// <param name="compressed">
/// A buffer containing data that has been compressed with DEFLATE.
/// </param>
///
/// <returns>The data in uncompressed form</returns>
public static byte[] UncompressBuffer(byte[] compressed)
{
using (var input = RecyclableMemory.GetStream(compressed))
{
System.IO.Stream decompressor =
new DeflateStream(input, CompressionMode.Decompress);
return(ZlibBaseStream.UncompressBuffer(compressed, decompressor));
}
}
public void WriteBlock(byte[] block)
{
using (MemoryStream ms = RecyclableMemory.GetStream(_header_block.BigBlockSize.GetBigBlockSize()))
{
_header_block.WriteData(ms);
byte[] temp = ms.ToArray();
Array.Copy(temp, 0, block, 0, temp.Length);
}
}
/// <summary>
/// Compress a string into a byte array using DEFLATE (RFC 1951).
/// </summary>
///
/// <remarks>
/// Uncompress it with <see cref="DeflateStream.UncompressString(byte[])"/>.
/// </remarks>
///
/// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
/// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
/// <seealso cref="GZipStream.CompressString(string)">GZipStream.CompressString(string)</seealso>
/// <seealso cref="ZlibStream.CompressString(string)">ZlibStream.CompressString(string)</seealso>
///
/// <param name="s">
/// A string to compress. The string will first be encoded
/// using UTF8, then compressed.
/// </param>
///
/// <returns>The string in compressed form</returns>
public static byte[] CompressString(String s)
{
using (var ms = RecyclableMemory.GetStream())
{
System.IO.Stream compressor =
new DeflateStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
ZlibBaseStream.CompressString(s, compressor);
return(ms.ToArray());
}
}
/// <summary>
/// Converts a range to text in CSV format.
/// Invariant culture is used by default.
/// </summary>
/// <param name="Format">Information how to create the csv text</param>
/// <returns>A string containing the text</returns>
public string ToText(ExcelOutputTextFormat Format)
{
using (var ms = RecyclableMemory.GetStream())
{
SaveToText(ms, Format);
ms.Position = 0;
var sr = new StreamReader(ms);
return(sr.ReadToEnd());
}
}
private string WritePassword()
{
byte[] nullBits = new byte[3];
byte[] nullKey = new byte[4];
byte[] nullHash = new byte[20];
if (Protection.PasswordKey == null)
{
return(Encrypt(new byte[] { 0 }));
}
else
{
Array.Copy(Protection.PasswordKey, nullKey, 4);
Array.Copy(Protection.PasswordHash, nullHash, 20);
//Set Null bits
for (int i = 0; i < 24; i++)
{
byte bit = (byte)(128 >> (int)((i % 8)));
if (i < 4)
{
if (nullKey[i] == 0)
{
nullKey[i] = 1;
}
else
{
nullBits[0] |= bit;
}
}
else
{
if (nullHash[i - 4] == 0)
{
nullHash[i - 4] = 1;
}
else
{
int byteIndex = (i - i % 8) / 8;
nullBits[byteIndex] |= bit;
}
}
}
//Write the Password Hash Data Structure (2.4.4.1)
using (var ms = RecyclableMemory.GetStream())
{
BinaryWriter bw = new BinaryWriter(ms);
bw.Write((byte)0xFF);
bw.Write(nullBits);
bw.Write(nullKey);
bw.Write(nullHash);
bw.Write((byte)0);
return(Encrypt(ms.ToArray()));
}
}
}
/// <summary>
/// Validate the password
/// </summary>
/// <param name="key">The encryption key</param>
/// <param name="encryptionInfo">The encryption info extracted from the ENCRYPTIOINFO stream inside the OLE document</param>
/// <returns></returns>
private bool IsPasswordValid(byte[] key, EncryptionInfoBinary encryptionInfo)
{
#if (Core)
var decryptKey = Aes.Create();
#else
RijndaelManaged decryptKey = new RijndaelManaged();
#endif
decryptKey.KeySize = encryptionInfo.Header.KeySize;
decryptKey.Mode = CipherMode.ECB;
decryptKey.Padding = PaddingMode.None;
ICryptoTransform decryptor = decryptKey.CreateDecryptor(
key,
null);
//Decrypt the verifier
MemoryStream dataStream;
var decryptedVerifier = new byte[16];
var decryptedVerifierHash = new byte[16];
using (dataStream = RecyclableMemory.GetStream(encryptionInfo.Verifier.EncryptedVerifier))
{
CryptoStream cryptoStream = new CryptoStream(dataStream,
decryptor,
CryptoStreamMode.Read);
cryptoStream.Read(decryptedVerifier, 0, 16);
}
using (dataStream = RecyclableMemory.GetStream(encryptionInfo.Verifier.EncryptedVerifierHash))
{
var cryptoStream = new CryptoStream(dataStream,
decryptor,
CryptoStreamMode.Read);
//Decrypt the verifier hash
cryptoStream.Read(decryptedVerifierHash, 0, 16);
}
//Get the hash for the decrypted verifier
#if (Core)
var sha = SHA1.Create();
#else
var sha = new SHA1Managed();
#endif
var hash = sha.ComputeHash(decryptedVerifier);
//Equal?
for (int i = 0; i < 16; i++)
{
if (hash[i] != decryptedVerifierHash[i])
{
return(false);
}
}
return(true);
}
/// <summary>
/// Compress a byte array into a new byte array using ZLIB.
/// </summary>
///
/// <remarks>
/// Uncompress it with <see cref="ZlibStream.UncompressBuffer(byte[])"/>.
/// </remarks>
///
/// <seealso cref="ZlibStream.CompressString(string)"/>
/// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
///
/// <param name="b">
/// A buffer to compress.
/// </param>
///
/// <returns>The data in compressed form</returns>
public static byte[] CompressBuffer(byte[] b)
{
using (var ms = RecyclableMemory.GetStream())
{
Stream compressor =
new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
ZlibBaseStream.CompressBuffer(b, compressor);
return(ms.ToArray());
}
}
/// <summary>
/// Converts a range to text in CSV format.
/// Invariant culture is used by default.
/// </summary>
/// <param name="Format">Information how to create the csv text</param>
/// <returns>A string containing the text</returns>
public async Task <string> ToTextAsync(ExcelOutputTextFormat Format)
{
using (var ms = RecyclableMemory.GetStream())
{
await SaveToTextAsync(ms, Format).ConfigureAwait(false);
ms.Position = 0;
var sr = new StreamReader(ms);
return(await sr.ReadToEndAsync().ConfigureAwait(false));
}
}
internal MemoryStream GetStream(FileMode fileMode, FileAccess fileAccess)
{
if (_stream == null || fileMode == FileMode.CreateNew || fileMode == FileMode.Create)
{
_stream = RecyclableMemory.GetStream();
}
else
{
_stream.Seek(0, SeekOrigin.Begin);
}
return(_stream);
}
internal byte[] SignProject(ExcelVbaProject proj)
{
if (!Certificate.HasPrivateKey)
{
//throw (new InvalidOperationException("The certificate doesn't have a private key"));
Certificate = null;
return(null);
}
var hash = GetContentHash(proj);
ContentInfo contentInfo;
using (var ms = RecyclableMemory.GetStream())
{
BinaryWriter bw = new BinaryWriter(ms);
bw.Write((byte)0x30); //Constructed Type
bw.Write((byte)0x32); //Total length
bw.Write((byte)0x30); //Constructed Type
bw.Write((byte)0x0E); //Length SpcIndirectDataContent
bw.Write((byte)0x06); //Oid Tag Indentifier
bw.Write((byte)0x0A); //Lenght OId
bw.Write(new byte[] { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0x37, 0x02, 0x01, 0x1D }); //Encoded Oid 1.3.6.1.4.1.311.2.1.29
bw.Write((byte)0x04); //Octet String Tag Identifier
bw.Write((byte)0x00); //Zero length
bw.Write((byte)0x30); //Constructed Type (DigestInfo)
bw.Write((byte)0x20); //Length DigestInfo
bw.Write((byte)0x30); //Constructed Type (Algorithm)
bw.Write((byte)0x0C); //length AlgorithmIdentifier
bw.Write((byte)0x06); //Oid Tag Indentifier
bw.Write((byte)0x08); //Lenght OId
bw.Write(new byte[] { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x02, 0x05 }); //Encoded Oid for 1.2.840.113549.2.5 (AlgorithmIdentifier MD5)
bw.Write((byte)0x05); //Null type identifier
bw.Write((byte)0x00); //Null length
bw.Write((byte)0x04); //Octet String Identifier
bw.Write((byte)hash.Length); //Hash length
bw.Write(hash); //Content hash
contentInfo = new ContentInfo(ms.ToArray());
}
contentInfo.ContentType.Value = "1.3.6.1.4.1.311.2.1.4";
#if (Core)
Verifier = new EnvelopedCms(contentInfo);
var r = new CmsRecipient(Certificate);
Verifier.Encrypt(r);
return(Verifier.Encode());
#else
Verifier = new SignedCms(contentInfo);
var signer = new CmsSigner(Certificate);
Verifier.ComputeSignature(signer, false);
return(Verifier.Encode());
#endif
}
/// <summary>
/// MS-OVBA 2.3.4.1
/// </summary>
/// <returns></returns>
private byte[] CreateVBAProjectStream()
{
using (var ms = RecyclableMemory.GetStream())
{
BinaryWriter bw = new BinaryWriter(ms);
bw.Write((ushort)0x61CC); //Reserved1
bw.Write((ushort)0xFFFF); //Version
bw.Write((byte)0x0); //Reserved3
bw.Write((ushort)0x0); //Reserved4
return(ms.ToArray());
}
}
/// <summary>
/// Loads a .thmx file, exported from a Spread Sheet Application like Excel
/// </summary>
/// <param name="thmxFile">The path to the thmx file</param>
public void Load(FileInfo thmxFile)
{
if (!thmxFile.Exists)
{
throw (new FileNotFoundException($"{thmxFile.FullName} does not exist"));
}
using (var ms = RecyclableMemory.GetStream(File.ReadAllBytes(thmxFile.FullName)))
{
Load(ms);
}
}
private void GetMiniSectors(byte[] miniFATStream)
{
using (var ms = RecyclableMemory.GetStream(miniFATStream))
{
var br = new BinaryReader(ms);
_miniSectors = new List <byte[]>();
while (ms.Position < ms.Length)
{
_miniSectors.Add(br.ReadBytes(_miniSectorSize));
}
}
}
public byte[] Serialize()
{
int size = DataSize + 4;
using (MemoryStream baos = RecyclableMemory.GetStream(size))
{
Serialize(new LittleEndianOutputStream(baos));
if (baos.Length != size)
{
throw new Exception("write size mismatch");
}
return(baos.ToArray());
}
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="Password"></param>
/// <param name="cancellationToken"></param>
private async Task LoadAsync(Stream input, Stream output, string Password, CancellationToken cancellationToken)
{
ReleaseResources();
if (input.CanSeek && input.Length == 0) // Template is blank, Construct new
{
_stream = output;
await ConstructNewFileAsync(Password, cancellationToken).ConfigureAwait(false);
}
else
{
Stream ms;
_stream = output;
if (Password != null)
{
using (var encrStream = RecyclableMemory.GetStream())
{
await CopyStreamAsync(input, encrStream, cancellationToken).ConfigureAwait(false);
var eph = new EncryptedPackageHandler();
Encryption.Password = Password;
ms = eph.DecryptPackage(encrStream, Encryption);
}
}
else
{
ms = RecyclableMemory.GetStream();
await CopyStreamAsync(input, ms, cancellationToken).ConfigureAwait(false);
}
try
{
_zipPackage = new Packaging.ZipPackage(ms);
}
catch (Exception ex)
{
if (Password == null && await CompoundDocumentFile.IsCompoundDocumentAsync((MemoryStream)_stream, cancellationToken).ConfigureAwait(false))
{
throw new Exception("Can not open the package. Package is an OLE compound document. If this is an encrypted package, please supply the password", ex);
}
throw;
}
finally
{
ms.Dispose();
}
}
//Clear the workbook so that it gets reinitialized next time
this._workbook = null;
}
private static byte[] blankWorksheet()
{
using (MemoryStream out1 = RecyclableMemory.GetStream())
{
try
{
new XSSFSheet().Write(out1);
}
catch (IOException e)
{
throw new RuntimeException(e);
}
return(out1.ToArray());
}
}
private async Task ConstructNewFileAsync(string password, CancellationToken cancellationToken)
{
var ms = RecyclableMemory.GetStream();
if (_stream == null)
{
_stream = RecyclableMemory.GetStream();
}
File?.Refresh();
if (File != null && File.Exists)
{
if (password != null)
{
var encrHandler = new EncryptedPackageHandler();
Encryption.IsEncrypted = true;
Encryption.Password = password;
ms.Dispose();
ms = encrHandler.DecryptPackage(File, Encryption);
}
else
{
await WriteFileToStreamAsync(File.FullName, ms, cancellationToken).ConfigureAwait(false);
}
try
{
_zipPackage = new Packaging.ZipPackage(ms);
}
catch (Exception ex)
{
if (password == null && await CompoundDocumentFile.IsCompoundDocumentAsync(File, cancellationToken).ConfigureAwait(false))
{
throw new Exception("Can not open the package. Package is an OLE compound document. If this is an encrypted package, please supply the password", ex);
}
throw;
}
finally
{
ms.Dispose();
}
}
else
{
_zipPackage = new Packaging.ZipPackage(ms);
ms.Dispose();
CreateBlankWb();
}
}
private byte[] CreateStrongEncryptionDataSpaceStream()
{
MemoryStream ms = RecyclableMemory.GetStream();
BinaryWriter bw = new BinaryWriter(ms);
bw.Write((int)8); //HeaderLength
bw.Write((int)1); //EntryCount
string tr = "StrongEncryptionTransform";
bw.Write((int)tr.Length * 2);
bw.Write(UTF8Encoding.Unicode.GetBytes(tr + "\0")); // end \0 is for padding
bw.Flush();
return(ms.ToArray());
}