Add project files.

Assets/Cryville/Common/Network/HttpClient.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Sockets;
+using System.Text;
+using Microsoft.Win32;
+
+namespace Cryville.Common.Network {
+	public class HttpClient {
+		private readonly string _directHost;
+		protected string DirectHost { get { return _directHost; } }
+
+		private readonly int _directPort;
+		protected int DirectPort { get { return _directPort; } }
+
+		readonly Uri _baseUri;
+		readonly int origPort;
+
+		protected string Version = "HTTP/1.1";
+		protected TcpClient TcpClient;
+		protected virtual Stream Stream {
+			get {
+				return TcpClient.GetStream();
+			}
+		}
+
+		private readonly bool _proxied = false;
+		
+		public Dictionary<string, string> Headers { get; set; }
+		
+		public HttpClient(Uri baseUri, int port = 80) {
+			_directHost = baseUri.Host;
+			_directPort = port;
+			_baseUri = baseUri;
+			origPort = _baseUri.Port;
+			Headers = new Dictionary<string, string>();
+			_proxied = GetProxy(ref _directHost, ref _directPort);
+			Logger.Log("main", 0, "Network", "Connecting to {0}:{1}", DirectHost, DirectPort);
+			TcpClient = new TcpClient(DirectHost, DirectPort);
+		}
+
+		public virtual void Connect() {
+			if (_proxied) {
+				Request("CONNECT", _baseUri.Host + ":" + origPort.ToString());
+			}
+		}
+
+		public virtual void Close() {
+			TcpClient.Close();
+		}
+		
+		public HttpResponse Request(string method, Uri uri, string body = null, Encoding encoding = null) {
+			string struri = GetUri(uri).PathAndQuery;
+			// if (_proxied) struri = GetUri(uri).AbsoluteUri;
+			return Request(method, struri, body, encoding);
+		}
+		
+		public HttpResponse Request(string method, string uri, string body = null, Encoding encoding = null) {
+			var headers = new Dictionary<string, string>();
+			// if (Stream.CanTimeout) Stream.ReadTimeout = Stream.WriteTimeout = 5000;
+			foreach (var h in Headers)
+				headers.Add(h.Key, h.Value);
+			// headers["Accept"] = "text/plain, */*";
+			// headers["Connection"] = "close";
+			headers["Host"] = _baseUri.Host;
+			byte[] payload = new byte[0];
+			if (body != null) {
+				if (encoding == null)
+					encoding = Encoding.UTF8;
+				payload = encoding.GetBytes(body);
+				headers.Add("Content-Encoding", encoding.EncodingName);
+				headers.Add("Content-Length", payload.Length.ToString());
+			}
+			string request_line = string.Format(
+				"{0} {1} {2}\r\n", method, uri, Version
+			);
+			string header_fields = string.Concat((
+				from h in headers select h.Key + ":" + h.Value + "\r\n"
+			).ToArray());
+			byte[] buffer0 = Encoding.ASCII.GetBytes(string.Format(
+				"{0}{1}\r\n", request_line, header_fields
+			));
+			byte[] buffer1 = new byte[buffer0.Length + payload.Length];
+			Array.Copy(buffer0, buffer1, buffer0.Length);
+			Array.Copy(payload, 0, buffer1, buffer0.Length, payload.Length);
+			Logger.Log("main", 0, "Network", Encoding.UTF8.GetString(buffer1));
+			Stream.Write(buffer1, 0, buffer1.Length);
+			Stream.Flush();
+			var response = new HttpResponse(Stream);
+			Logger.Log("main", 0, "Network", "{0}", response);
+			return response;
+		}
+
+		protected virtual bool GetProxy(ref string host, ref int port) {
+			if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
+				var reg = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Internet Settings");
+				var proxyEnable = (int)reg.GetValue("ProxyEnable");
+				if (proxyEnable == 0) return false;
+				var proxyStr = (string)reg.GetValue("ProxyServer");
+				if (!string.IsNullOrEmpty(proxyStr)) {
+					string[] proxies = proxyStr.Split(';');
+					foreach (var p in proxies) {
+						if (p.StartsWith("http=")) {
+							string[] s = p.Split('=', ':');
+							host = s[1];
+							port = int.Parse(s[2]);
+							return true;
+						}
+					}
+				}
+			}
+			return false;
+		}
+		
+		protected Uri GetUri(string path) {
+			Uri address;
+			if (_baseUri != null) {
+				if (!Uri.TryCreate(_baseUri, path, out address)) {
+					return new Uri(Path.GetFullPath(path));
+				}
+			}
+			else {
+				if (!Uri.TryCreate(path, UriKind.Absolute, out address)) {
+					return new Uri(Path.GetFullPath(path));
+				}
+			}
+			return GetUri(address);
+		}
+		
+		protected Uri GetUri(Uri address) {
+			if (address == null) {
+				throw new ArgumentNullException("address");
+			}
+			Uri uri = address;
+			if (!address.IsAbsoluteUri && _baseUri != null && !Uri.TryCreate(_baseUri, address, out uri)) {
+				return address;
+			}
+			return uri;
+		}
+	}
+}

