예제 #1
0
        protected override void ReadFinish(MarkingBinaryReader reader)
        {
            var cryptVersion = reader.ReadRarVIntUInt32();

            if (cryptVersion > CRYPT_VERSION)
            {
                //error?
                return;
            }
            var encryptionFlags = reader.ReadRarVIntUInt32();

            _usePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
            _lg2Count    = reader.ReadRarVIntByte(1);


            //UsePswCheck = HasHeaderFlag(EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
            if (_lg2Count > CRYPT5_KDF_LG2_COUNT_MAX)
            {
                //error?
                return;
            }

            _salt = reader.ReadBytes(SIZE_SALT50);
            if (_usePswCheck)
            {
                _pswCheck    = reader.ReadBytes(SIZE_PSWCHECK);
                _pswCheckCsm = reader.ReadBytes(SIZE_PSWCHECK_CSUM);
            }
        }
예제 #2
0
        private void ReadLocator(MarkingBinaryReader reader)
        {
            var size = reader.ReadRarVIntUInt16();
            var type = reader.ReadRarVIntUInt16();

            if (type != 1)
            {
                throw new InvalidFormatException("expected locator record");
            }

            var          flags = reader.ReadRarVIntUInt16();
            const ushort hasQuickOpenOffset = 0x01;
            const ushort hasRecoveryOffset  = 0x02;
            ulong        quickOpenOffset    = 0;

            if ((flags & hasQuickOpenOffset) == hasQuickOpenOffset)
            {
                quickOpenOffset = reader.ReadRarVInt();
            }
            ulong recoveryOffset = 0;

            if ((flags & hasRecoveryOffset) == hasRecoveryOffset)
            {
                recoveryOffset = reader.ReadRarVInt();
            }
        }
예제 #3
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     UnpackVersion = reader.ReadByte();
     Method        = reader.ReadByte();
     AVVersion     = reader.ReadByte();
     AVInfoCRC     = reader.ReadInt32();
 }
예제 #4
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     Version     = reader.ReadByte();
     RecSectors  = reader.ReadUInt16();
     TotalBlocks = reader.ReadUInt32();
     Mark        = reader.ReadBytes(8);
 }
예제 #5
0
 protected override void ReadFinish(MarkingBinaryReader reader)
 {
     UnpackVersion = reader.ReadByte();
     Method        = reader.ReadByte();
     AvVersion     = reader.ReadByte();
     AvInfoCrc     = reader.ReadInt32();
 }
예제 #6
0
 protected override void ReadFinish(MarkingBinaryReader reader)
 {
     if (IsRar5)
     {
         Flags = reader.ReadRarVIntUInt16();
         if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
         {
             VolumeNumber = (int)reader.ReadRarVIntUInt32();
         }
         // later: we may have a locator record if we need it
         //if (ExtraSize != 0) {
         //    ReadLocator(reader);
         //}
     }
     else
     {
         Flags     = HeaderFlags;
         HighPosAv = reader.ReadInt16();
         PosAv     = reader.ReadInt32();
         if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
         {
             EncryptionVersion = reader.ReadByte();
         }
     }
 }
예제 #7
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     UnpSize    = reader.ReadInt16();
     UnpVersion = reader.ReadByte();
     UnpMethod  = reader.ReadByte();
     CommCRC    = reader.ReadInt16();
 }
예제 #8
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     ArchiveHeaderFlag = (ArchiveFlags)reader.ReadVInt();
     if (ArchiveHeaderFlag.HasFlag(ArchiveFlags.VolumeNumberFieldIsPresented))
     {
         VolumeNumber = reader.ReadVInt();
     }
 }
