Ejemplo n.º 1
0
 internal static Stream CreateDecoderStream(Stream inStream, long startPos, long[] packSizes, CFolder folderInfo, IPasswordProvider pass)
 {
     int num2;
     int num3;
     if (!folderInfo.CheckStructure())
     {
         throw new NotSupportedException("Unsupported stream binding structure.");
     }
     Stream[] packStreams = new Stream[folderInfo.PackStreams.Count];
     for (int i = 0; i < folderInfo.PackStreams.Count; i++)
     {
         packStreams[i] = new ReadOnlySubStream(inStream, new long?(startPos), packSizes[i]);
         startPos += packSizes[i];
     }
     Stream[] outStreams = new Stream[folderInfo.UnpackSizes.Count];
     FindPrimaryOutStreamIndex(folderInfo, out num2, out num3);
     return CreateDecoderStream(packStreams, packSizes, outStreams, folderInfo, num2, pass);
 }
Ejemplo n.º 2
0
        internal static Stream CreateDecoderStream(Stream inStream, long startPos, long[] packSizes, CFolder folderInfo,
            IPasswordProvider pass)
        {
            if (!folderInfo.CheckStructure())
                throw new NotSupportedException("Unsupported stream binding structure.");

            Stream[] inStreams = new Stream[folderInfo.PackStreams.Count];
            for (int j = 0; j < folderInfo.PackStreams.Count; j++)
            {
                inStreams[j] = new ReadOnlySubStream(inStream, startPos, packSizes[j]);
                startPos += packSizes[j];
            }

            Stream[] outStreams = new Stream[folderInfo.UnpackSizes.Count];

            int primaryCoderIndex, primaryOutStreamIndex;
            FindPrimaryOutStreamIndex(folderInfo, out primaryCoderIndex, out primaryOutStreamIndex);
            return CreateDecoderStream(inStreams, packSizes, outStreams, folderInfo, primaryCoderIndex, pass);
        }
Ejemplo n.º 3
0
        protected Stream GetCryptoStream(Stream plainStream)
        {
            if ((Header.CompressedSize == 0)
#if !PORTABLE && !NETFX_CORE
 && ((Header.PkwareTraditionalEncryptionData != null)
                    || (Header.WinzipAesEncryptionData != null)))
#else 
                && (Header.PkwareTraditionalEncryptionData != null))
#endif
            {
                throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
            }
            if ((Header.CompressedSize == 0)
                && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
            {
                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close    
            }
            else
            {
                plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
            }
            if (Header.PkwareTraditionalEncryptionData != null)
            {
                return new PkwareTraditionalCryptoStream(plainStream, Header.PkwareTraditionalEncryptionData,
                                                         CryptoMode.Decrypt);
            }
#if !PORTABLE && !NETFX_CORE
            if (Header.WinzipAesEncryptionData != null)
            {
                //only read 10 less because the last ten are auth bytes
                return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10);
            }
#endif
            return plainStream;
        }
Ejemplo n.º 4
0
 private RarHeader ReadNextHeader(Stream stream)
 {
     MarkingBinaryReader reader = new MarkingBinaryReader(stream);
     RarHeader header = RarHeader.Create(reader);
     if (header == null)
     {
         return null;
     }
     switch (header.HeaderType)
     {
         case HeaderType.ArchiveHeader:
             {
                 return header.PromoteHeader<ArchiveHeader>(reader);
             }
         case HeaderType.MarkHeader:
             {
                 return header.PromoteHeader<MarkHeader>(reader);
             }
         case HeaderType.NewSubHeader:
             {
                 FileHeader fh = header.PromoteHeader<FileHeader>(reader);
                 switch (StreamingMode)
                 {
                     case StreamingMode.Seekable:
                         {
                             fh.DataStartPosition = reader.BaseStream.Position;
                             reader.BaseStream.Position += fh.CompressedSize;
                         }
                         break;
                     case StreamingMode.Streaming:
                         {
                             //skip the data because it's useless?
                             reader.BaseStream.Skip(fh.CompressedSize);
                         }
                         break;
                     default:
                         {
                             throw new InvalidFormatException("Invalid StreamingMode");
                         }
                 }
                 return fh;
             }
         case HeaderType.FileHeader:
             {
                 FileHeader fh = header.PromoteHeader<FileHeader>(reader);
                 switch (StreamingMode)
                 {
                     case StreamingMode.Seekable:
                         {
                             fh.DataStartPosition = reader.BaseStream.Position;
                             reader.BaseStream.Position += fh.CompressedSize;
                         }
                         break;
                     case StreamingMode.Streaming:
                         {
                             ReadOnlySubStream ms
                                 = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
                             fh.PackedStream = ms;
                         }
                         break;
                     default:
                         {
                             throw new InvalidFormatException("Invalid StreamingMode");
                         }
                 }
                 return fh;
             }
         case HeaderType.EndArchiveHeader:
             {
                 return header.PromoteHeader<EndArchiveHeader>(reader);
             }
         default:
             {
                 throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
             }
     }
 }