Assets/Cryville/Common/Network/HttpClient.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5ea931bf5488011468f3d1243a038874
+timeCreated: 1622589817
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Network/HttpResponse.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace Cryville.Common.Network {
+	public class HttpResponse {
+		static readonly char[] spchar = new char[]{ ' ' };
+		public string HttpVersion { get; private set; }
+		public string StatusCode { get; private set; }
+		public string ReasonPhase { get; private set; }
+		public Dictionary<string, string> Headers { get; private set; }
+		public HttpResponseStream MessageBody { get; private set; }
+		internal HttpResponse(Stream stream) {
+			var reader = new BinaryReader(stream, Encoding.ASCII);
+			var statu_line = ReadLine(reader).Split(spchar, 3);
+			HttpVersion = statu_line[0];
+			StatusCode = statu_line[1];
+			ReasonPhase = statu_line[2];
+			Logger.Log("main", 0, "Network", "Receive Response: {0} {1} {2}", HttpVersion, StatusCode, ReasonPhase);
+			Headers = new Dictionary<string, string>();
+			while (ParseHeader(reader, Headers)) ;
+			if (Headers.ContainsKey("content-length")) {
+				int length = int.Parse(Headers["content-length"]);
+				MessageBody = new HttpResponseBlockStream(reader, length);
+			}
+			else if (Headers.ContainsKey("transfer-encoding") && Headers["transfer-encoding"] == "chunked") {
+				MessageBody = new HttpResponseChunkedStream(reader);
+			}
+		}
+
+		public override string ToString() {
+			return string.Format("<{0} {1} {2}>", HttpVersion, StatusCode, ReasonPhase);
+		}
+
+		internal static bool ParseHeader(BinaryReader reader, Dictionary<string,string> headers) {
+			// TODO Multiline header
+			var header = ReadLine(reader);
+			if (header == "") return false;
+			var s = header.Split(':');
+			string field_name = s[0].Trim().ToLower();
+			string field_value = s[1].Trim();
+			if (headers.ContainsKey(field_name)) headers[field_name] += "," + field_value;
+			else headers.Add(field_name, field_value);
+			Logger.Log("main", 0, "Network", "Receive Header {0}: {1}", field_name, field_value);
+			return true;
+		}
+
+		internal static string ReadLine(BinaryReader reader) {
+			StringBuilder result = new StringBuilder();
+			char c;
+			while (true) {
+				c = reader.ReadChar();
+				if (c == '\r') break;
+				result.Append(c);
+			}
+			// TODO Unseekable
+			reader.ReadByte();
+			return result.ToString();
+		}
+	}
+}