예제 #9
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     HighPosAv = reader.ReadInt16();
     PosAv     = reader.ReadInt32();
     if (ArchiveHeaderFlags.HasFlag(ArchiveFlags.ENCRYPTVER))
     {
         EncryptionVersion = reader.ReadByte();
     }
 }
        internal static IEnumerable <ZipHeader> ReadHeaderNonseekable(Stream stream)
        {
            while (true)
            {
                ZipHeader header = null;
                try
                {
                    MarkingBinaryReader reader = new MarkingBinaryReader(stream);

                    uint headerBytes = reader.ReadUInt32();
                    switch (headerBytes)
                    {
                    case ENTRY_HEADER_BYTES:
                    {
                        var entry = new LocalEntryHeader();
                        entry.Read(reader);
                        if (entry.CompressedSize > 0)
                        {
                            entry.PackedStream = new ReadOnlySubStream(stream, entry.CompressedSize, true);
                        }
                        header = entry;
                    }
                    break;

                    case DIRECTORY_START_HEADER_BYTES:
                    {
                        var entry = new DirectoryEntryHeader();
                        entry.Read(reader);
                        header = entry;
                    }
                    break;

                    case POST_DATA_DESCRIPTOR:
                    case DIGITAL_SIGNATURE:
                        break;

                    case DIRECTORY_END_HEADER_BYTES:
                    {
                        var entry = new DirectoryEndHeader();
                        entry.Read(reader);
                        header = entry;
                    }
                    break;

                    case ZIP64_END_OF_CENTRAL_DIRECTORY:
                    default:
                        break;
                    }
                }
                catch
                {
                    header = null;
                }
                yield return(header);
            }
        }
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     if (EndArchiveFlags.HasFlag(EndArchiveFlags.EARC_DATACRC))
     {
         ArchiveCRC = reader.ReadInt32();
     }
     if (EndArchiveFlags.HasFlag(EndArchiveFlags.EARC_VOLNUMBER))
     {
         VolumeNumber = reader.ReadInt16();
     }
 }
예제 #12
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     if (this.EndArchiveFlags_HasFlag(SharpCompress.Common.Rar.Headers.EndArchiveFlags.EARC_DATACRC))
     {
         this.ArchiveCRC = new int?(reader.ReadInt32());
     }
     if (this.EndArchiveFlags_HasFlag(SharpCompress.Common.Rar.Headers.EndArchiveFlags.EARC_VOLNUMBER))
     {
         this.VolumeNumber = new short?(reader.ReadInt16());
     }
 }
예제 #13
0
 protected override void ReadFinish(MarkingBinaryReader reader)
 {
     if (IsRar5)
     {
         ReadFromReaderV5(reader);
     }
     else
     {
         ReadFromReaderV4(reader);
     }
 }
예제 #14
0
 private static DateTime ReadExtendedTimeV5(MarkingBinaryReader reader, bool isWindowsTime)
 {
     if (isWindowsTime)
     {
         return(DateTime.FromFileTime(reader.ReadInt64()));
     }
     else
     {
         return(Utility.UnixTimeToDateTime(reader.ReadUInt32()));
     }
 }
예제 #15
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     EncriptionVersion = reader.ReadVInt();
     EncriptionFlags   = reader.ReadVInt();
     KdfCount          = reader.ReadByte();
     Salt = reader.ReadBytes(16);
     if (PasswordCheckDataIsPresent)
     {
         CheckValue = reader.ReadBytes(12);
     }
 }
예제 #16
0
 protected virtual void ReadFromReader(MarkingBinaryReader reader)
 {
     HeadCRC    = reader.ReadInt16();
     HeaderType = (HeaderType)(int)(reader.ReadByte() & 0xff);
     Flags      = reader.ReadInt16();
     HeaderSize = reader.ReadInt16();
     if (FlagUtility.HasFlag(Flags, LONG_BLOCK))
     {
         AdditionalSize = reader.ReadUInt32();
     }
 }
예제 #17
0
 internal override void Read(MarkingBinaryReader reader)
 {
     VolumeNumber                       = reader.ReadUInt16();
     FirstVolumeWithDirectory           = reader.ReadUInt16();
     TotalNumberOfEntriesInDisk         = reader.ReadUInt16();
     TotalNumberOfEntries               = reader.ReadUInt16();
     DirectorySize                      = reader.ReadUInt32();
     DirectoryStartOffsetRelativeToDisk = reader.ReadUInt32();
     CommentLength                      = reader.ReadUInt16();
     Comment = reader.ReadBytes(CommentLength);
 }
