Jeu Videz votre presse-papier - Page 1074

Pen^2 (./32190) :
https://www.youtube.com/watch?v=QsWht21hvHc
https://www.youtube.com/watch?v=LEQt2QPvTT8

using System;
using System.IO;
using System.IO.Compression;

namespace CASC.NET.IO.Streams.Compression
{
    public sealed class MemoryBackedDeflateStream : DeflateStream
    {
        private static byte[] DUMMY_BUFFER = new byte[0x2000];

        public override long Position { get; set; }

        public MemoryBackedDeflateStream(Stream stream, CompressionMode mode) : base(stream, mode)
        {
        }

        public MemoryBackedDeflateStream(Stream stream, CompressionMode mode, bool leaveOpen) : base(stream, mode, leaveOpen)
        {
        }

        public MemoryBackedDeflateStream(Stream stream, CompressionLevel compressionLevel) : base(stream, compressionLevel)
        {
        }

        public MemoryBackedDeflateStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen) : base(stream, compressionLevel, leaveOpen)
        {
        }

        public override int Read(byte[] array, int offset, int count)
        {
            var readCount = base.Read(array, offset, count);
            Position += readCount;
            return readCount;
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            if (origin != SeekOrigin.Current)
                throw new ArgumentOutOfRangeException(nameof(origin));

            var readCount = 0L;
            while (readCount != offset)
            {
                var chunkSize = Read(DUMMY_BUFFER, 0, (int) Math.Min(DUMMY_BUFFER.Length, offset));
                if (chunkSize == 0)
                    break;

                readCount += chunkSize;
            }

            return readCount;
        }
    }
}

squalyl (./32198) :
https://blog.quarkslab.com/flash-dumping-part-i.html

Donc le CROUS à Rennes surveille oklm les étudiants dans leur chambre, sans les prévenir, avec des capteurs cachés sur leur lit... pic.twitter.com/2HwGK1U0mE

— Jeanne ? (@jeanne_la_rouge) September 6, 2017

using System;
using System.IO;
using System.Linq;

namespace CASC.NET.IO.Streams
{
    public sealed class BLTE : DelegatingStream
    {
        private Chunk[] Chunks { get; }
        private int _chunkItr = 0;

        private EndianBinaryReader _underlyingStream;

        public BLTE(Stream underlyingStream) : base(underlyingStream)
        {
            _underlyingStream = new EndianBinaryReader(BaseStream);

            var signature = _underlyingStream.ReadInt32();
            if (signature != 0x45544c42)
                throw new Exception("Provided stream is not a BLTE archive.");

            _underlyingStream.Endianness = Endianness.Big;
            var headerSize = _underlyingStream.ReadInt32();

            if (headerSize > 0)
            {
                _chunkItr = 0;

                var flagsCount = _underlyingStream.ReadBytes(4);
                // var flags = flagsCount[3];
                var chunkCount = (flagsCount[1] << 16) | (flagsCount[2] << 8) | flagsCount[3];

                Chunks = new Chunk[chunkCount];
                for (var i = 0; i < chunkCount; ++i)
                {
                    var compressedSize = _underlyingStream.ReadUInt32();
                    var decompressedSize = _underlyingStream.ReadUInt32();
                    Chunks[i] = new Chunk
                    {
                        CompressedSize = compressedSize - 1,
                        DecompressedSize = decompressedSize
                    };

                    // Skip checksums
                    _underlyingStream.BaseStream.Seek(16, SeekOrigin.Current);
                }
            }
            else
                _chunkItr = -1;
        }

        protected override void Dispose(bool disposing)
        {
            if (_underlyingStream != null)
            {
                _underlyingStream.Dispose();
                _underlyingStream = null;
            }

            base.Dispose(disposing);
        }

        //! TODO: Optimize this
        public override int ReadByte()
        {
            var buffer = new byte[1];
            Read(buffer, 0, 1);
            return buffer[0];
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            if (_chunkItr == -1)
                throw new NotImplementedException();

            if (_chunkItr == Chunks.Length)
                return 0;

            var currentChunk = Chunks[_chunkItr];
            var readCount = currentChunk.Read(_underlyingStream, buffer, offset, count);
            _position += readCount;

            if (currentChunk.Consumed)
                ++_chunkItr;

            return readCount;
        }

        public override bool CanRead => true;
        public override bool CanSeek => true;

        public override long Length => Chunks.Sum(c => c.DecompressedSize);

        private long _position;

        public override long Position
        {
            get => _position;
            set => Seek(value, SeekOrigin.Begin);
        }

        /// <summary>
        /// Seeks inside the decompressed data.
        /// </summary>
        /// <param name="offset">The offset by which to seek, in relation to the actual file contained in this <see cref="BLTE"/> archive.</param>
        /// <param name="origin"></param>
        /// <remarks>
        /// Throws <exception cref="NotImplementedException">NotImplementedException</exception> when using <see cref="SeekOrigin.End"/>.
        /// </remarks>
        /// <returns></returns>
        public override long Seek(long offset, SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.Begin:
                    offset = offset - _position;
                    break;
                case SeekOrigin.End:
                    throw new NotImplementedException();
            }

            var seekCount = 0L;
            while (seekCount != offset)
            {
                if (_chunkItr == Chunks.Length)
                    break;

                seekCount += Chunks[_chunkItr].Seek(_underlyingStream, offset);

                if (Chunks[_chunkItr].Consumed)
                    ++_chunkItr;
            }
            return _position += offset;
        }
    }
}

        private void InitializeChunk(EndianBinaryReader reader)
        {
            if (EncodingMode != 0x00)
                return;
            
            EncodingMode = reader.ReadByte();

            Console.WriteLine($"Initializing chunk at 0x{reader.BaseStream.Position:x8} : {(char) EncodingMode}");

            if (EncodingMode == (byte) 'Z')
            {
#if DEBUG
                var compressionInfo = reader.ReadBits(4);
                var compressionMethod = reader.ReadBits(4);

                var flevel = reader.ReadBits(2);
                var fdict = reader.ReadBit();
                var fcheck = reader.ReadBits(5);

                Console.Write($"  Compression level: {flevel} ");
                if (flevel == 0)
                    Console.WriteLine("(Fastest algorithm)");
                else if (flevel == 1)
                    Console.WriteLine("(Fast algorithm)");
                else if (flevel == 2)
                    Console.WriteLine("(Default algorithm)");
                else if (flevel == 3)
                    Console.WriteLine("(Maximum compression algorithm)");
                else
                    Console.WriteLine("(Unknown compression level)");

                Console.WriteLine("  Dictionary preset: {0}", fdict ? "Yes" : "No");
#else
                // Skip the header bytes of the BLTE stream
                reader.BaseStream.Seek(2, SeekOrigin.Current);
#endif
                _compressionStream = new MemoryBackedDeflateStream(new PartialStream(reader.BaseStream, (int)CompressedSize - 2), CompressionMode.Decompress);
            }
        }