Assets/Cryville/Common/Network/HttpResponse.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 07e8215a93e3eb1418685009f0c58dcd
+timeCreated: 1622596274
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Network/HttpResponseStream.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+namespace Cryville.Common.Network {
+	public abstract class HttpResponseStream : Stream {
+		public override bool CanRead { get { return true; } }
+
+		public override bool CanSeek { get { return false; } }
+
+		public override bool CanWrite { get { return false; } }
+
+		public override long Length { get { throw new NotSupportedException(); } }
+
+		public override long Position {
+			get { throw new NotSupportedException(); }
+			set { throw new NotSupportedException(); }
+		}
+		
+		public override void Flush() {
+			// Do nothing
+		}
+
+		public abstract byte[] ReadToEnd();
+
+		public override long Seek(long offset, SeekOrigin origin) {
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength(long value) {
+			throw new NotSupportedException();
+		}
+
+		public override void Write(byte[] buffer, int offset, int count) {
+			throw new NotSupportedException();
+		}
+	}
+
+	internal sealed class HttpResponseBlockStream : HttpResponseStream {
+		readonly BinaryReader _reader;
+		readonly int _length;
+		int _pos = 0;
+		internal HttpResponseBlockStream(BinaryReader reader, int length) {
+			_reader = reader;
+			_length = length;
+		}
+		public override int Read(byte[] buffer, int offset, int count) {
+			int recv = 0;
+			int recv_len = System.Math.Min(count, _length - _pos);
+			if (recv_len == 0) return 0;
+			while (recv < recv_len) {
+				recv += _reader.Read(buffer, offset + recv, count - recv);
+				Logger.Log("main", 0, "Network", "Message body received: {0}/{1}/{2}", recv, recv_len, _length);
+			}
+			_pos += recv_len;
+			return recv_len;
+		}
+		public override byte[] ReadToEnd() {
+			byte[] buffer = new byte[_length - _pos];
+			Read(buffer, 0, buffer.Length);
+			return buffer;
+		}
+	}
+
+	internal sealed class HttpResponseChunkedStream : HttpResponseStream {
+		readonly BinaryReader _reader;
+		byte[] _chunk = null;
+		int _pos = 0;
+		internal HttpResponseChunkedStream(BinaryReader reader) {
+			_reader = reader;
+			ReadChunk();
+		}
+		public void ReadChunk() {
+			if (_chunk != null && _chunk.Length == 0) return;
+			string[] chunkHeader = HttpResponse.ReadLine(_reader).Split(';');
+			// int chunkSize = Array.IndexOf(LEN, chunkHeader[0].ToLower()[0]);
+			int chunkSize = int.Parse(chunkHeader[0], NumberStyles.HexNumber);
+			if (chunkSize == -1)
+				throw new IOException("Corrupted chunk received");
+			if (chunkSize == 0) {
+				_chunk = new byte[0];
+				// TODO TE Header, now just discard
+				var headers = new Dictionary<string, string>();
+				while (HttpResponse.ParseHeader(_reader, headers)) ;
+				return;
+			}
+			_chunk = new byte[chunkSize];
+			int recv = 0;
+			while (recv < chunkSize) {
+				recv += _reader.Read(_chunk, recv, chunkSize - recv);
+				Logger.Log("main", 0, "Network", "Message chunk received: {0}/{1}", recv, chunkSize);
+			}
+			_pos = 0;
+			if (HttpResponse.ReadLine(_reader) != "")
+				throw new IOException("Corrupted chunk received");
+		}
+		public override int Read(byte[] buffer, int offset, int count) {
+			if (_chunk.Length == 0) return 0;
+			int recv = 0;
+			while (true) {
+				if (count - recv <= _chunk.Length - _pos) break;
+				Array.Copy(_chunk, _pos, buffer, recv, _chunk.Length - _pos);
+				recv += _chunk.Length - _pos;
+				ReadChunk();
+				if (_chunk.Length == 0) return recv;
+			}
+			Array.Copy(_chunk, _pos, buffer, recv, count - recv);
+			return count;
+		}
+		public override byte[] ReadToEnd() {
+			if (_chunk.Length == 0) return new byte[0];
+			List<byte[]> segs = new List<byte[]>();
+			while (true) {
+				if (_pos != 0) {
+					var buffer = new byte[_chunk.Length - _pos];
+					Array.Copy(_chunk, _pos, buffer, 0, buffer.Length);
+					segs.Add(buffer);
+				}
+				else segs.Add(_chunk);
+				ReadChunk();
+				if (_chunk.Length == 0) {
+					var result = new byte[segs.Sum(i => i.Length)];
+					int p = 0;
+					foreach (var i in segs) {
+						Array.Copy(i, 0, result, p, i.Length);
+						p += i.Length;
+					}
+					return result;
+				}
+			}
+		}
+	}
+}

Assets/Cryville/Common/Network/HttpResponseStream.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f191de447a708da4f9d230e6545ce0a6
+timeCreated: 1635470462
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Network/HttpsClient.cs

@@ -0,0 +1,51 @@
+using Microsoft.Win32;
+using System;
+using System.IO;
+using System.Net.Sockets;
+
+namespace Cryville.Common.Network {
+	public class HttpsClient : HttpClient {
+		readonly TlsTcpClient _tlsTcpClient;
+		
+		protected override Stream Stream {
+			get {
+				return _tlsTcpClient.Stream;
+			}
+		}
+
+		public HttpsClient(Uri baseUri) : base(baseUri, 443) {
+			_tlsTcpClient = new TlsTcpClient(DirectHost, DirectPort);
+		}
+
+		public override void Connect() {
+			_tlsTcpClient.Connect();
+			base.Connect();
+		}
+
+		public override void Close() {
+			base.Close();
+			_tlsTcpClient.Close();
+		}
+
+		protected override bool GetProxy(ref string host, ref int port) {
+			if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
+				var reg = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Internet Settings");
+				var proxyEnable = (int)reg.GetValue("ProxyEnable");
+				if (proxyEnable == 0) return false;
+				var proxyStr = (string)reg.GetValue("ProxyServer");
+				if (!string.IsNullOrEmpty(proxyStr)) {
+					string[] proxies = proxyStr.Split(';');
+					foreach (var p in proxies) {
+						if (p.StartsWith("https=")) {
+							string[] s = p.Split('=', ':');
+							host = s[1];
+							port = int.Parse(s[2]);
+							return true;
+						}
+					}
+				}
+			}
+			return false;
+		}
+	}
+}