Ejemplo n.º 5
0
        private RarHeader ReadNextHeader(Stream stream)
        {
            #if !NO_CRYPTO
            var reader = new RarCryptoBinaryReader(stream, Password);

            if (IsEncrypted)
            {
                if (Password == null)
                {
                    throw new CryptographicException("Encrypted Rar archive has no password specified.");
                }
                reader.SkipQueue();
                byte[] salt = reader.ReadBytes(8);
                reader.InitializeAes(salt);
            }
            #else
            var reader = new MarkingBinaryReader(stream);

            #endif

            RarHeader header = RarHeader.Create(reader);
            if (header == null)
            {
                return null;
            }
            switch (header.HeaderType)
            {
                case HeaderType.ArchiveHeader:
                    {
                        var ah = header.PromoteHeader<ArchiveHeader>(reader);
                        IsEncrypted = ah.HasPassword;
                        return ah;
                    }
                case HeaderType.MarkHeader:
                    {
                        return header.PromoteHeader<MarkHeader>(reader);
                    }

                case HeaderType.ProtectHeader:
                    {
                        ProtectHeader ph = header.PromoteHeader<ProtectHeader>(reader);

                        // skip the recovery record data, we do not use it.
                        switch (StreamingMode)
                        {
                            case StreamingMode.Seekable:
                                {
                                    reader.BaseStream.Position += ph.DataSize;
                                }
                                break;
                            case StreamingMode.Streaming:
                                {
                                    reader.BaseStream.Skip(ph.DataSize);
                                }
                                break;
                            default:
                                {
                                    throw new InvalidFormatException("Invalid StreamingMode");
                                }
                        }

                        return ph;
                    }

                case HeaderType.NewSubHeader:
                    {
                        FileHeader fh = header.PromoteHeader<FileHeader>(reader);
                        switch (StreamingMode)
                        {
                            case StreamingMode.Seekable:
                                {
                                    fh.DataStartPosition = reader.BaseStream.Position;
                                    reader.BaseStream.Position += fh.CompressedSize;
                                }
                                break;
                            case StreamingMode.Streaming:
                                {
                                    //skip the data because it's useless?
                                    reader.BaseStream.Skip(fh.CompressedSize);
                                }
                                break;
                            default:
                                {
                                    throw new InvalidFormatException("Invalid StreamingMode");
                                }
                        }
                        return fh;
                    }
                case HeaderType.FileHeader:
                    {
                        FileHeader fh = header.PromoteHeader<FileHeader>(reader);
                        switch (StreamingMode)
                        {
                            case StreamingMode.Seekable:
                                {
                                    fh.DataStartPosition = reader.BaseStream.Position;
                                    reader.BaseStream.Position += fh.CompressedSize;
                                }
                                break;
                            case StreamingMode.Streaming:
                                {
                                    var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
                                    if (fh.Salt == null)
                                    {
                                        fh.PackedStream = ms;
                                    }
                                    else
                                    {
            #if !NO_CRYPTO
                                        fh.PackedStream = new RarCryptoWrapper(ms, Password,  fh.Salt);
            #else
                                        throw new NotSupportedException("RarCrypto not supported");
            #endif
                                    }
                                }
                                break;
                            default:
                                {
                                    throw new InvalidFormatException("Invalid StreamingMode");
                                }
                        }
                        return fh;
                    }
                case HeaderType.EndArchiveHeader:
                    {
                        return header.PromoteHeader<EndArchiveHeader>(reader);
                    }
                default:
                    {
                        throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
                    }
            }
        }