예제 #18
0
 protected virtual void ReadFromReader(MarkingBinaryReader reader)
 {
     this.HeadCRC    = reader.ReadInt16();
     this.HeaderType = ((SharpCompress.Common.Rar.Headers.HeaderType)reader.ReadByte()) & ((SharpCompress.Common.Rar.Headers.HeaderType) 0xff);
     this.Flags      = reader.ReadInt16();
     this.HeaderSize = reader.ReadInt16();
     if (FlagUtility.HasFlag((short)this.Flags, (short)-32768))
     {
         this.AdditionalSize = reader.ReadUInt32();
     }
 }
예제 #19
0
 internal static RarHeader Create(MarkingBinaryReader reader)
 {
     try
     {
         RarHeader header = new RarHeader();
         reader.Mark();
         header.ReadFromReader(reader);
         header.ReadBytes += reader.CurrentReadByteCount;
         return(header);
     }
     catch (EndOfStreamException)
     {
         return(null);
     }
 }
예제 #20
0
        internal T PromoteHeader <T>(MarkingBinaryReader reader) where T : RarHeader, new()
        {
            T local = Activator.CreateInstance <T>();

            local.FillBase(this);
            reader.Mark();
            local.ReadFromReader(reader);
            local.ReadBytes += reader.CurrentReadByteCount;
            int count = local.HeaderSize - ((int)local.ReadBytes);

            if (count > 0)
            {
                reader.ReadBytes(count);
            }
            return(local);
        }
        internal override void Read(MarkingBinaryReader reader)
        {
            Version           = reader.ReadUInt16();
            Flags             = reader.ReadUInt16();
            CompressionMethod = reader.ReadUInt16();
            LastModifiedTime  = reader.ReadUInt16();
            LastModifiedDate  = reader.ReadUInt16();
            Crc              = reader.ReadUInt32();
            CompressedSize   = reader.ReadUInt32();
            UncompressedSize = reader.ReadUInt32();
            ushort nameLength  = reader.ReadUInt16();
            ushort extraLength = reader.ReadUInt16();

            byte[] name = reader.ReadBytes(nameLength);
            Extra = reader.ReadBytes(extraLength);
            Name  = DefaultEncoding.GetString(name, 0, name.Length);
        }
예제 #22
0
 protected override void ReadFinish(MarkingBinaryReader reader)
 {
     if (IsRar5)
     {
         Flags = reader.ReadRarVIntUInt16();
     }
     else
     {
         Flags = HeaderFlags;
         if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
         {
             ArchiveCrc = reader.ReadInt32();
         }
         if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
         {
             VolumeNumber = reader.ReadInt16();
         }
     }
 }
예제 #23
0
        internal T PromoteHeader <T>(MarkingBinaryReader reader)
            where T : RarHeader, new()
        {
            T header = new T();

            header.FillBase(this);

            reader.Mark();
            header.ReadFromReader(reader);
            header.ReadBytes += reader.CurrentReadByteCount;

            int headerSizeDiff = header.HeaderSize - (int)header.ReadBytes;

            if (headerSizeDiff > 0)
            {
                reader.ReadBytes(headerSizeDiff);
            }

            return(header);
        }
예제 #24
0
        internal override void Read(MarkingBinaryReader reader)
        {
            Version = reader.ReadUInt16();
            VersionNeededToExtract = reader.ReadUInt16();
            Flags             = reader.ReadUInt16();
            CompressionMethod = reader.ReadUInt16();
            LastModifiedTime  = reader.ReadUInt16();
            LastModifiedDate  = reader.ReadUInt16();
            Crc              = reader.ReadUInt32();
            CompressedSize   = reader.ReadUInt32();
            UncompressedSize = reader.ReadUInt32();
            ushort nameLength    = reader.ReadUInt16();
            ushort extraLength   = reader.ReadUInt16();
            ushort commentLength = reader.ReadUInt16();

            DiskNumberStart             = reader.ReadUInt16();
            InternalFileAttributes      = reader.ReadUInt16();
            ExternalFileAttributes      = reader.ReadUInt32();
            RelativeOffsetOfEntryHeader = reader.ReadUInt32();

            Name    = DefaultEncoding.GetString(reader.ReadBytes(nameLength));
            Extra   = reader.ReadBytes(extraLength);
            Comment = reader.ReadBytes(commentLength);
        }
