Exemplo n.º 1
0
        /// <summary>
        /// This method saves all the Excel embedded binary objects from the <paramref name="inputFile"/> to the
        /// <see cref="outputFolder"/>
        /// </summary>
        /// <param name="inputFile">The binary Excel file</param>
        /// <param name="outputFolder">The output folder</param>
        /// <returns></returns>
        /// <exception cref="OEFileIsPasswordProtected">Raised when the <paramref name="inputFile"/> is password protected</exception>
        /// <exception cref="OEFileIsCorrupt">Raised when the file is corrupt</exception>
        public static List<string> SaveToFolder(string inputFile, string outputFolder)
        {
            using (var compoundFile = new CompoundFile(inputFile))
            {
                try
                {
                    if (IsPasswordProtected(compoundFile))
                        throw new OEFileIsPasswordProtected("The file '" + Path.GetFileName(inputFile) +
                                                            "' is password protected");
                }
                catch (CFCorruptedFileException)
                {
                    throw new OEFileIsCorrupt("The file '" + Path.GetFileName(inputFile) + "' is corrupt");
                }

                var result = new List<string>();

                foreach (var child in compoundFile.RootStorage.Children)
                {
                    var childStorage = child as CFStorage;
                    if (childStorage == null) continue;

                    // Linked files start with "LNK"
                    if (!childStorage.Name.StartsWith("MBD")) continue;

                    var extractedFileName = Extraction.SaveFromStorageNode(childStorage, outputFolder);
                    if (extractedFileName != null)
                        result.Add(extractedFileName);
                }

                return result;
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Returns true when the Word file is password protected
        /// </summary>
        /// <param name="compoundFile"></param>
        /// <returns></returns>
        /// <exception cref="OEFileIsCorrupt">Raised when the file is corrupt</exception>
        public static bool IsPasswordProtected(CompoundFile compoundFile)
        {
            if (!compoundFile.RootStorage.ExistsStream("WordDocument")) 
                throw new OEFileIsCorrupt("Could not find the WordDocument stream in the file '" + compoundFile.FileName + "'");

            var stream = compoundFile.RootStorage.GetStream("WordDocument") as CFStream;
            if (stream == null) return false;

            var bytes = stream.GetData();
            using (var memoryStream = new MemoryStream(bytes))
            using (var binaryReader = new BinaryReader(memoryStream))
            {
                //http://msdn.microsoft.com/en-us/library/dd944620%28v=office.12%29.aspx
                // The bit that shows if the file is encrypted is in the 11th and 12th byte so we 
                // need to skip the first 10 bytes
                binaryReader.ReadBytes(10);

                // Now we read the 2 bytes that we need
                var pnNext = binaryReader.ReadUInt16();
                //(value & mask) == mask)

                // The bit that tells us if the file is encrypted
                return (pnNext & 0x0100) == 0x0100;
            }
        }
Exemplo n.º 3
0
        internal CFStream(CompoundFile sectorManager, IDirectoryEntry dirEntry)
            : base(sectorManager)
        {
            if (dirEntry == null || dirEntry.SID < 0)
                throw new CFException("Attempting to add a CFStream using an unitialized directory");

            DirEntry = dirEntry;
        }
Exemplo n.º 4
0
        /// <summary>
        /// This method saves all the Word embedded binary objects from the <paramref name="inputFile"/> to the
        /// <see cref="outputFolder"/>
        /// </summary>
        /// <param name="inputFile">The binary Word file</param>
        /// <param name="outputFolder">The output folder</param>
        /// <returns></returns>
        /// <exception cref="OEFileIsPasswordProtected">Raised when the <see cref="inputFile"/> is password protected</exception>
        public static List<string> SaveToFolder(string inputFile, string outputFolder)
        {
            using (var compoundFile = new CompoundFile(inputFile))
            {
                if (IsPasswordProtected(compoundFile))
                    throw new OEFileIsPasswordProtected("The file '" + Path.GetFileName(inputFile) +
                                                        "' is password protected");

                var result = new List<string>();

                if (!compoundFile.RootStorage.ExistsStorage("ObjectPool")) return result;
                var objectPoolStorage = compoundFile.RootStorage.GetStorage("ObjectPool") as CFStorage;
                if (objectPoolStorage == null) return result;

                // Multiple objects are stored as children of the storage object
                foreach (var child in objectPoolStorage.Children)
                {
                    var childStorage = child as CFStorage;
                    if (childStorage == null) continue;

                    // Get the objInfo stream to check if this is a linked file... if so then ignore it
                    var objInfo = childStorage.GetStream("\x0003ObjInfo");
                    var objInfoStream = new ObjInfoStream(objInfo);

                    // We don't want to export linked objects and objects that are not shown as an icon... 
                    // because these objects are already visible on the Word document
                    if (objInfoStream.Link || !objInfoStream.Icon)
                        continue;

                    var extractedFileName = Extraction.SaveFromStorageNode(childStorage, outputFolder);
                    if (!string.IsNullOrEmpty(extractedFileName))
                        result.Add(extractedFileName);
                }

                return result;
            }
        }
Exemplo n.º 5
0
 protected CFItem(CompoundFile compoundFile)
 {
     _compoundFile = compoundFile;
 }
Exemplo n.º 6
0
        /// <summary>
        /// Saves the <paramref name="data"/> byte array to the <paramref name="outputFile"/>
        /// </summary>
        /// <param name="data">The stream as byte array</param>
        /// <param name="outputFile">The output filename with path</param>
        /// <returns></returns>
        /// <exception cref="OEFileIsCorrupt">Raised when the file is corrupt</exception> 
        internal static string SaveByteArrayToFile(byte[] data, string outputFile)
        {
            // Because the data is stored in a stream we have no name for it so we
            // have to check the magic bytes to see with what kind of file we are dealing

            var extension = Path.GetExtension(outputFile);

            if (string.IsNullOrEmpty(extension))
            {
                var fileType = FileTypeSelector.GetFileTypeFileInfo(data);
                if (fileType != null && !string.IsNullOrEmpty(fileType.Extension))
                    outputFile += "." + fileType.Extension;

                if (fileType != null)
                    extension = "." + fileType.Extension;
            }

            // Check if the output file already exists and if so make a new one
            outputFile = FileManager.FileExistsMakeNew(outputFile);

            if (extension != null)
            {
                switch (extension.ToUpperInvariant())
                {
                    case ".XLS":
                    case ".XLT":
                    case ".XLW":
                        using (var memoryStream = new MemoryStream(data))
                        using (var compoundFile = new CompoundFile(memoryStream))
                        {
                            Excel.SetWorkbookVisibility(compoundFile.RootStorage);
                            compoundFile.Save(outputFile);
                        }
                        break;

                    case ".XLSB":
                    case ".XLSM":
                    case ".XLSX":
                    case ".XLTM":
                    case ".XLTX":
                        using (var memoryStream = new MemoryStream(data))
                        {
                            var file = Excel.SetWorkbookVisibility(memoryStream);
                            File.WriteAllBytes(outputFile, file.ToArray());
                        }
                        break;

                    default:
                        File.WriteAllBytes(outputFile, data);
                        break;
                }
            }
            else
                File.WriteAllBytes(outputFile, data);

            return outputFile;
        }
Exemplo n.º 7
0
        /// <summary>
        /// This will save the complete tree from the given <paramref name="storage"/> to a new <see cref="CompoundFile"/>
        /// </summary>
        /// <param name="storage"></param>
        /// <param name="fileName">The filename with path for the new compound file</param>
        internal static string SaveStorageTreeToCompoundFile(CFStorage storage, string fileName)
        {
            fileName = FileManager.FileExistsMakeNew(fileName);

            using (var compoundFile = new CompoundFile())
            {
                GetStorageChain(compoundFile.RootStorage, storage);
                compoundFile.Save(fileName);
            }

            return fileName;
        }
Exemplo n.º 8
0
 /// <summary>
 /// This method will extract and save the data from the given <see cref="CompoundFile"/> node to the <see cref="outputFolder"/>
 /// </summary>
 /// <param name="bytes">The <see cref="CompoundFile"/> as a byte array</param>
 /// <param name="outputFolder">The outputFolder</param>
 /// <param name="fileName">The fileName to use, null when the fileName is unknown</param>
 /// <returns></returns>
 /// <exception cref="OEFileIsPasswordProtected">Raised when a WordDocument, WorkBook or PowerPoint Document stream is password protected</exception>
 internal static string SaveFromStorageNode(byte[] bytes, string outputFolder, string fileName)
 {
     using (var memoryStream = new MemoryStream(bytes))
     using (var compoundFile = new CompoundFile(memoryStream))
         return SaveFromStorageNode(compoundFile.RootStorage, outputFolder, fileName);
 }
Exemplo n.º 9
0
 internal CFStream(CompoundFile sectorManager)
     : base(sectorManager)
 {
     DirEntry = new DirectoryEntry(StgType.StgStream);
     sectorManager.InsertNewDirectoryEntry(DirEntry);
 }
Exemplo n.º 10
0
        /// <summary>
        /// This method saves all the PowerPoint embedded binary objects from the <paramref name="inputFile"/> to the
        /// <paramref name="outputFolder"/>
        /// </summary>
        /// <param name="inputFile">The binary PowerPoint file</param>
        /// <param name="outputFolder">The output folder</param>
        /// <returns></returns>
        /// <exception cref="OEFileIsPasswordProtected">Raised when the <see cref="inputFile"/> is password protected</exception>
        public static List<string> SaveToFolder(string inputFile, string outputFolder)
        {
            using (var compoundFile = new CompoundFile(inputFile))
            {
                if (IsPasswordProtected(compoundFile))
                    throw new OEFileIsPasswordProtected("The file '" + Path.GetFileName(inputFile) +
                                                        "' is password protected");

                var result = new List<string>();

                if (!compoundFile.RootStorage.ExistsStream("PowerPoint Document")) return result;
                var stream = compoundFile.RootStorage.GetStream("PowerPoint Document") as CFStream;
                if (stream == null) return result;

                using (var memoryStream = new MemoryStream(stream.GetData()))
                using (var binaryReader = new BinaryReader(memoryStream))
                {
                    while (binaryReader.BaseStream.Position != memoryStream.Length)
                    {
                        var verAndInstance = binaryReader.ReadUInt16();
                        // ReSharper disable once UnusedVariable
                        var version = verAndInstance & 0x000FU; // First 4 bit of field verAndInstance
                        var instance = (verAndInstance & 0xFFF0U) >> 4; // Last 12 bit of field verAndInstance

                        var typeCode = binaryReader.ReadUInt16();
                        var size = binaryReader.ReadUInt32();

                        // Embedded OLE objects start with code 4113
                        if (typeCode == 4113)
                        {
                            if (instance == 0)
                            {
                                // Uncompressed
                                var bytes = binaryReader.ReadBytes((int)size);

                                // Check if the ole object is another compound storage node with a package stream
                                if (Extraction.IsCompoundFile(bytes))
                                    result.Add(Extraction.SaveFromStorageNode(bytes, outputFolder));
                                else
                                    Extraction.SaveByteArrayToFile(bytes, outputFolder + Extraction.DefaultEmbeddedObjectName);
                            }
                            else
                            {
                                var decompressedSize = binaryReader.ReadUInt32();
                                var data = binaryReader.ReadBytes((int)size - 4);
                                var compressedMemoryStream = new MemoryStream(data);

                                // skip the first 2 bytes
                                compressedMemoryStream.ReadByte();
                                compressedMemoryStream.ReadByte();

                                // Decompress the bytes
                                var decompressedBytes = new byte[decompressedSize];
                                var deflateStream = new DeflateStream(compressedMemoryStream, CompressionMode.Decompress, true);
                                deflateStream.Read(decompressedBytes, 0, decompressedBytes.Length);

                                string extractedFileName;

                                // Check if the ole object is another compound storage node with a package stream
                                if (Extraction.IsCompoundFile(decompressedBytes))
                                    extractedFileName = Extraction.SaveFromStorageNode(decompressedBytes, outputFolder);
                                else
                                    extractedFileName = Extraction.SaveByteArrayToFile(decompressedBytes,
                                        outputFolder + Extraction.DefaultEmbeddedObjectName);

                                if (!string.IsNullOrEmpty(extractedFileName))
                                    result.Add(extractedFileName);
                            }
                        }
                        else
                            binaryReader.BaseStream.Position += size;
                    }
                }

                return result;
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Extracts a Outlook File Attachment object from the given <paramref name="stream"/>
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="outputFolder">The output folder</param>
        internal static string ExtractOutlookAttachmentObject(Stream stream, string outputFolder)
        {
            // Outlook attachments embedded in RTF are firstly embedded in an OLE v1.0 object
            var ole10 = new Ole10(stream);

            // After that it is wrapped in a compound document
            using (var internalStream = new MemoryStream(ole10.NativeData))
            using (var compoundFile = new CompoundFile(internalStream))
            {
                string fileName = null;
                if (compoundFile.RootStorage.ExistsStream("AttachDesc"))
                {
                    var attachDescStream = compoundFile.RootStorage.GetStream("AttachDesc") as CFStream;
                    fileName = GetFileNameFromAttachDescStream(attachDescStream);
                }

                if (string.IsNullOrEmpty(fileName))
                    fileName = Extraction.DefaultEmbeddedObjectName;

                fileName = FileManager.RemoveInvalidFileNameChars(fileName);
                fileName = Path.Combine(outputFolder, fileName);
                fileName = FileManager.FileExistsMakeNew(fileName);

                if (compoundFile.RootStorage.ExistsStream("AttachContents"))
                {
                    var data = compoundFile.RootStorage.GetStream("AttachContents").GetData();
                    return Extraction.SaveByteArrayToFile(data, fileName);
                }

                if (compoundFile.RootStorage.ExistsStorage("MAPIMessage"))
                {

                    fileName = Path.Combine(outputFolder, fileName);
                    var storage = compoundFile.RootStorage.GetStorage("MAPIMessage") as CFStorage;
                    return Extraction.SaveStorageTreeToCompoundFile(storage, fileName);
                }

                return null;
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// Extracts all the embedded object from the OpenDocument <paramref name="inputFile"/> to the 
        /// <see cref="outputFolder"/> and returns the files with full path as a list of strings
        /// </summary>
        /// <param name="inputFile">The OpenDocument format file</param>
        /// <param name="outputFolder">The output folder</param>
        /// <returns>List with files or en empty list when there are nog embedded files</returns>
        /// <exception cref="OEFileIsPasswordProtected">Raised when the OpenDocument format file is password protected</exception>
        internal List<string> ExtractFromOpenDocumentFormat(string inputFile, string outputFolder)
        {
            var result = new List<string>();

            var zipFile = new ZipFile(inputFile);
  
            // Check if the file is password protected
            var manifestEntry = zipFile.FindEntry("META-INF/manifest.xml", true);
            if (manifestEntry != -1)
            {
                using (var manifestEntryStream = zipFile.GetInputStream(manifestEntry))
                using (var manifestEntryMemoryStream = new MemoryStream())
                {
                    manifestEntryStream.CopyTo(manifestEntryMemoryStream);
                    manifestEntryMemoryStream.Position = 0;
                    using (var streamReader = new StreamReader(manifestEntryMemoryStream))
                    {
                        var manifest = streamReader.ReadToEnd();
                        if (manifest.ToUpperInvariant().Contains("ENCRYPTION-DATA"))
                            throw new OEFileIsPasswordProtected("The file '" + Path.GetFileName(inputFile) +
                                                                "' is password protected");
                    }
                }
            }

            foreach (ZipEntry zipEntry in zipFile)
            {
                if (!zipEntry.IsFile) continue;
                if (zipEntry.IsCrypted)
                    throw new OEFileIsPasswordProtected("The file '" + Path.GetFileName(inputFile) +
                                                                "' is password protected");

                var name = zipEntry.Name.ToUpperInvariant();
                if (!name.StartsWith("OBJECT") || name.Contains("/"))
                    continue;

                string fileName = null;

                var objectReplacementFileIndex = zipFile.FindEntry("ObjectReplacements/" + name, true);
                if (objectReplacementFileIndex != -1)
                    fileName = Extraction.GetFileNameFromObjectReplacementFile(zipFile, objectReplacementFileIndex);
                
                using (var zipEntryStream = zipFile.GetInputStream(zipEntry))
                using (var zipEntryMemoryStream = new MemoryStream())
                {
                    zipEntryStream.CopyTo(zipEntryMemoryStream);

                    using (var compoundFile = new CompoundFile(zipEntryMemoryStream))
                        result.Add(Extraction.SaveFromStorageNode(compoundFile.RootStorage, outputFolder, fileName));
                }
            }

            return result;
        }
Exemplo n.º 13
0
        /// <summary>
        /// Extracts all the embedded object from the Office Open XML <paramref name="inputFile"/> to the 
        /// <see cref="outputFolder"/> and returns the files with full path as a list of strings
        /// </summary>
        /// <param name="inputFile">The Office Open XML format file</param>
        /// <param name="embeddingPartString">The folder in the Office Open XML format (zip) file</param>
        /// <param name="outputFolder">The output folder</param>
        /// <returns>List with files or en empty list when there are nog embedded files</returns>
        /// <exception cref="OEFileIsPasswordProtected">Raised when the Microsoft Office file is password protected</exception>
        internal List<string> ExtractFromOfficeOpenXmlFormat(string inputFile, string embeddingPartString, string outputFolder)
        {
            var result = new List<string>();

            using (var inputFileMemoryStream = new MemoryStream(File.ReadAllBytes(inputFile)))
            {
                try
                {
                    var package = Package.Open(inputFileMemoryStream);

                    // Get the embedded files names. 
                    foreach (var packagePart in package.GetParts())
                    {
                        if (packagePart.Uri.ToString().StartsWith(embeddingPartString))
                        {
                            using (var packagePartStream = packagePart.GetStream())
                            using (var packagePartMemoryStream = new MemoryStream())
                            {
                                packagePartStream.CopyTo(packagePartMemoryStream);

                                var fileName = outputFolder +
                                               packagePart.Uri.ToString().Remove(0, embeddingPartString.Length);
                                
                                if (fileName.ToUpperInvariant().Contains("OLEOBJECT"))
                                {
                                    using (var compoundFile = new CompoundFile(packagePartStream))
                                    {
                                        result.Add(Extraction.SaveFromStorageNode(compoundFile.RootStorage, outputFolder));
                                        //result.Add(ExtractFileFromOle10Native(packagePartMemoryStream.ToArray(), outputFolder));
                                    }
                                }
                                else
                                {
                                    fileName = FileManager.FileExistsMakeNew(fileName);
                                    File.WriteAllBytes(fileName, packagePartMemoryStream.ToArray());
                                    result.Add(fileName);
                                }
                            }
                        }
                    }
                    package.Close();

                    return result;
                }
                catch (FileFormatException fileFormatException)
                {
                    if (
                        !fileFormatException.Message.Equals("File contains corrupted data.",
                            StringComparison.InvariantCultureIgnoreCase))
                        return null;

                    try
                    {
                        // When we receive this exception we can have 2 things:
                        // - The file is corrupt
                        // - The file is password protected, in this case the file is saved as a compound file
                        //EncryptedPackage
                        using (var compoundFile = new CompoundFile(inputFileMemoryStream))
                        {
                            if (compoundFile.RootStorage.ExistsStream("EncryptedPackage"))
                                throw new OEFileIsPasswordProtected("The file '" + Path.GetFileName(inputFile) +
                                                                    "' is password protected");
                        }

                    }
                    catch (Exception)
                    {
                        return null;
                    }
                }
            }

            return null;
        }
Exemplo n.º 14
0
        /// <summary>
        /// Returns true when the Word file is password protected
        /// </summary>
        /// <param name="inputFile">The Word file to check</param>
        /// <returns></returns>
        /// <exception cref="OCFileIsCorrupt">Raised when the file is corrupt</exception>
        internal static bool FileIsPasswordProtected(string inputFile)
        {
            try
            {
                using (var compoundFile = new CompoundFile(inputFile))
                {
                    if (compoundFile.RootStorage.ExistsStream("EncryptedPackage")) return true;
                    if (!compoundFile.RootStorage.ExistsStream("WordDocument"))
                        throw new OCFileIsCorrupt("Could not find the WordDocument stream in the file '" +
                                                  compoundFile.FileName + "'");

                    var stream = compoundFile.RootStorage.GetStream("WordDocument") as CFStream;
                    if (stream == null) return false;

                    var bytes = stream.GetData();
                    using (var memoryStream = new MemoryStream(bytes))
                    using (var binaryReader = new BinaryReader(memoryStream))
                    {
                        //http://msdn.microsoft.com/en-us/library/dd944620%28v=office.12%29.aspx
                        // The bit that shows if the file is encrypted is in the 11th and 12th byte so we 
                        // need to skip the first 10 bytes
                        binaryReader.ReadBytes(10);

                        // Now we read the 2 bytes that we need
                        var pnNext = binaryReader.ReadUInt16();
                        //(value & mask) == mask)

                        // The bit that tells us if the file is encrypted
                        return (pnNext & 0x0100) == 0x0100;
                    }
                }
            }
            catch (CFCorruptedFileException)
            {
                throw new OCFileIsCorrupt("The file '" + Path.GetFileName(inputFile) + "' is corrupt");
            }
            catch (CFFileFormatException)
            {
                // It seems the file is just a normal Microsoft Office 2007 and up Open XML file
                return false;
            }
        }
Exemplo n.º 15
0
        /// <summary>
        /// Returns true when the Excel file is password protected
        /// </summary>
        /// <param name="inputFile">The Excel file to check</param>
        /// <returns></returns>
        /// <exception cref="OCFileIsCorrupt">Raised when the file is corrupt</exception>
        internal static bool FileIsPasswordProtected(string inputFile)
        {
            try
            {
                using (var compoundFile = new CompoundFile(inputFile))
                {
                    if (compoundFile.RootStorage.ExistsStream("EncryptedPackage")) return true;
                    if (!compoundFile.RootStorage.ExistsStream("WorkBook"))
                        throw new OCFileIsCorrupt("Could not find the WorkBook stream in the file '" +
                                                  compoundFile.FileName + "'");

                    var stream = compoundFile.RootStorage.GetStream("WorkBook") as CFStream;
                    if (stream == null) return false;

                    var bytes = stream.GetData();
                    using (var memoryStream = new MemoryStream(bytes))
                    using (var binaryReader = new BinaryReader(memoryStream))
                    {
                        // Get the record type, at the beginning of the stream this should always be the BOF
                        var recordType = binaryReader.ReadUInt16();

                        // Something seems to be wrong, we would expect a BOF but for some reason it isn't so stop it
                        if (recordType != 0x809)
                            throw new OCFileIsCorrupt("The file '" + Path.GetFileName(compoundFile.FileName) +
                                                      "' is corrupt");

                        var recordLength = binaryReader.ReadUInt16();
                        binaryReader.BaseStream.Position += recordLength;

                        // Search after the BOF for the FilePass record, this starts with 2F hex
                        recordType = binaryReader.ReadUInt16();
                        if (recordType != 0x2F) return false;
                        binaryReader.ReadUInt16();
                        var filePassRecord = new FilePassRecord(memoryStream);
                        var key = Biff8EncryptionKey.Create(filePassRecord.DocId);
                        return !key.Validate(filePassRecord.SaltData, filePassRecord.SaltHash);
                    }
                }
            }
            catch (OCConfiguration)
            {
                // If we get an OCExcelConfiguration exception it means we have an unknown encryption
                // type so we return a false so that Excel itself can figure out if the file is password
                // protected
                return false;
            }
            catch (CFCorruptedFileException)
            {
                throw new OCFileIsCorrupt("The file '" + Path.GetFileName(inputFile) + "' is corrupt");
            }
            catch (CFFileFormatException)
            {
                // It seems the file is just a normal Microsoft Office 2007 and up Open XML file
                return false;
            }
        }
Exemplo n.º 16
0
        /*
            // Because the properties to be set are known in advance,
            // most of the structures involved can be statically declared
            // to minimize expensive MAPIAllocateBuffer calls.
            SPropValue spvProps[NUM_PROPS] = {0};
            spvProps[p_PR_MESSAGE_CLASS_W].ulPropTag          = PR_MESSAGE_CLASS_W;
            spvProps[p_PR_ICON_INDEX].ulPropTag                 = PR_ICON_INDEX;
            spvProps[p_PR_SUBJECT_W].ulPropTag                = PR_SUBJECT_W;
            spvProps[p_PR_CONVERSATION_TOPIC_W].ulPropTag     = PR_CONVERSATION_TOPIC_W;
            spvProps[p_PR_BODY_W].ulPropTag                   = PR_BODY_W;
            spvProps[p_PR_IMPORTANCE].ulPropTag               = PR_IMPORTANCE;
            spvProps[p_PR_READ_RECEIPT_REQUESTED].ulPropTag   = PR_READ_RECEIPT_REQUESTED;
            spvProps[p_PR_MESSAGE_FLAGS].ulPropTag             = PR_MESSAGE_FLAGS;
            spvProps[p_PR_MSG_EDITOR_FORMAT].ulPropTag         = PR_MSG_EDITOR_FORMAT;
            spvProps[p_PR_MESSAGE_LOCALE_ID].ulPropTag         = PR_MESSAGE_LOCALE_ID;
            spvProps[p_PR_INETMAIL_OVERRIDE_FORMAT].ulPropTag = PR_INETMAIL_OVERRIDE_FORMAT;
            spvProps[p_PR_DELETE_AFTER_SUBMIT].ulPropTag      = PR_DELETE_AFTER_SUBMIT;
            spvProps[p_PR_INTERNET_CPID].ulPropTag            = PR_INTERNET_CPID;
            spvProps[p_PR_CONVERSATION_INDEX].ulPropTag         = PR_CONVERSATION_INDEX;
            spvProps[p_PR_MESSAGE_CLASS_W].Value.lpszW = L"IPM.Note";
            spvProps[p_PR_ICON_INDEX].Value.l = 0x103; // Unsent Mail
            spvProps[p_PR_SUBJECT_W].Value.lpszW = szSubject;
            spvProps[p_PR_CONVERSATION_TOPIC_W].Value.lpszW = szSubject;
            spvProps[p_PR_BODY_W].Value.lpszW = szBody;
            spvProps[p_PR_IMPORTANCE].Value.l = bHighImportance?IMPORTANCE_HIGH:IMPORTANCE_NORMAL;
            spvProps[p_PR_READ_RECEIPT_REQUESTED].Value.b = bReadReceipt?true:false;
            spvProps[p_PR_MESSAGE_FLAGS].Value.l = MSGFLAG_UNSENT;
            spvProps[p_PR_MSG_EDITOR_FORMAT].Value.l = EDITOR_FORMAT_PLAINTEXT;
            spvProps[p_PR_MESSAGE_LOCALE_ID].Value.l = 1033; // (en-us)
            spvProps[p_PR_INETMAIL_OVERRIDE_FORMAT].Value.l = NULL; // Mail system chooses default encoding scheme
            spvProps[p_PR_DELETE_AFTER_SUBMIT].Value.b = bDeleteAfterSubmit?true:false;
            spvProps[p_PR_INTERNET_CPID].Value.l = cpidASCII;

            hRes = BuildConversationIndex(
            &spvProps[p_PR_CONVERSATION_INDEX].Value.bin.cb,
            &spvProps[p_PR_CONVERSATION_INDEX].Value.bin.lpb);
        */
        public void Test()
        {
            using (var stream = File.OpenRead("d:\\message.msg"))
            using (var cf = new CompoundFile(stream))
            {
                var st = cf.RootStorage.GetStream("__properties_version1.0");
                var p = new TopLevelPropertiesStream(st);
                foreach (var child in cf.RootStorage.Children)
                {
                    if (child.IsStream)
                    {
                        var cfStream = child as CFStream;
                        if (cfStream == null) continue;

                        if (cfStream.Name.StartsWith("__substg1.0_"))
                            p.AddProperty(cfStream);
                    }
                }
                var pr = p.Find(m => m.IdAsString == "0E1D");
            }
        }
Exemplo n.º 17
0
        /// <summary>
        /// Returns true when the binary PowerPoint file is password protected
        /// </summary>
        /// <param name="inputFile">The PowerPoint file to check</param>
        /// <returns></returns>
        internal static bool FileIsPasswordProtected(string inputFile)
        {
            try
            {
                using (var compoundFile = new CompoundFile(inputFile))
                {
                    if (compoundFile.RootStorage.ExistsStream("EncryptedPackage")) return true;
                    if (!compoundFile.RootStorage.ExistsStream("Current User")) return false;
                    var stream = compoundFile.RootStorage.GetStream("Current User") as CFStream;
                    if (stream == null) return false;

                    using (var memoryStream = new MemoryStream(stream.GetData()))
                    using (var binaryReader = new BinaryReader(memoryStream))
                    {
                        var verAndInstance = binaryReader.ReadUInt16();
                        // ReSharper disable UnusedVariable
                        // We need to read these fields to get to the correct location in the Current User stream
                        var version = verAndInstance & 0x000FU; // first 4 bit of field verAndInstance
                        var instance = (verAndInstance & 0xFFF0U) >> 4; // last 12 bit of field verAndInstance
                        var typeCode = binaryReader.ReadUInt16();
                        var size = binaryReader.ReadUInt32();
                        var size1 = binaryReader.ReadUInt32();
                        // ReSharper restore UnusedVariable
                        var headerToken = binaryReader.ReadUInt32();

                        switch (headerToken)
                        {
                            // Not encrypted
                            case 0xE391C05F:
                                return false;

                            // Encrypted
                            case 0xF3D1C4DF:
                                return true;

                            default:
                                return false;
                        }
                    }
                }
            }
            catch (CFCorruptedFileException)
            {
                throw new OCFileIsCorrupt("The file '" + Path.GetFileName(inputFile) + "' is corrupt");
            }
            catch (CFFileFormatException)
            {
                // It seems the file is just a normal Microsoft Office 2007 and up Open XML file
                return false;
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// Returns true when the binary PowerPoint file is password protected
        /// </summary>
        /// <param name="compoundFile"></param>
        /// <returns></returns>
        private static bool IsPasswordProtected(CompoundFile compoundFile)
        {
            if (!compoundFile.RootStorage.ExistsStream("Current User")) return false;
            var stream = compoundFile.RootStorage.GetStream("Current User") as CFStream;
            if (stream == null) return false;

            using (var memoryStream = new MemoryStream(stream.GetData()))
            using (var binaryReader = new BinaryReader(memoryStream))
            {
                var verAndInstance = binaryReader.ReadUInt16();
                // ReSharper disable UnusedVariable
                // We need to read these fields to get to the correct location in the Current User stream
                var version = verAndInstance & 0x000FU;         // first 4 bit of field verAndInstance
                var instance = (verAndInstance & 0xFFF0U) >> 4; // last 12 bit of field verAndInstance
                var typeCode = binaryReader.ReadUInt16();
                var size = binaryReader.ReadUInt32();
                var size1 = binaryReader.ReadUInt32();
                // ReSharper restore UnusedVariable
                var headerToken = binaryReader.ReadUInt32();

                switch (headerToken)
                {
                    // Not encrypted
                    case 0xE391C05F:
                        return false;

                    // Encrypted
                    case 0xF3D1C4DF:
                        return true;

                    default:
                        return false;
                }
            }
        }