Ejemplo n.º 6
0
        private RarHeader ReadNextHeader(Stream stream)
        {
            FileHeader header4;
            RarCryptoBinaryReader reader = new RarCryptoBinaryReader(stream, this.Password);
            if (this.IsEncrypted)
            {
                if (this.Password == null)
                {
                    throw new CryptographicException("Encrypted Rar archive has no password specified.");
                }
                reader.SkipQueue();
                byte[] salt = reader.ReadBytes(8);
                reader.InitializeAes(salt);
            }
            RarHeader header = RarHeader.Create(reader);
            if (header == null)
            {
                return null;
            }
            switch (header.HeaderType)
            {
                case HeaderType.MarkHeader:
                    return header.PromoteHeader<MarkHeader>(reader);

                case HeaderType.ArchiveHeader:
                {
                    ArchiveHeader header2 = header.PromoteHeader<ArchiveHeader>(reader);
                    this.IsEncrypted = header2.HasPassword;
                    return header2;
                }
                case HeaderType.FileHeader:
                    header4 = header.PromoteHeader<FileHeader>(reader);
                    switch (this.StreamingMode)
                    {
                        case SharpCompress.IO.StreamingMode.Streaming:
                        {
                            ReadOnlySubStream actualStream = new ReadOnlySubStream(reader.BaseStream, header4.CompressedSize);
                            if (header4.Salt == null)
                            {
                                header4.PackedStream = actualStream;
                                return header4;
                            }
                            header4.PackedStream = new RarCryptoWrapper(actualStream, this.Password, header4.Salt);
                            return header4;
                        }
                        case SharpCompress.IO.StreamingMode.Seekable:
                        {
                            header4.DataStartPosition = reader.BaseStream.Position;
                            Stream baseStream = reader.BaseStream;
                            baseStream.Position += header4.CompressedSize;
                            return header4;
                        }
                    }
                    throw new InvalidFormatException("Invalid StreamingMode");

                case HeaderType.ProtectHeader:
                {
                    ProtectHeader header3 = header.PromoteHeader<ProtectHeader>(reader);
                    switch (this.StreamingMode)
                    {
                        case SharpCompress.IO.StreamingMode.Streaming:
                            Utility.Skip(reader.BaseStream, (long) header3.DataSize);
                            return header3;

                        case SharpCompress.IO.StreamingMode.Seekable:
                        {
                            Stream stream1 = reader.BaseStream;
                            stream1.Position += header3.DataSize;
                            return header3;
                        }
                    }
                    throw new InvalidFormatException("Invalid StreamingMode");
                }
                case HeaderType.NewSubHeader:
                    header4 = header.PromoteHeader<FileHeader>(reader);
                    switch (this.StreamingMode)
                    {
                        case SharpCompress.IO.StreamingMode.Streaming:
                            Utility.Skip(reader.BaseStream, header4.CompressedSize);
                            return header4;

                        case SharpCompress.IO.StreamingMode.Seekable:
                        {
                            header4.DataStartPosition = reader.BaseStream.Position;
                            Stream stream3 = reader.BaseStream;
                            stream3.Position += header4.CompressedSize;
                            return header4;
                        }
                    }
                    throw new InvalidFormatException("Invalid StreamingMode");

                case HeaderType.EndArchiveHeader:
                    return header.PromoteHeader<EndArchiveHeader>(reader);
            }
            throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
        }
Ejemplo n.º 7
0
        private RarHeader ReadNextHeader(Stream stream)
        {
            #if PORTABLE
            var reader = new MarkingBinaryReader(stream);
            #else
            var reader = new RarCryptoBinaryReader(stream, Password);

            if (IsEncrypted)
            {
                reader.SkipQueue();
                byte[] salt = reader.ReadBytes(8);
                reader.InitializeAes(salt);
            }
            #endif

            RarHeader header = RarHeader.Create(reader);
            if (header == null)
            {
                return null;
            }
            switch (header.HeaderType)
            {
                case HeaderType.ArchiveHeader:
                    {
                        var ah = header.PromoteHeader<ArchiveHeader>(reader);
                        IsEncrypted = ah.HasPassword;
                        return ah;
                    }
                case HeaderType.MarkHeader:
                    {
                        return header.PromoteHeader<MarkHeader>(reader);
                    }
                case HeaderType.NewSubHeader:
                    {
                        FileHeader fh = header.PromoteHeader<FileHeader>(reader);
                        switch (StreamingMode)
                        {
                            case StreamingMode.Seekable:
                                {
                                    fh.DataStartPosition = reader.BaseStream.Position;
                                    reader.BaseStream.Position += fh.CompressedSize;
                                }
                                break;
                            case StreamingMode.Streaming:
                                {
                                    //skip the data because it's useless?
                                    reader.BaseStream.Skip(fh.CompressedSize);
                                }
                                break;
                            default:
                                {
                                    throw new InvalidFormatException("Invalid StreamingMode");
                                }
                        }
                        return fh;
                    }
                case HeaderType.FileHeader:
                    {
                        FileHeader fh = header.PromoteHeader<FileHeader>(reader);
                        switch (StreamingMode)
                        {
                            case StreamingMode.Seekable:
                                {
                                    fh.DataStartPosition = reader.BaseStream.Position;
                                    reader.BaseStream.Position += fh.CompressedSize;
                                }
                                break;
                            case StreamingMode.Streaming:
                                {
                                    var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
                                    if (fh.Salt == null)
                                    {
                                        fh.PackedStream = ms;
                                    }
                                    else
                                    {
            #if PORTABLE
                                        throw new NotSupportedException("Encrypted Rar files aren't supported in portable distro.");
            #else
                                        fh.PackedStream = new RarCryptoWrapper(ms, Password,  fh.Salt);
            #endif
                                    }
                                }
                                break;
                            default:
                                {
                                    throw new InvalidFormatException("Invalid StreamingMode");
                                }
                        }
                        return fh;
                    }
                case HeaderType.EndArchiveHeader:
                    {
                        return header.PromoteHeader<EndArchiveHeader>(reader);
                    }
                default:
                    {
                        throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
                    }
            }
        }