예제 #25
0
 protected virtual void PostReadingBytes(MarkingBinaryReader reader)
 {
 }
예제 #26
0
        private static DateTime?ProcessExtendedTime(ushort extendedFlags, DateTime?time, MarkingBinaryReader reader, int i)
        {
            uint rmode = (uint)extendedFlags >> (3 - i) * 4;

            if ((rmode & 8) == 0)
            {
                return(null);
            }
            if (i != 0)
            {
                uint DosTime = reader.ReadUInt32();
                time = Utility.DosDateToDateTime(DosTime);
            }
            if ((rmode & 4) == 0)
            {
                time = time.Value.AddSeconds(1);
            }
            uint nanosecondHundreds = 0;
            int  count = (int)rmode & 3;

            for (int j = 0; j < count; j++)
            {
                byte b = reader.ReadByte();
                nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
            }
            //10^-7 to 10^-3
            return(time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4)));
        }
예제 #27
0
        protected override void ReadFromReader(MarkingBinaryReader reader)
        {
            uint lowUncompressedSize = reader.ReadUInt32();

            HostOS = (HostOS)(int)reader.ReadByte();

            FileCRC = reader.ReadUInt32();

            FileLastModifiedTime = Utility.DosDateToDateTime(reader.ReadInt32());

            RarVersion    = reader.ReadByte();
            PackingMethod = reader.ReadByte();

            short nameSize = reader.ReadInt16();

            FileAttributes = reader.ReadInt32();

            uint highCompressedSize    = 0;
            uint highUncompressedkSize = 0;

            if (FileFlags.HasFlag(FileFlags.LARGE))
            {
                highCompressedSize    = reader.ReadUInt32();
                highUncompressedkSize = reader.ReadUInt32();
            }
            else
            {
                if (lowUncompressedSize == 0xffffffff)
                {
                    lowUncompressedSize   = 0xffffffff;
                    highUncompressedkSize = int.MaxValue;
                }
            }
            CompressedSize   = UInt32To64(highCompressedSize, AdditionalSize);
            UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);

            nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;

            byte[] fileNameBytes = reader.ReadBytes(nameSize);

            switch (HeaderType)
            {
            case HeaderType.FileHeader:
            {
                if (FileFlags.HasFlag(FileFlags.UNICODE))
                {
                    int length = 0;
                    while (length < fileNameBytes.Length &&
                           fileNameBytes[length] != 0)
                    {
                        length++;
                    }
                    if (length != nameSize)
                    {
                        length++;
                        FileName = FileNameDecoder.Decode(fileNameBytes, length);
                    }
                    else
                    {
                        FileName = DecodeDefault(fileNameBytes);
                    }
                }
                else
                {
                    FileName = DecodeDefault(fileNameBytes);
                }
                FileName = ConvertPath(FileName, HostOS);
            }
            break;

            case HeaderType.NewSubHeader:
            {
                int datasize = HeaderSize - NEWLHD_SIZE - nameSize;
                if (FileFlags.HasFlag(FileFlags.SALT))
                {
                    datasize -= SALT_SIZE;
                }
                if (datasize > 0)
                {
                    SubData = reader.ReadBytes(datasize);
                }

                if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
                {
                    RecoverySectors = SubData[8] + (SubData[9] << 8)
                                      + (SubData[10] << 16) + (SubData[11] << 24);
                }
            }
            break;
            }

            if (FileFlags.HasFlag(FileFlags.SALT))
            {
                Salt = reader.ReadBytes(SALT_SIZE);
            }
            if (FileFlags.HasFlag(FileFlags.EXTTIME))
            {
                ushort extendedFlags = reader.ReadUInt16();
                FileLastModifiedTime = ProcessExtendedTime(extendedFlags, FileLastModifiedTime, reader, 0);
                FileCreatedTime      = ProcessExtendedTime(extendedFlags, null, reader, 1);
                FileLastAccessedTime = ProcessExtendedTime(extendedFlags, null, reader, 2);
                FileArchivedTime     = ProcessExtendedTime(extendedFlags, null, reader, 3);
            }
        }
예제 #28
0
 protected override void ReadFromReader(MarkingBinaryReader reader)
 {
     CreationTime = reader.ReadInt32();
     ArcNameSize  = reader.ReadInt16();
     UserNameSize = reader.ReadInt16();
 }
예제 #29
0
        private RarHeader ReadNextHeader(Stream stream)
        {
#if !NO_CRYPTO
            var reader = new RarCryptoBinaryReader(stream, Options.Password);

            if (IsEncrypted)
            {
                if (Options.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, Options.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);
            }
            }
        }
예제 #30
0
        protected override void ReadFromReader(MarkingBinaryReader reader)
        {
            uint y = reader.ReadUInt32();

            this.HostOS  = (SharpCompress.Common.Rar.Headers.HostOS)reader.ReadByte();
            this.FileCRC = reader.ReadUInt32();
            this.FileLastModifiedTime = new DateTime?(Utility.DosDateToDateTime(reader.ReadInt32()));
            this.RarVersion           = reader.ReadByte();
            this.PackingMethod        = reader.ReadByte();
            short count = reader.ReadInt16();

            this.FileAttributes = reader.ReadInt32();
            uint x    = 0;
            uint num4 = 0;

            if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.LARGE))
            {
                x    = reader.ReadUInt32();
                num4 = reader.ReadUInt32();
            }
            else if (y == uint.MaxValue)
            {
                y    = uint.MaxValue;
                num4 = 0x7fffffff;
            }
            this.CompressedSize   = this.UInt32To64(x, base.AdditionalSize);
            this.UncompressedSize = this.UInt32To64(num4, y);
            count = (count > 0x1000) ? ((short)0x1000) : count;
            byte[] name = reader.ReadBytes(count);
            switch (base.HeaderType)
            {
            case HeaderType.FileHeader:
                if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.UNICODE))
                {
                    int index = 0;
                    while ((index < name.Length) && (name[index] != 0))
                    {
                        index++;
                    }
                    if (index != count)
                    {
                        index++;
                        this.FileName = FileNameDecoder.Decode(name, index);
                    }
                    else
                    {
                        this.FileName = this.DecodeDefault(name);
                    }
                }
                else
                {
                    this.FileName = this.DecodeDefault(name);
                }
                this.FileName = ConvertPath(this.FileName, this.HostOS);
                break;

            case HeaderType.NewSubHeader:
            {
                int num6 = (base.HeaderSize - 0x20) - count;
                if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.SALT))
                {
                    num6 -= 8;
                }
                if (num6 > 0)
                {
                    this.SubData = reader.ReadBytes(num6);
                }
                if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(name))
                {
                    this.RecoverySectors = ((this.SubData[8] + (this.SubData[9] << 8)) + (this.SubData[10] << 0x10)) + (this.SubData[11] << 0x18);
                }
                break;
            }
            }
            if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.SALT))
            {
                this.Salt = reader.ReadBytes(8);
            }
            if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.EXTTIME) && ((base.ReadBytes + reader.CurrentReadByteCount) <= (base.HeaderSize - 2)))
            {
                ushort extendedFlags = reader.ReadUInt16();
                this.FileLastModifiedTime = ProcessExtendedTime(extendedFlags, this.FileLastModifiedTime, reader, 0);
                DateTime?time = null;
                this.FileCreatedTime = ProcessExtendedTime(extendedFlags, time, reader, 1);
                time = null;
                this.FileLastAccessedTime = ProcessExtendedTime(extendedFlags, time, reader, 2);
                this.FileArchivedTime     = ProcessExtendedTime(extendedFlags, null, reader, 3);
            }
        }