import stream extended

Author: justcoding121

examples/Titanium.Web.Proxy.Examples.Wpf/Titanium.Web.Proxy.Examples.Wpf.csproj

@@ -72,9 +72,6 @@
     <Prefer32Bit>true</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="StreamExtended, Version=1.0.209.0, Culture=neutral, PublicKeyToken=bbfa0f1d54f50043, processorArchitecture=MSIL">
-      <HintPath>..\..\src\packages\StreamExtended.1.0.209-beta\lib\net45\StreamExtended.dll</HintPath>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
@@ -128,7 +125,6 @@
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
     </EmbeddedResource>
-    <None Include="packages.config" />
     <None Include="Properties\Settings.settings">
       <Generator>SettingsSingleFileGenerator</Generator>
       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
@@ -145,6 +141,10 @@
     </BootstrapperPackage>
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\src\StreamExtended\StreamExtended.csproj">
+      <Project>{61539dc1-ce80-41e6-a696-8f455ace8d15}</Project>
+      <Name>StreamExtended</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\src\Titanium.Web.Proxy\Titanium.Web.Proxy.csproj">
       <Project>{91018b6d-a7a9-45be-9cb3-79cbb8b169a6}</Project>
       <Name>Titanium.Web.Proxy</Name>

examples/Titanium.Web.Proxy.Examples.Wpf/packages.config

@@ -0,0 +1,47 @@
+using System.Collections.Concurrent;
+
+namespace StreamExtended
+{
+
+    /// <summary>
+    ///     A concrete IBufferPool implementation using a thread-safe stack.
+    ///     Works well when all consumers ask for buffers with the same size.
+    ///     If your application would use variable size buffers consider implementing IBufferPool using System.Buffers library from Microsoft.
+    /// </summary>
+    public class DefaultBufferPool : IBufferPool
+    {
+        private readonly ConcurrentStack<byte[]> buffers = new ConcurrentStack<byte[]>();
+
+        /// <summary>
+        /// Gets a buffer.
+        /// </summary>
+        /// <param name="bufferSize">Size of the buffer.</param>
+        /// <returns></returns>
+        public byte[] GetBuffer(int bufferSize)
+        {
+            if (!buffers.TryPop(out var buffer) || buffer.Length != bufferSize)
+            {
+                buffer = new byte[bufferSize];
+            }
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Returns the buffer.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        public void ReturnBuffer(byte[] buffer)
+        {
+            if (buffer != null)
+            {
+                buffers.Push(buffer);
+            }
+        }
+
+        public void Dispose()
+        {
+            buffers.Clear();
+        }
+    }
+}

src/StreamExtended/BufferPool/DefaultBufferPool.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace StreamExtended
+{
+    /// <summary>
+    ///     Use this interface to implement custom buffer pool.
+    ///     To use the default buffer pool implementation use DefaultBufferPool class.
+    /// </summary>
+    public interface IBufferPool : IDisposable
+    {
+        byte[] GetBuffer(int bufferSize);
+        void ReturnBuffer(byte[] buffer);
+    }
+}

src/StreamExtended/BufferPool/IBufferPool.cs

@@ -0,0 +1,122 @@
+using StreamExtended.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace StreamExtended
+{
+    /// <summary>
+    /// Wraps up the client SSL hello information.
+    /// </summary>
+    public class ClientHelloInfo
+    {
+        private static readonly string[] compressions = {
+            "null",
+            "DEFLATE"
+        };
+
+        public int HandshakeVersion { get; set; }
+
+        public int MajorVersion { get; set; }
+
+        public int MinorVersion { get; set; }
+
+        public byte[] Random { get; set; }
+
+        public DateTime Time
+        {
+            get
+            {
+                DateTime time = DateTime.MinValue;
+                if (Random.Length > 3)
+                {
+                    time = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc)
+                        .AddSeconds(((uint)Random[3] << 24) + ((uint)Random[2] << 16) + ((uint)Random[1] << 8) + (uint)Random[0]).ToLocalTime();
+                }
+
+                return time;
+            }
+        }
+
+        public byte[] SessionId { get; set; }
+
+        public int[] Ciphers { get; set; }
+
+        public byte[] CompressionData { get; set; }
+
+        internal int ClientHelloLength { get; set; }
+
+        internal int EntensionsStartPosition { get; set; }
+
+        public Dictionary<string, SslExtension> Extensions { get; set; }
+
+        private static string SslVersionToString(int major, int minor)
+        {
+            string str = "Unknown";
+            if (major == 3 && minor == 3)
+                str = "TLS/1.2";
+            else if (major == 3 && minor == 2)
+                str = "TLS/1.1";
+            else if (major == 3 && minor == 1)
+                str = "TLS/1.0";
+            else if (major == 3 && minor == 0)
+                str = "SSL/3.0";
+            else if (major == 2 && minor == 0)
+                str = "SSL/2.0";
+
+            return $"{major}.{minor} ({str})";
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String" /> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="System.String" /> that represents this instance.
+        /// </returns>
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine($"A SSLv{HandshakeVersion}-compatible ClientHello handshake was found. Titanium extracted the parameters below.");
+            sb.AppendLine();
+            sb.AppendLine($"Version: {SslVersionToString(MajorVersion, MinorVersion)}");
+            sb.AppendLine($"Random: {string.Join(" ", Random.Select(x => x.ToString("X2")))}");
+            sb.AppendLine($"\"Time\": {Time}");
+            sb.AppendLine($"SessionID: {string.Join(" ", SessionId.Select(x => x.ToString("X2")))}");
+
+            if (Extensions != null)
+            {
+                sb.AppendLine("Extensions:");
+                foreach (var extension in Extensions.Values.OrderBy(x => x.Position))
+                {
+                    sb.AppendLine($"{extension.Name}: {extension.Data}");
+                }
+            }
+
+            if (CompressionData != null && CompressionData.Length > 0)
+            {
+                int compressionMethod = CompressionData[0];
+                string compression = compressions.Length > compressionMethod 
+                    ? compressions[compressionMethod] 
+                    : $"unknown [0x{compressionMethod:X2}]";
+                sb.AppendLine($"Compression: {compression}");
+            }
+
+            if (Ciphers.Length > 0)
+            {
+                sb.AppendLine("Ciphers:");
+                foreach (int cipherSuite in Ciphers)
+                {
+                    if (!SslCiphers.Ciphers.TryGetValue(cipherSuite, out string cipherStr))
+                    {
+                        cipherStr = "unknown";
+                    }
+
+                    sb.AppendLine($"[0x{cipherSuite:X4}] {cipherStr}");
+                }
+            }
+
+            return sb.ToString();
+        }
+    }
+}