Assets/Cryville/Common/Network/HttpsClient.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9b35290e0e147a342acc29a20c8fceaf
+timeCreated: 1622503538
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Cryville/Common/Network/TlsTcpClient.cs

@@ -0,0 +1,94 @@
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Tls;
+using Org.BouncyCastle.Tls.Crypto;
+using Org.BouncyCastle.Tls.Crypto.Impl.BC;
+using System.Collections;
+using System.IO;
+using System.Linq;
+using System.Net.Sockets;
+
+namespace Cryville.Common.Network {
+	public class TlsTcpClient {
+		readonly TcpClient _tcpClient;
+		readonly TlsClientProtocol _protocol;
+		readonly TlsClient _tlsClient;
+		public Stream Stream { get; private set; }
+		public TlsTcpClient(string hostname, int port) {
+			_tcpClient = new TcpClient(hostname, port);
+			_protocol = new TlsClientProtocol(_tcpClient.GetStream());
+			_tlsClient = new InternalTlsClient(new BcTlsCrypto(new SecureRandom()));
+		}
+
+		public void Connect() {
+			_protocol.Connect(_tlsClient);
+			Stream = _protocol.Stream;
+		}
+
+		public void Close() {
+			_protocol.Close();
+		}
+
+		private class InternalTlsClient : DefaultTlsClient {
+			public InternalTlsClient(TlsCrypto crypto) : base(crypto) { }
+
+			protected override ProtocolVersion[] GetSupportedVersions() {
+				return ProtocolVersion.TLSv13.DownTo(ProtocolVersion.TLSv12);
+			}
+
+			protected override IList GetProtocolNames() {
+				IList list = new ArrayList {
+					ProtocolName.Http_1_1,
+					ProtocolName.Http_2_Tls
+				};
+				return list;
+			}
+
+			private static readonly int[] supportedCipherSuites = {
+				CipherSuite.TLS_AES_128_GCM_SHA256,
+				CipherSuite.TLS_AES_256_GCM_SHA384,
+				CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
+				CipherSuite.TLS_AES_128_CCM_SHA256,
+				CipherSuite.TLS_AES_128_CCM_8_SHA256,
+			};
+			protected override int[] GetSupportedCipherSuites() {
+				return base.GetSupportedCipherSuites().Union(supportedCipherSuites).ToArray();
+			}
+
+			protected override IList GetSupportedSignatureAlgorithms() {
+				var result = base.GetSupportedSignatureAlgorithms();
+				result.Add(SignatureAndHashAlgorithm.ecdsa_brainpoolP256r1tls13_sha256);
+				result.Add(SignatureAndHashAlgorithm.ecdsa_brainpoolP384r1tls13_sha384);
+				result.Add(SignatureAndHashAlgorithm.ecdsa_brainpoolP512r1tls13_sha512);
+				return result;
+			}
+
+			public override TlsAuthentication GetAuthentication() {
+				return new NullTlsAuthentication();
+			}
+
+			public override void NotifyAlertReceived(short alertLevel, short alertDescription) {
+				Logger.Log("main", 0, "Network/TLS", "TLS Alert {0} {1}", alertLevel, alertDescription);
+			}
+
+			public override void NotifyServerVersion(ProtocolVersion serverVersion) {
+				base.NotifyServerVersion(serverVersion);
+				Logger.Log("main", 0, "Network/TLS", "NotifyServerVersion {0}", serverVersion);
+			}
+
+			public override void NotifySelectedCipherSuite(int selectedCipherSuite) {
+				base.NotifySelectedCipherSuite(selectedCipherSuite);
+				Logger.Log("main", 0, "Network/TLS", "NotifySelectedCipherSuite {0}", selectedCipherSuite);
+			}
+		}
+
+		private class NullTlsAuthentication : TlsAuthentication {
+			public TlsCredentials GetClientCredentials(CertificateRequest certificateRequest) {
+				return null;
+			}
+
+			public void NotifyServerCertificate(TlsServerCertificate serverCertificate) {
+				// Do nothing
+			}
+		}
+	}
+}

Assets/Cryville/Common/Network/TlsTcpClient.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c9c242bb90fc1cc479a8df1407f21940
+timeCreated: 1622021660
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: