提交Unity 联机Pro

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1Generator.cs

@@ -0,0 +1,32 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class Asn1Generator
+    {
+		private Stream _out;
+
+		protected Asn1Generator(
+			Stream outStream)
+        {
+            _out = outStream;
+        }
+
+		protected Stream Out
+		{
+			get { return _out; }
+		}
+
+		public abstract void AddObject(Asn1Encodable obj);
+
+        public abstract void AddObject(Asn1Object obj);
+
+        public abstract Stream GetRawOutputStream();
+
+		public abstract void Close();
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1Generator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bdc81b96ab45ff94098a67c1dcf27e23
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1OctetStringParser.cs

@@ -0,0 +1,17 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public interface Asn1OctetStringParser
+		: IAsn1Convertible
+	{
+        /// <summary>Return the content of the OCTET STRING as a <see cref="Stream"/>.</summary>
+        /// <returns>A <see cref="Stream"/> represnting the OCTET STRING's content.</returns>
+        Stream GetOctetStream();
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1OctetStringParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cc7b00883ebe075438a06d46defe0b35
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1SequenceParser.cs

@@ -0,0 +1,12 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public interface Asn1SequenceParser
+		: IAsn1Convertible
+	{
+		IAsn1Convertible ReadObject();
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1SequenceParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 945f35756f280754580483acdd35d1f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1SetParser.cs

@@ -0,0 +1,12 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public interface Asn1SetParser
+		: IAsn1Convertible
+	{
+		IAsn1Convertible ReadObject();
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1SetParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e5c4059ebe7ac0240878ec76e191d1ad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1StreamParser.cs

@@ -0,0 +1,248 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public class Asn1StreamParser
+	{
+		private readonly Stream _in;
+		private readonly int _limit;
+
+        private readonly byte[][] tmpBuffers;
+
+        public Asn1StreamParser(Stream input)
+			: this(input, Asn1InputStream.FindLimit(input))
+		{
+		}
+
+        public Asn1StreamParser(byte[] encoding)
+            : this(new MemoryStream(encoding, false), encoding.Length)
+        {
+        }
+
+        public Asn1StreamParser(Stream input, int limit)
+            : this(input, limit, new byte[16][])
+		{
+        }
+
+        internal Asn1StreamParser(Stream input, int limit, byte[][] tmpBuffers)
+        {
+            if (!input.CanRead)
+                throw new ArgumentException("Expected stream to be readable", "input");
+
+            this._in = input;
+            this._limit = limit;
+            this.tmpBuffers = tmpBuffers;
+        }
+
+		public virtual IAsn1Convertible ReadObject()
+		{
+			int tagHdr = _in.ReadByte();
+			if (tagHdr < 0)
+				return null;
+
+            return ImplParseObject(tagHdr);
+        }
+
+        internal IAsn1Convertible ImplParseObject(int tagHdr)
+        {
+            // turn off looking for "00" while we resolve the tag
+            Set00Check(false);
+
+			//
+			// calculate tag number
+			//
+			int tagNo = Asn1InputStream.ReadTagNumber(_in, tagHdr);
+
+			//
+			// calculate length
+			//
+			int length = Asn1InputStream.ReadLength(_in, _limit,
+                tagNo == Asn1Tags.BitString || tagNo == Asn1Tags.OctetString || tagNo == Asn1Tags.Sequence ||
+                tagNo == Asn1Tags.Set || tagNo == Asn1Tags.External);
+
+			if (length < 0) // indefinite-length method
+			{
+                if (0 == (tagHdr & Asn1Tags.Constructed))
+                    throw new IOException("indefinite-length primitive encoding encountered");
+
+                IndefiniteLengthInputStream indIn = new IndefiniteLengthInputStream(_in, _limit);
+                Asn1StreamParser sp = new Asn1StreamParser(indIn, _limit, tmpBuffers);
+
+                int tagClass = tagHdr & Asn1Tags.Private;
+                if (0 != tagClass)
+                    return new BerTaggedObjectParser(tagClass, tagNo, sp);
+
+                return sp.ParseImplicitConstructedIL(tagNo);
+			}
+			else
+			{
+				DefiniteLengthInputStream defIn = new DefiniteLengthInputStream(_in, length, _limit);
+
+                if (0 == (tagHdr & Asn1Tags.Flags))
+                    return ParseImplicitPrimitive(tagNo, defIn);
+
+                Asn1StreamParser sp = new Asn1StreamParser(defIn, defIn.Remaining, tmpBuffers);
+
+                int tagClass = tagHdr & Asn1Tags.Private;
+                if (0 != tagClass)
+                {
+                    bool isConstructed = (tagHdr & Asn1Tags.Constructed) != 0;
+
+                    return new DLTaggedObjectParser(tagClass, tagNo, isConstructed, sp);
+                }
+
+                return sp.ParseImplicitConstructedDL(tagNo);
+			}
+		}
+
+        internal Asn1Object LoadTaggedDL(int tagClass, int tagNo, bool constructed)
+        {
+            if (!constructed)
+            {
+                byte[] contentsOctets = ((DefiniteLengthInputStream)_in).ToArray();
+                return Asn1TaggedObject.CreatePrimitive(tagClass, tagNo, contentsOctets);
+            }
+
+            Asn1EncodableVector contentsElements = ReadVector();
+            return Asn1TaggedObject.CreateConstructedDL(tagClass, tagNo, contentsElements);
+        }
+
+        internal Asn1Object LoadTaggedIL(int tagClass, int tagNo)
+        {
+            Asn1EncodableVector contentsElements = ReadVector();
+            return Asn1TaggedObject.CreateConstructedIL(tagClass, tagNo, contentsElements);
+        }
+
+        internal IAsn1Convertible ParseImplicitConstructedDL(int univTagNo)
+        {
+            switch (univTagNo)
+            {
+            case Asn1Tags.BitString:
+                // TODO[asn1] DLConstructedBitStringParser
+                return new BerBitStringParser(this);
+            case Asn1Tags.External:
+                return new DerExternalParser(this);
+            case Asn1Tags.OctetString:
+                // TODO[asn1] DLConstructedOctetStringParser
+                return new BerOctetStringParser(this);
+            case Asn1Tags.Set:
+                return new DerSetParser(this);
+            case Asn1Tags.Sequence:
+                return new DerSequenceParser(this);
+            default:
+				throw new Asn1Exception("unknown DL object encountered: 0x" + univTagNo.ToString("X"));
+            }
+        }
+
+        internal IAsn1Convertible ParseImplicitConstructedIL(int univTagNo)
+        {
+            switch (univTagNo)
+            {
+            case Asn1Tags.BitString:
+                return new BerBitStringParser(this);
+            case Asn1Tags.External:
+                // TODO[asn1] BERExternalParser
+                return new DerExternalParser(this);
+            case Asn1Tags.OctetString:
+                return new BerOctetStringParser(this);
+            case Asn1Tags.Sequence:
+                return new BerSequenceParser(this);
+            case Asn1Tags.Set:
+                return new BerSetParser(this);
+            default:
+                throw new Asn1Exception("unknown BER object encountered: 0x" + univTagNo.ToString("X"));
+            }
+        }
+
+        internal IAsn1Convertible ParseImplicitPrimitive(int univTagNo)
+        {
+            return ParseImplicitPrimitive(univTagNo, (DefiniteLengthInputStream)_in);
+        }
+
+        internal IAsn1Convertible ParseImplicitPrimitive(int univTagNo, DefiniteLengthInputStream defIn)
+        {
+            // Some primitive encodings can be handled by parsers too...
+            switch (univTagNo)
+            {
+            case Asn1Tags.BitString:
+                return new DLBitStringParser(defIn);
+            case Asn1Tags.External:
+                throw new Asn1Exception("externals must use constructed encoding (see X.690 8.18)");
+            case Asn1Tags.OctetString:
+                return new DerOctetStringParser(defIn);
+			case Asn1Tags.Set:
+				throw new Asn1Exception("sequences must use constructed encoding (see X.690 8.9.1/8.10.1)");
+			case Asn1Tags.Sequence:
+				throw new Asn1Exception("sets must use constructed encoding (see X.690 8.11.1/8.12.1)");
+            }
+
+            try
+            {
+                return Asn1InputStream.CreatePrimitiveDerObject(univTagNo, defIn, tmpBuffers);
+            }
+            catch (ArgumentException e)
+            {
+                throw new Asn1Exception("corrupted stream detected", e);
+            }
+        }
+
+        internal IAsn1Convertible ParseObject(int univTagNo)
+        {
+            if (univTagNo < 0 || univTagNo > 30)
+                throw new ArgumentException("invalid universal tag number: " + univTagNo, "univTagNo");
+
+            int tagHdr = _in.ReadByte();
+            if (tagHdr < 0)
+                return null;
+
+            if ((tagHdr & ~Asn1Tags.Constructed) != univTagNo)
+                throw new IOException("unexpected identifier encountered: " + tagHdr);
+
+            return ImplParseObject(tagHdr);
+        }
+
+        internal Asn1TaggedObjectParser ParseTaggedObject()
+        {
+            int tagHdr = _in.ReadByte();
+            if (tagHdr< 0)
+                return null;
+
+            int tagClass = tagHdr & Asn1Tags.Private;
+            if (0 == tagClass)
+                throw new Asn1Exception("no tagged object found");
+
+            return (Asn1TaggedObjectParser)ImplParseObject(tagHdr);
+        }
+
+        // TODO[asn1] Prefer 'LoadVector'
+        internal Asn1EncodableVector ReadVector()
+        {
+            int tagHdr = _in.ReadByte();
+            if (tagHdr < 0)
+                return new Asn1EncodableVector(0);
+
+            Asn1EncodableVector v = new Asn1EncodableVector();
+            do
+            {
+                IAsn1Convertible obj = ImplParseObject(tagHdr);
+
+                v.Add(obj.ToAsn1Object());
+            }
+            while ((tagHdr = _in.ReadByte()) >= 0);
+            return v;
+        }
+
+		private void Set00Check(bool enabled)
+		{
+			if (_in is IndefiniteLengthInputStream indef)
+			{
+				indef.SetEofOn00(enabled);
+			}
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1StreamParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 12d648f2463b0b34a8a0756dbb9d6bfb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1TaggedObjectParser.cs

@@ -0,0 +1,39 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public interface Asn1TaggedObjectParser
+		: IAsn1Convertible
+	{
+        int TagClass { get; }
+
+		int TagNo { get; }
+
+        bool HasContextTag(int tagNo);
+
+        bool HasTag(int tagClass, int tagNo);
+
+        /// <exception cref="IOException"/>
+        IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo);
+
+        /// <summary>Needed for open types, until we have better type-guided parsing support.</summary>
+        /// <remarks>
+        /// Use sparingly for other purposes, and prefer <see cref="ParseExplicitBaseTagged"/> or
+        /// <see cref="ParseBaseUniversal(bool, int)"/> where possible. Before using, check for matching tag
+        /// <see cref="TagClass">class</see> and <see cref="TagNo">number</see>.
+        /// </remarks>
+        /// <exception cref="IOException"/>
+        IAsn1Convertible ParseExplicitBaseObject();
+
+        /// <exception cref="IOException"/>
+        Asn1TaggedObjectParser ParseExplicitBaseTagged();
+
+        /// <exception cref="IOException"/>
+        Asn1TaggedObjectParser ParseImplicitBaseTagged(int baseTagClass, int baseTagNo);
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ASN1TaggedObjectParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e183ed6c26f0fac4caebd14e56080e86
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1BitStringParser.cs

@@ -0,0 +1,36 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public interface Asn1BitStringParser
+        : IAsn1Convertible
+    {
+        /// <summary>Return a <see cref="Stream"/> representing the contents of the BIT STRING. The final byte, if any,
+        /// may include pad bits. See <see cref="PadBits"/>.</summary>
+        /// <returns>A <see cref="Stream"/> with its source as the BIT STRING content.</returns>
+        /// <exception cref="IOException"/>
+        Stream GetBitStream();
+
+        /// <summary>Return a <see cref="Stream"/> representing the contents of the BIT STRING, where the content is
+        /// expected to be octet-aligned (this will be automatically checked during parsing).</summary>
+        /// <returns>A <see cref="Stream"/> with its source as the BIT STRING content.</returns>
+        /// <exception cref="IOException"/>
+        Stream GetOctetStream();
+
+        /// <summary>Return the number of pad bits, if any, in the final byte, if any, read from
+        /// <see cref="GetBitStream"/>.</summary>
+        /// <remarks>
+        /// This number is in the range zero to seven. That number of the least significant bits of the final byte, if
+        /// any, are not part of the contents and should be ignored. NOTE: Must be called AFTER the stream has been
+        /// fully processed. (Does not need to be called if <see cref="GetOctetStream"/> was used instead of
+        /// <see cref="GetBitStream"/>.
+        /// </remarks>
+        /// <returns>The number of pad bits. In the range zero to seven.</returns>
+        int PadBits { get; }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1BitStringParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 24137e6820af97b4bb29831a34398f8f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Encodable.cs

@@ -0,0 +1,80 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public abstract class Asn1Encodable
+		: IAsn1Convertible
+    {
+		public const string Der = "DER";
+		public const string Ber = "BER";
+
+        public virtual void EncodeTo(Stream output)
+        {
+            ToAsn1Object().EncodeTo(output);
+        }
+
+        public virtual void EncodeTo(Stream output, string encoding)
+        {
+            ToAsn1Object().EncodeTo(output, encoding);
+        }
+
+		public byte[] GetEncoded()
+        {
+            MemoryStream bOut = new MemoryStream();
+            ToAsn1Object().EncodeTo(bOut);
+            return bOut.ToArray();
+        }
+
+        public byte[] GetEncoded(string encoding)
+        {
+            MemoryStream bOut = new MemoryStream();
+            ToAsn1Object().EncodeTo(bOut, encoding);
+            return bOut.ToArray();
+        }
+
+        /**
+		* Return the DER encoding of the object, null if the DER encoding can not be made.
+		*
+		* @return a DER byte array, null otherwise.
+		*/
+        public byte[] GetDerEncoded()
+		{
+			try
+			{
+				return GetEncoded(Der);
+			}
+			catch (IOException)
+			{
+				return null;
+			}
+		}
+
+		public sealed override int GetHashCode()
+		{
+			return ToAsn1Object().CallAsn1GetHashCode();
+		}
+
+		public sealed override bool Equals(
+			object obj)
+		{
+			if (obj == this)
+				return true;
+
+			IAsn1Convertible other = obj as IAsn1Convertible;
+
+			if (other == null)
+				return false;
+
+			Asn1Object o1 = ToAsn1Object();
+			Asn1Object o2 = other.ToAsn1Object();
+
+			return o1 == o2 || (null != o2 && o1.CallAsn1Equals(o2));
+		}
+
+		public abstract Asn1Object ToAsn1Object();
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Encodable.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b69b682df6ac1845b77ec1b6bf0427d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1EncodableVector.cs

@@ -0,0 +1,248 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Collections.Generic;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /**
+     * Mutable class for building ASN.1 constructed objects such as SETs or SEQUENCEs.
+     */
+    public class Asn1EncodableVector
+        : IEnumerable<Asn1Encodable>
+    {
+        internal static readonly Asn1Encodable[] EmptyElements = new Asn1Encodable[0];
+
+        private const int DefaultCapacity = 10;
+
+        private Asn1Encodable[] elements;
+        private int elementCount;
+        private bool copyOnWrite;
+
+        public static Asn1EncodableVector FromEnumerable(IEnumerable<Asn1Encodable> e)
+        {
+            Asn1EncodableVector v = new Asn1EncodableVector();
+            foreach (Asn1Encodable obj in e)
+            {
+                v.Add(obj);
+            }
+            return v;
+        }
+
+        public Asn1EncodableVector()
+            : this(DefaultCapacity)
+        {
+        }
+
+        public Asn1EncodableVector(int initialCapacity)
+        {
+            if (initialCapacity < 0)
+                throw new ArgumentException("must not be negative", "initialCapacity");
+
+            this.elements = (initialCapacity == 0) ? EmptyElements : new Asn1Encodable[initialCapacity];
+            this.elementCount = 0;
+            this.copyOnWrite = false;
+        }
+
+        public Asn1EncodableVector(Asn1Encodable element)
+            : this()
+        {
+            Add(element);
+        }
+
+        public Asn1EncodableVector(Asn1Encodable element1, Asn1Encodable element2)
+            : this()
+        {
+            Add(element1);
+            Add(element2);
+        }
+
+        public Asn1EncodableVector(params Asn1Encodable[] v)
+            : this()
+        {
+            Add(v);
+        }
+
+        public void Add(Asn1Encodable element)
+        {
+            if (null == element)
+                throw new ArgumentNullException("element");
+
+            int capacity = elements.Length;
+            int minCapacity = elementCount + 1;
+            if ((minCapacity > capacity) | copyOnWrite)
+            {
+                Reallocate(minCapacity);
+            }
+
+            this.elements[elementCount] = element;
+            this.elementCount = minCapacity;
+        }
+
+        public void Add(Asn1Encodable element1, Asn1Encodable element2)
+        {
+            Add(element1);
+            Add(element2);
+        }
+
+        public void Add(params Asn1Encodable[] objs)
+        {
+            foreach (Asn1Encodable obj in objs)
+            {
+                Add(obj);
+            }
+        }
+
+        public void AddOptional(Asn1Encodable element)
+        {
+            if (element != null)
+            {
+                Add(element);
+            }
+        }
+
+        public void AddOptional(Asn1Encodable element1, Asn1Encodable element2)
+        {
+            if (element1 != null)
+            {
+                Add(element1);
+            }
+            if (element2 != null)
+            {
+                Add(element2);
+            }
+        }
+
+        public void AddOptional(params Asn1Encodable[] elements)
+        {
+            if (elements != null)
+            {
+                foreach (var element in elements)
+                {
+                    if (element != null)
+                    {
+                        Add(element);
+                    }
+                }
+            }
+        }
+
+        public void AddOptionalTagged(bool isExplicit, int tagNo, Asn1Encodable obj)
+        {
+            if (null != obj)
+            {
+                Add(new DerTaggedObject(isExplicit, tagNo, obj));
+            }
+        }
+
+        public void AddOptionalTagged(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+        {
+            if (null != obj)
+            {
+                Add(new DerTaggedObject(isExplicit, tagClass, tagNo, obj));
+            }
+        }
+
+        public void AddAll(Asn1EncodableVector other)
+        {
+            if (null == other)
+                throw new ArgumentNullException("other");
+
+            int otherElementCount = other.Count;
+            if (otherElementCount < 1)
+                return;
+
+            int capacity = elements.Length;
+            int minCapacity = elementCount + otherElementCount;
+            if ((minCapacity > capacity) | copyOnWrite)
+            {
+                Reallocate(minCapacity);
+            }
+
+            int i = 0;
+            do
+            {
+                Asn1Encodable otherElement = other[i];
+                if (null == otherElement)
+                    throw new NullReferenceException("'other' elements cannot be null");
+
+                this.elements[elementCount + i] = otherElement;
+            }
+            while (++i < otherElementCount);
+
+            this.elementCount = minCapacity;
+        }
+
+        public Asn1Encodable this[int index]
+        {
+            get
+            {
+                if (index >= elementCount)
+                    throw new IndexOutOfRangeException(index + " >= " + elementCount);
+
+                return elements[index];
+            }
+        }
+
+        public int Count
+        {
+            get { return elementCount; }
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public IEnumerator<Asn1Encodable> GetEnumerator()
+        {
+            IEnumerable<Asn1Encodable> e = CopyElements();
+            return e.GetEnumerator();
+        }
+
+        internal Asn1Encodable[] CopyElements()
+        {
+            if (0 == elementCount)
+                return EmptyElements;
+
+            Asn1Encodable[] copy = new Asn1Encodable[elementCount];
+            Array.Copy(elements, 0, copy, 0, elementCount);
+            return copy;
+        }
+
+        internal Asn1Encodable[] TakeElements()
+        {
+            if (0 == elementCount)
+                return EmptyElements;
+
+            if (elements.Length == elementCount)
+            {
+                this.copyOnWrite = true;
+                return elements;
+            }
+
+            Asn1Encodable[] copy = new Asn1Encodable[elementCount];
+            Array.Copy(elements, 0, copy, 0, elementCount);
+            return copy;
+        }
+
+        private void Reallocate(int minCapacity)
+        {
+            int oldCapacity = elements.Length;
+            int newCapacity = System.Math.Max(oldCapacity, minCapacity + (minCapacity >> 1));
+
+            Asn1Encodable[] copy = new Asn1Encodable[newCapacity];
+            Array.Copy(elements, 0, copy, 0, elementCount);
+
+            this.elements = copy;
+            this.copyOnWrite = false;
+        }
+
+        internal static Asn1Encodable[] CloneElements(Asn1Encodable[] elements)
+        {
+            return elements.Length < 1 ? EmptyElements : (Asn1Encodable[])elements.Clone();
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1EncodableVector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e3245f80405a56e41ad1c7af42022aea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Exception.cs

@@ -0,0 +1,35 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+using System.Runtime.Serialization;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    [Serializable]
+    public class Asn1Exception
+		: IOException
+	{
+		public Asn1Exception()
+			: base()
+		{
+		}
+
+		public Asn1Exception(string message)
+			: base(message)
+		{
+		}
+
+		public Asn1Exception(string message, Exception innerException)
+			: base(message, innerException)
+		{
+		}
+
+		protected Asn1Exception(SerializationInfo info, StreamingContext context)
+			: base(info, context)
+		{
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Exception.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bbd822b3cbfd4b643a313c46df1ee0a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1GeneralizedTime.cs

@@ -0,0 +1,266 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /// <summary>GeneralizedTime ASN.1 type</summary>
+    public class Asn1GeneralizedTime
+        : Asn1Object
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1GeneralizedTime), Asn1Tags.GeneralizedTime) { }
+
+            internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+            {
+                return CreatePrimitive(octetString.GetOctets());
+            }
+        }
+
+        public static Asn1GeneralizedTime GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1GeneralizedTime asn1GeneralizedTime)
+                return asn1GeneralizedTime;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1GeneralizedTime converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1GeneralizedTime)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct generalized time from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), nameof(obj));
+        }
+
+        public static Asn1GeneralizedTime GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1GeneralizedTime)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        private readonly string m_timeString;
+        private readonly bool m_timeStringCanonical;
+        private readonly DateTime m_dateTime;
+
+        public Asn1GeneralizedTime(string timeString)
+        {
+            m_timeString = timeString ?? throw new ArgumentNullException(nameof(timeString));
+            m_timeStringCanonical = false; // TODO Dynamic check?
+
+            try
+            {
+                m_dateTime = FromString(timeString);
+            }
+            catch (FormatException e)
+            {
+                throw new ArgumentException("invalid date string: " + e.Message);
+            }
+        }
+
+        public Asn1GeneralizedTime(DateTime dateTime)
+        {
+            dateTime = dateTime.ToUniversalTime();
+
+            m_dateTime = dateTime;
+            m_timeString = ToStringCanonical(dateTime);
+            m_timeStringCanonical = true;
+        }
+
+        // TODO TimeZoneInfo or other locale-specific constructors?
+
+        internal Asn1GeneralizedTime(byte[] contents)
+            : this(Encoding.ASCII.GetString(contents))
+        {
+        }
+
+        public string TimeString => m_timeString;
+
+        public DateTime ToDateTime()
+        {
+            return m_dateTime;
+        }
+
+        internal byte[] GetContents(int encoding)
+        {
+            if (encoding == Asn1OutputStream.EncodingDer && !m_timeStringCanonical)
+                return Encoding.ASCII.GetBytes(ToStringCanonical(m_dateTime));
+
+            return Encoding.ASCII.GetBytes(m_timeString);
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.GeneralizedTime, GetContents(encoding));
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            return new PrimitiveEncoding(tagClass, tagNo, GetContents(encoding));
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            if (!(asn1Object is Asn1GeneralizedTime that))
+                return false;
+
+            // TODO Performance
+            return Arrays.AreEqual(
+                this.GetContents(Asn1OutputStream.EncodingDer),
+                that.GetContents(Asn1OutputStream.EncodingDer));
+        }
+
+        protected override int Asn1GetHashCode()
+        {
+            // TODO Performance
+            return Arrays.GetHashCode(
+                this.GetContents(Asn1OutputStream.EncodingDer));
+        }
+
+        internal static Asn1GeneralizedTime CreatePrimitive(byte[] contents)
+        {
+            return new Asn1GeneralizedTime(contents);
+        }
+
+        private static DateTime FromString(string s)
+        {
+            if (s.Length < 10)
+                throw new FormatException();
+
+            s = s.Replace(',', '.');
+
+            if (Org.BouncyCastle.Utilities.Platform.EndsWith(s, "Z"))
+            {
+                switch (s.Length)
+                {
+                case 11: return ParseUtc(s, @"yyyyMMddHH\Z");
+                case 13: return ParseUtc(s, @"yyyyMMddHHmm\Z");
+                case 15: return ParseUtc(s, @"yyyyMMddHHmmss\Z");
+                case 17: return ParseUtc(s, @"yyyyMMddHHmmss.f\Z");
+                case 18: return ParseUtc(s, @"yyyyMMddHHmmss.ff\Z");
+                case 19: return ParseUtc(s, @"yyyyMMddHHmmss.fff\Z");
+                case 20: return ParseUtc(s, @"yyyyMMddHHmmss.ffff\Z");
+                case 21: return ParseUtc(s, @"yyyyMMddHHmmss.fffff\Z");
+                case 22: return ParseUtc(s, @"yyyyMMddHHmmss.ffffff\Z");
+                case 23: return ParseUtc(s, @"yyyyMMddHHmmss.fffffff\Z");
+                default:
+                    throw new FormatException();
+                }
+            }
+
+            int signIndex = IndexOfSign(s, System.Math.Max(10, s.Length - 5));
+
+            if (signIndex < 0)
+            {
+                switch (s.Length)
+                {
+                case 10: return ParseLocal(s, @"yyyyMMddHH");
+                case 12: return ParseLocal(s, @"yyyyMMddHHmm");
+                case 14: return ParseLocal(s, @"yyyyMMddHHmmss");
+                case 16: return ParseLocal(s, @"yyyyMMddHHmmss.f");
+                case 17: return ParseLocal(s, @"yyyyMMddHHmmss.ff");
+                case 18: return ParseLocal(s, @"yyyyMMddHHmmss.fff");
+                case 19: return ParseLocal(s, @"yyyyMMddHHmmss.ffff");
+                case 20: return ParseLocal(s, @"yyyyMMddHHmmss.fffff");
+                case 21: return ParseLocal(s, @"yyyyMMddHHmmss.ffffff");
+                case 22: return ParseLocal(s, @"yyyyMMddHHmmss.fffffff");
+                default:
+                    throw new FormatException();
+                }
+            }
+
+            if (signIndex == s.Length - 5)
+            {
+                switch (s.Length)
+                {
+                case 15: return ParseTimeZone(s, @"yyyyMMddHHzzz");
+                case 17: return ParseTimeZone(s, @"yyyyMMddHHmmzzz");
+                case 19: return ParseTimeZone(s, @"yyyyMMddHHmmsszzz");
+                case 21: return ParseTimeZone(s, @"yyyyMMddHHmmss.fzzz");
+                case 22: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffzzz");
+                case 23: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffzzz");
+                case 24: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffzzz");
+                case 25: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffzzz");
+                case 26: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffffzzz");
+                case 27: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffffzzz");
+                default:
+                    throw new FormatException();
+                }
+            }
+
+            if (signIndex == s.Length - 3)
+            {
+                switch (s.Length)
+                {
+                case 13: return ParseTimeZone(s, @"yyyyMMddHHzz");
+                case 15: return ParseTimeZone(s, @"yyyyMMddHHmmzz");
+                case 17: return ParseTimeZone(s, @"yyyyMMddHHmmsszz");
+                case 19: return ParseTimeZone(s, @"yyyyMMddHHmmss.fzz");
+                case 20: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffzz");
+                case 21: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffzz");
+                case 22: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffzz");
+                case 23: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffzz");
+                case 24: return ParseTimeZone(s, @"yyyyMMddHHmmss.ffffffzz");
+                case 25: return ParseTimeZone(s, @"yyyyMMddHHmmss.fffffffzz");
+                default:
+                    throw new FormatException();
+                }
+            }
+
+            throw new FormatException();
+        }
+
+        private static int IndexOfSign(string s, int startIndex)
+        {
+            int index = Org.BouncyCastle.Utilities.Platform.IndexOf(s, '+', startIndex);
+            if (index < 0)
+            {
+                index = Org.BouncyCastle.Utilities.Platform.IndexOf(s, '-', startIndex);
+            }
+            return index;
+        }
+
+        private static DateTime ParseLocal(string s, string format)
+        {
+            return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AssumeLocal);
+        }
+
+        private static DateTime ParseTimeZone(string s, string format)
+        {
+            return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AdjustToUniversal);
+        }
+
+        private static DateTime ParseUtc(string s, string format)
+        {
+            return DateTime.ParseExact(s, format, DateTimeFormatInfo.InvariantInfo,
+                DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+        }
+
+        private static string ToStringCanonical(DateTime dateTime)
+        {
+            return dateTime.ToUniversalTime().ToString(@"yyyyMMddHHmmss.FFFFFFFK", DateTimeFormatInfo.InvariantInfo);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1GeneralizedTime.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d717ef26a13ca4645a37a12bf5d48229
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1InputStream.cs

@@ -0,0 +1,471 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /**
+     * a general purpose ASN.1 decoder - note: this class differs from the
+     * others in that it returns null after it has read the last object in
+     * the stream. If an ASN.1 Null is encountered a Der/BER Null object is
+     * returned.
+     */
+    public class Asn1InputStream
+        : FilterStream
+    {
+        private readonly int limit;
+
+        internal byte[][] tmpBuffers;
+
+        internal static int FindLimit(Stream input)
+        {
+            if (input is LimitedInputStream limited)
+                return limited.Limit;
+
+            if (input is Asn1InputStream asn1)
+                return asn1.Limit;
+
+            if (input is MemoryStream memory)
+                return Convert.ToInt32(memory.Length - memory.Position);
+
+            return int.MaxValue;
+        }
+
+        public Asn1InputStream(Stream input)
+            : this(input, FindLimit(input))
+        {
+        }
+
+        /**
+         * Create an ASN1InputStream based on the input byte array. The length of DER objects in
+         * the stream is automatically limited to the length of the input array.
+         *
+         * @param input array containing ASN.1 encoded data.
+         */
+        public Asn1InputStream(byte[] input)
+            : this(new MemoryStream(input, false), input.Length)
+        {
+        }
+
+        /**
+         * Create an ASN1InputStream where no DER object will be longer than limit.
+         *
+         * @param input stream containing ASN.1 encoded data.
+         * @param limit maximum size of a DER encoded object.
+         */
+        public Asn1InputStream(Stream input, int limit)
+            : this(input, limit, new byte[16][])
+        {
+        }
+
+        internal Asn1InputStream(Stream input, int limit, byte[][] tmpBuffers)
+            : base(input)
+        {
+            this.limit = limit;
+            this.tmpBuffers = tmpBuffers;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            tmpBuffers = null;
+
+            base.Dispose(disposing);
+        }
+
+        /**
+        * build an object given its tag and the number of bytes to construct it from.
+        */
+        private Asn1Object BuildObject(int tagHdr, int tagNo, int length)
+        {
+            // TODO[asn1] Special-case zero length first?
+
+            DefiniteLengthInputStream defIn = new DefiniteLengthInputStream(s, length, limit);
+
+            if (0 == (tagHdr & Asn1Tags.Flags))
+                return CreatePrimitiveDerObject(tagNo, defIn, tmpBuffers);
+
+            int tagClass = tagHdr & Asn1Tags.Private;
+            if (0 != tagClass)
+            {
+                bool isConstructed = (tagHdr & Asn1Tags.Constructed) != 0;
+                return ReadTaggedObjectDL(tagClass, tagNo, isConstructed, defIn);
+            }
+
+            switch (tagNo)
+            {
+            case Asn1Tags.BitString:
+                return BuildConstructedBitString(ReadVector(defIn));
+            case Asn1Tags.OctetString:
+                return BuildConstructedOctetString(ReadVector(defIn));
+            case Asn1Tags.Sequence:
+                return CreateDLSequence(defIn);
+            case Asn1Tags.Set:
+                return CreateDLSet(defIn);
+            case Asn1Tags.External:
+                return DLSequence.FromVector(ReadVector(defIn)).ToAsn1External();
+            default:
+                throw new IOException("unknown tag " + tagNo + " encountered");
+            }
+        }
+
+        internal Asn1Object ReadTaggedObjectDL(int tagClass, int tagNo, bool constructed, DefiniteLengthInputStream defIn)
+        {
+            if (!constructed)
+            {
+                byte[] contentsOctets = defIn.ToArray();
+                return Asn1TaggedObject.CreatePrimitive(tagClass, tagNo, contentsOctets);
+            }
+
+            Asn1EncodableVector contentsElements = ReadVector(defIn);
+            return Asn1TaggedObject.CreateConstructedDL(tagClass, tagNo, contentsElements);
+        }
+
+        internal virtual Asn1EncodableVector ReadVector()
+        {
+            Asn1Object o = ReadObject();
+            if (null == o)
+                return new Asn1EncodableVector(0);
+
+            Asn1EncodableVector v = new Asn1EncodableVector();
+            do
+            {
+                v.Add(o);
+            }
+            while ((o = ReadObject()) != null);
+            return v;
+        }
+
+        internal virtual Asn1EncodableVector ReadVector(DefiniteLengthInputStream defIn)
+        {
+            int remaining = defIn.Remaining;
+            if (remaining < 1)
+                return new Asn1EncodableVector(0);
+
+            return new Asn1InputStream(defIn, remaining, tmpBuffers).ReadVector();
+        }
+
+        internal virtual Asn1Sequence CreateDLSequence(DefiniteLengthInputStream defIn)
+        {
+            return DLSequence.FromVector(ReadVector(defIn));
+        }
+
+        internal virtual Asn1Set CreateDLSet(DefiniteLengthInputStream defIn)
+        {
+            return DLSet.FromVector(ReadVector(defIn));
+        }
+
+        public Asn1Object ReadObject()
+        {
+            int tagHdr = s.ReadByte();
+            if (tagHdr <= 0)
+            {
+                if (tagHdr == 0)
+                    throw new IOException("unexpected end-of-contents marker");
+
+                return null;
+            }
+
+            int tagNo = ReadTagNumber(s, tagHdr);
+            int length = ReadLength(s, limit, false);
+
+            if (length >= 0)
+            {
+                // definite-length
+                try
+                {
+                    return BuildObject(tagHdr, tagNo, length);
+                }
+                catch (ArgumentException e)
+                {
+                    throw new Asn1Exception("corrupted stream detected", e);
+                }
+            }
+
+            // indefinite-length
+
+            if (0 == (tagHdr & Asn1Tags.Constructed))
+                throw new IOException("indefinite-length primitive encoding encountered");
+
+            IndefiniteLengthInputStream indIn = new IndefiniteLengthInputStream(s, limit);
+            Asn1StreamParser sp = new Asn1StreamParser(indIn, limit, tmpBuffers);
+
+            int tagClass = tagHdr & Asn1Tags.Private;
+            if (0 != tagClass)
+                return sp.LoadTaggedIL(tagClass, tagNo);
+
+            switch (tagNo)
+            {
+            case Asn1Tags.BitString:
+                return BerBitStringParser.Parse(sp);
+            case Asn1Tags.OctetString:
+                return BerOctetStringParser.Parse(sp);
+            case Asn1Tags.Sequence:
+                return BerSequenceParser.Parse(sp);
+            case Asn1Tags.Set:
+                return BerSetParser.Parse(sp);
+            case Asn1Tags.External:
+                // TODO[asn1] BerExternalParser
+                return DerExternalParser.Parse(sp);
+            default:
+                throw new IOException("unknown BER object encountered");
+            }
+        }
+
+        internal virtual DerBitString BuildConstructedBitString(Asn1EncodableVector contentsElements)
+        {
+            DerBitString[] bitStrings = new DerBitString[contentsElements.Count];
+
+            for (int i = 0; i != bitStrings.Length; i++)
+            {
+                DerBitString bitString = contentsElements[i] as DerBitString;
+                if (null == bitString)
+                    throw new Asn1Exception("unknown object encountered in constructed BIT STRING: "
+                        + Org.BouncyCastle.Utilities.Platform.GetTypeName(contentsElements[i]));
+
+                bitStrings[i] = bitString;
+            }
+
+            return new DLBitString(BerBitString.FlattenBitStrings(bitStrings), false);
+        }
+
+        internal virtual Asn1OctetString BuildConstructedOctetString(Asn1EncodableVector contentsElements)
+        {
+            Asn1OctetString[] octetStrings = new Asn1OctetString[contentsElements.Count];
+
+            for (int i = 0; i != octetStrings.Length; i++)
+            {
+                Asn1OctetString octetString = contentsElements[i] as Asn1OctetString;
+                if (null == octetString)
+                    throw new Asn1Exception("unknown object encountered in constructed OCTET STRING: "
+                        + Org.BouncyCastle.Utilities.Platform.GetTypeName(contentsElements[i]));
+
+                octetStrings[i] = octetString;
+            }
+
+            // Note: No DLOctetString available
+            return new DerOctetString(BerOctetString.FlattenOctetStrings(octetStrings));
+        }
+
+        internal virtual int Limit
+        {
+            get { return limit; }
+        }
+
+        internal static int ReadTagNumber(Stream s, int tagHdr)
+        {
+            int tagNo = tagHdr & 0x1f;
+
+            //
+            // with tagged object tag number is bottom 5 bits, or stored at the start of the content
+            //
+            if (tagNo == 0x1f)
+            {
+                int b = s.ReadByte();
+                if (b < 31)
+                {
+                    if (b < 0)
+                        throw new EndOfStreamException("EOF found inside tag value.");
+
+                    throw new IOException("corrupted stream - high tag number < 31 found");
+                }
+
+                tagNo = b & 0x7f;
+
+                // X.690-0207 8.1.2.4.2
+                // "c) bits 7 to 1 of the first subsequent octet shall not all be zero."
+                if (0 == tagNo)
+                    throw new IOException("corrupted stream - invalid high tag number found");
+
+                while ((b & 0x80) != 0)
+                {
+                    if (((uint)tagNo >> 24) != 0U)
+                        throw new IOException("Tag number more than 31 bits");
+
+                    tagNo <<= 7;
+
+                    b = s.ReadByte();
+                    if (b < 0)
+                        throw new EndOfStreamException("EOF found inside tag value.");
+
+                    tagNo |= b & 0x7f;
+                }
+            }
+
+            return tagNo;
+        }
+
+        internal static int ReadLength(Stream s, int limit, bool isParsing)
+        {
+            int length = s.ReadByte();
+            if (0U == ((uint)length >> 7))
+            {
+                // definite-length short form 
+                return length;
+            }
+            if (0x80 == length)
+            {
+                // indefinite-length
+                return -1;
+            }
+            if (length < 0)
+            {
+                throw new EndOfStreamException("EOF found when length expected");
+            }
+            if (0xFF == length)
+            {
+                throw new IOException("invalid long form definite-length 0xFF");
+            }
+
+            int octetsCount = length & 0x7F, octetsPos = 0;
+
+            length = 0;
+            do
+            {
+                int octet = s.ReadByte();
+                if (octet < 0)
+                    throw new EndOfStreamException("EOF found reading length");
+
+                if (((uint)length >> 23) != 0U)
+                    throw new IOException("long form definite-length more than 31 bits");
+
+                length = (length << 8) + octet;
+            }
+            while (++octetsPos < octetsCount);
+
+            if (length >= limit && !isParsing)   // after all we must have read at least 1 byte
+                throw new IOException("corrupted stream - out of bounds length found: " + length + " >= " + limit);
+
+            return length;
+        }
+
+        private static byte[] GetBuffer(DefiniteLengthInputStream defIn, byte[][] tmpBuffers)
+        {
+            int len = defIn.Remaining;
+            if (len >= tmpBuffers.Length)
+            {
+                return defIn.ToArray();
+            }
+
+            byte[] buf = tmpBuffers[len];
+            if (buf == null)
+            {
+                buf = tmpBuffers[len] = new byte[len];
+            }
+
+            defIn.ReadAllIntoByteArray(buf);
+
+            return buf;
+        }
+
+        private static char[] GetBmpCharBuffer(DefiniteLengthInputStream defIn)
+        {
+            int remainingBytes = defIn.Remaining;
+            if (0 != (remainingBytes & 1))
+                throw new IOException("malformed BMPString encoding encountered");
+
+            char[] str = new char[remainingBytes / 2];
+            int stringPos = 0;
+
+            byte[] buf = new byte[8];
+            while (remainingBytes >= 8)
+            {
+                if (Streams.ReadFully(defIn, buf, 0, 8) != 8)
+                    throw new EndOfStreamException("EOF encountered in middle of BMPString");
+
+                str[stringPos    ] = (char)((buf[0] << 8) | (buf[1] & 0xFF));
+                str[stringPos + 1] = (char)((buf[2] << 8) | (buf[3] & 0xFF));
+                str[stringPos + 2] = (char)((buf[4] << 8) | (buf[5] & 0xFF));
+                str[stringPos + 3] = (char)((buf[6] << 8) | (buf[7] & 0xFF));
+                stringPos += 4;
+                remainingBytes -= 8;
+            }
+            if (remainingBytes > 0)
+            {
+                if (Streams.ReadFully(defIn, buf, 0, remainingBytes) != remainingBytes)
+                    throw new EndOfStreamException("EOF encountered in middle of BMPString");
+
+                int bufPos = 0;
+                do
+                {
+                    int b1 = buf[bufPos++] << 8;
+                    int b2 = buf[bufPos++] & 0xFF;
+                    str[stringPos++] = (char)(b1 | b2);
+                }
+                while (bufPos < remainingBytes);
+            }
+
+            if (0 != defIn.Remaining || str.Length != stringPos)
+                throw new InvalidOperationException();
+
+            return str;
+        }
+
+        internal static Asn1Object CreatePrimitiveDerObject(int tagNo, DefiniteLengthInputStream defIn,
+            byte[][] tmpBuffers)
+        {
+            switch (tagNo)
+            {
+            case Asn1Tags.BmpString:
+                return DerBmpString.CreatePrimitive(GetBmpCharBuffer(defIn));
+            case Asn1Tags.Boolean:
+                return DerBoolean.CreatePrimitive(GetBuffer(defIn, tmpBuffers));
+            case Asn1Tags.Enumerated:
+                // TODO Ideally only clone if we used a buffer
+                return DerEnumerated.CreatePrimitive(GetBuffer(defIn, tmpBuffers), true);
+            case Asn1Tags.ObjectIdentifier:
+                // TODO Ideally only clone if we used a buffer
+                return DerObjectIdentifier.CreatePrimitive(GetBuffer(defIn, tmpBuffers), true);
+            }
+
+            byte[] bytes = defIn.ToArray();
+
+            switch (tagNo)
+            {
+            case Asn1Tags.BitString:
+                return DerBitString.CreatePrimitive(bytes);
+            case Asn1Tags.GeneralizedTime:
+                return Asn1GeneralizedTime.CreatePrimitive(bytes);
+            case Asn1Tags.GeneralString:
+                return DerGeneralString.CreatePrimitive(bytes);
+            case Asn1Tags.GraphicString:
+                return DerGraphicString.CreatePrimitive(bytes);
+            case Asn1Tags.IA5String:
+                return DerIA5String.CreatePrimitive(bytes);
+            case Asn1Tags.Integer:
+                return DerInteger.CreatePrimitive(bytes);
+            case Asn1Tags.Null:
+                return Asn1Null.CreatePrimitive(bytes);
+            case Asn1Tags.NumericString:
+                return DerNumericString.CreatePrimitive(bytes);
+            case Asn1Tags.ObjectDescriptor:
+                return Asn1ObjectDescriptor.CreatePrimitive(bytes);
+            case Asn1Tags.OctetString:
+                return Asn1OctetString.CreatePrimitive(bytes);
+            case Asn1Tags.PrintableString:
+                return DerPrintableString.CreatePrimitive(bytes);
+            case Asn1Tags.RelativeOid:
+                return Asn1RelativeOid.CreatePrimitive(bytes, false);
+            case Asn1Tags.T61String:
+                return DerT61String.CreatePrimitive(bytes);
+            case Asn1Tags.UniversalString:
+                return DerUniversalString.CreatePrimitive(bytes);
+            case Asn1Tags.UtcTime:
+                return Asn1UtcTime.CreatePrimitive(bytes);
+            case Asn1Tags.Utf8String:
+                return DerUtf8String.CreatePrimitive(bytes);
+            case Asn1Tags.VideotexString:
+                return DerVideotexString.CreatePrimitive(bytes);
+            case Asn1Tags.VisibleString:
+                return DerVisibleString.CreatePrimitive(bytes);
+            default:
+                throw new IOException("unknown tag " + tagNo + " encountered");
+            }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1InputStream.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e252ac704e464264d8409a56a0bb3eb3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Null.cs

@@ -0,0 +1,81 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /**
+     * A Null object.
+     */
+    public abstract class Asn1Null
+        : Asn1Object
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1Null), Asn1Tags.Null) {}
+
+            internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+            {
+                return CreatePrimitive(octetString.GetOctets());
+            }
+        }
+
+        public static Asn1Null GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1Null asn1Null)
+                return asn1Null;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1Null converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1Null)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct NULL from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj));
+        }
+
+        public static Asn1Null GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1Null)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        internal Asn1Null()
+        {
+        }
+
+        public override string ToString()
+        {
+            return "NULL";
+        }
+
+        internal static Asn1Null CreatePrimitive(byte[] contents)
+        {
+            if (0 != contents.Length)
+                throw new InvalidOperationException("malformed NULL encoding encountered");
+
+            return DerNull.Instance;
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Null.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b6ffeb7c543040429c96c7fa0041261
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Object.cs

@@ -0,0 +1,95 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class Asn1Object
+		: Asn1Encodable
+    {
+        public override void EncodeTo(Stream output)
+        {
+            Asn1OutputStream asn1Out = Asn1OutputStream.Create(output);
+            GetEncoding(asn1Out.Encoding).Encode(asn1Out);
+            asn1Out.FlushInternal();
+        }
+
+        public override void EncodeTo(Stream output, string encoding)
+        {
+            Asn1OutputStream asn1Out = Asn1OutputStream.Create(output, encoding);
+            GetEncoding(asn1Out.Encoding).Encode(asn1Out);
+            asn1Out.FlushInternal();
+        }
+
+        public bool Equals(Asn1Object other)
+        {
+            return this == other || Asn1Equals(other);
+        }
+
+        /// <summary>Create a base ASN.1 object from a byte array.</summary>
+        /// <param name="data">The byte array to parse.</param>
+        /// <returns>The base ASN.1 object represented by the byte array.</returns>
+        /// <exception cref="IOException">
+        /// If there is a problem parsing the data, or parsing an object did not exhaust the available data.
+        /// </exception>
+        public static Asn1Object FromByteArray(
+			byte[] data)
+		{
+            try
+			{
+                MemoryStream input = new MemoryStream(data, false);
+                Asn1InputStream asn1 = new Asn1InputStream(input, data.Length);
+                Asn1Object result = asn1.ReadObject();
+                if (input.Position != input.Length)
+                    throw new IOException("extra data found after object");
+                return result;
+			}
+			catch (InvalidCastException)
+			{
+				throw new IOException("cannot recognise object in byte array");
+			}
+		}
+
+		/// <summary>Read a base ASN.1 object from a stream.</summary>
+		/// <param name="inStr">The stream to parse.</param>
+		/// <returns>The base ASN.1 object represented by the byte array.</returns>
+		/// <exception cref="IOException">If there is a problem parsing the data.</exception>
+		public static Asn1Object FromStream(
+			Stream inStr)
+		{
+			try
+			{
+				return new Asn1InputStream(inStr).ReadObject();
+			}
+			catch (InvalidCastException)
+			{
+				throw new IOException("cannot recognise object in stream");
+			}
+		}
+
+		public sealed override Asn1Object ToAsn1Object()
+        {
+            return this;
+        }
+
+        internal abstract IAsn1Encoding GetEncoding(int encoding);
+
+        internal abstract IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo);
+
+        protected abstract bool Asn1Equals(Asn1Object asn1Object);
+		protected abstract int Asn1GetHashCode();
+
+		internal bool CallAsn1Equals(Asn1Object obj)
+		{
+			return Asn1Equals(obj);
+		}
+
+		internal int CallAsn1GetHashCode()
+		{
+			return Asn1GetHashCode();
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Object.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86b4801bceb05f54ab0490784feb75c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1ObjectDescriptor.cs

@@ -0,0 +1,125 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public sealed class Asn1ObjectDescriptor
+        : Asn1Object
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1ObjectDescriptor), Asn1Tags.ObjectDescriptor) {}
+
+            internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+            {
+                return new Asn1ObjectDescriptor(
+                    (DerGraphicString)DerGraphicString.Meta.Instance.FromImplicitPrimitive(octetString));
+            }
+
+            internal override Asn1Object FromImplicitConstructed(Asn1Sequence sequence)
+            {
+                return new Asn1ObjectDescriptor(
+                    (DerGraphicString)DerGraphicString.Meta.Instance.FromImplicitConstructed(sequence));
+            }
+        }
+
+        /**
+         * Return an ObjectDescriptor from the passed in object.
+         *
+         * @param obj an ASN1ObjectDescriptor or an object that can be converted into one.
+         * @exception IllegalArgumentException if the object cannot be converted.
+         * @return an ASN1ObjectDescriptor instance, or null.
+         */
+        public static Asn1ObjectDescriptor GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1ObjectDescriptor asn1ObjectDescriptor)
+                return asn1ObjectDescriptor;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1ObjectDescriptor converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1ObjectDescriptor)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct object descriptor from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), "obj");
+        }
+
+        /**
+         * Return an ObjectDescriptor from a tagged object.
+         *
+         * @param taggedObject the tagged object holding the object we want.
+         * @param declaredExplicit true if the object is meant to be explicitly tagged, false otherwise.
+         * @exception IllegalArgumentException if the tagged object cannot be converted.
+         * @return an ASN1ObjectDescriptor instance, or null.
+         */
+        public static Asn1ObjectDescriptor GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1ObjectDescriptor)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        private readonly DerGraphicString m_baseGraphicString;
+
+        public Asn1ObjectDescriptor(DerGraphicString baseGraphicString)
+        {
+            if (null == baseGraphicString)
+                throw new ArgumentNullException("baseGraphicString");
+
+            this.m_baseGraphicString = baseGraphicString;
+        }
+
+        public DerGraphicString BaseGraphicString
+        {
+            get { return m_baseGraphicString; }
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            return m_baseGraphicString.GetEncodingImplicit(encoding, Asn1Tags.Universal, Asn1Tags.ObjectDescriptor);
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            return m_baseGraphicString.GetEncodingImplicit(encoding, tagClass, tagNo);
+        }
+
+        protected override int Asn1GetHashCode()
+        {
+            return ~m_baseGraphicString.CallAsn1GetHashCode();
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            Asn1ObjectDescriptor that = asn1Object as Asn1ObjectDescriptor;
+            return null != that
+                && this.m_baseGraphicString.Equals(that.m_baseGraphicString);
+        }
+
+        internal static Asn1ObjectDescriptor CreatePrimitive(byte[] contents)
+        {
+            return new Asn1ObjectDescriptor(DerGraphicString.CreatePrimitive(contents));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1ObjectDescriptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef670ce0aae993744a256d3bb7362b31
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1OctetString.cs

@@ -0,0 +1,136 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Encoders;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class Asn1OctetString
+        : Asn1Object, Asn1OctetStringParser
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1OctetString), Asn1Tags.OctetString) {}
+
+            internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+            {
+                return octetString;
+            }
+
+            internal override Asn1Object FromImplicitConstructed(Asn1Sequence sequence)
+            {
+                return sequence.ToAsn1OctetString();
+            }
+        }
+
+        internal static readonly byte[] EmptyOctets = new byte[0];
+
+        /**
+         * return an Octet string from the given object.
+         *
+         * @param obj the object we want converted.
+         * @exception ArgumentException if the object cannot be converted.
+         */
+        public static Asn1OctetString GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1OctetString asn1OctetString)
+                return asn1OctetString;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1OctetString converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1OctetString)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct OCTET STRING from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), "obj");
+        }
+
+        /**
+         * return an octet string from a tagged object.
+         *
+         * @param taggedObject the tagged object holding the object we want.
+         * @param declaredExplicit true if the object is meant to be explicitly tagged false otherwise.
+         * @exception ArgumentException if the tagged object cannot be converted.
+         */
+        public static Asn1OctetString GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1OctetString)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        internal readonly byte[] contents;
+
+        /**
+         * @param string the octets making up the octet string.
+         */
+        internal Asn1OctetString(byte[] contents)
+        {
+			if (null == contents)
+				throw new ArgumentNullException("contents");
+
+			this.contents = contents;
+        }
+
+        public Stream GetOctetStream()
+		{
+			return new MemoryStream(contents, false);
+		}
+
+		public Asn1OctetStringParser Parser
+		{
+			get { return this; }
+		}
+
+		public virtual byte[] GetOctets()
+        {
+            return contents;
+        }
+
+		protected override int Asn1GetHashCode()
+		{
+			return Arrays.GetHashCode(GetOctets());
+        }
+
+		protected override bool Asn1Equals(
+			Asn1Object asn1Object)
+		{
+			DerOctetString other = asn1Object as DerOctetString;
+
+			if (other == null)
+				return false;
+
+			return Arrays.AreEqual(GetOctets(), other.GetOctets());
+		}
+
+		public override string ToString()
+		{
+			return "#" + Hex.ToHexString(contents);
+		}
+
+        internal static Asn1OctetString CreatePrimitive(byte[] contents)
+        {
+            return new DerOctetString(contents);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1OctetString.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 605a6b277ffde7640a895840c2243816
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1OutputStream.cs

@@ -0,0 +1,192 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+using System.Diagnostics;
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+using System.Buffers.Binary;
+using System.Numerics;
+#endif
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class Asn1OutputStream
+        : FilterStream
+    {
+        internal const int EncodingBer = 1;
+        internal const int EncodingDer = 2;
+
+        public static Asn1OutputStream Create(Stream output)
+        {
+            return new Asn1OutputStream(output);
+        }
+
+        public static Asn1OutputStream Create(Stream output, string encoding)
+        {
+            if (Asn1Encodable.Der.Equals(encoding))
+            {
+                return new DerOutputStream(output);
+            }
+            else
+            {
+                return new Asn1OutputStream(output);
+            }
+        }
+
+        internal Asn1OutputStream(Stream os)
+            : base(os)
+        {
+        }
+
+        public virtual void WriteObject(Asn1Encodable asn1Encodable)
+        {
+            if (null == asn1Encodable)
+                throw new ArgumentNullException("asn1Encodable");
+
+            asn1Encodable.ToAsn1Object().GetEncoding(this.Encoding).Encode(this);
+            FlushInternal();
+        }
+
+        public virtual void WriteObject(Asn1Object asn1Object)
+        {
+            if (null == asn1Object)
+                throw new ArgumentNullException("asn1Object");
+
+            asn1Object.GetEncoding(this.Encoding).Encode(this);
+            FlushInternal();
+        }
+
+        internal void EncodeContents(IAsn1Encoding[] contentsEncodings)
+        {
+            for (int i = 0, count = contentsEncodings.Length; i < count; ++i)
+            {
+                contentsEncodings[i].Encode(this);
+            }
+        }
+
+        internal virtual int Encoding
+        {
+            get { return EncodingBer; }
+        }
+
+        internal void FlushInternal()
+        {
+            // Placeholder to support future internal buffering
+        }
+
+        internal void WriteDL(int dl)
+        {
+            if (dl < 128)
+            {
+                Debug.Assert(dl >= 0);
+                WriteByte((byte)dl);
+                return;
+            }
+
+#if false && (NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_)
+            Span<byte> encoding = stackalloc byte[5];
+            BinaryPrimitives.WriteUInt32BigEndian(encoding[1..], (uint)dl);
+            int leadingZeroBytes = BitOperations.LeadingZeroCount((uint)dl) / 8;
+            encoding[leadingZeroBytes] = (byte)(0x84 - leadingZeroBytes);
+            Write(encoding[leadingZeroBytes..]);
+#else
+            byte[] stack = new byte[5];
+            int pos = stack.Length;
+
+            do
+            {
+                stack[--pos] = (byte)dl;
+                dl >>= 8;
+            }
+            while (dl > 0);
+
+            int count = stack.Length - pos;
+            stack[--pos] = (byte)(0x80 | count);
+
+            Write(stack, pos, count + 1);
+#endif
+        }
+
+        internal void WriteIdentifier(int tagClass, int tagNo)
+        {
+            if (tagNo < 31)
+            {
+                WriteByte((byte)(tagClass | tagNo));
+                return;
+            }
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+            Span<byte> stack = stackalloc byte[6];
+#else
+            byte[] stack = new byte[6];
+#endif
+            int pos = stack.Length;
+
+            stack[--pos] = (byte)(tagNo & 0x7F);
+            while (tagNo > 127)
+            {
+                tagNo >>= 7;
+                stack[--pos] = (byte)(tagNo & 0x7F | 0x80);
+            }
+
+            stack[--pos] = (byte)(tagClass | 0x1F);
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+            Write(stack[pos..]);
+#else
+            Write(stack, pos, stack.Length - pos);
+#endif
+        }
+
+        internal static IAsn1Encoding[] GetContentsEncodings(int encoding, Asn1Encodable[] elements)
+        {
+            int count = elements.Length;
+            IAsn1Encoding[] contentsEncodings = new IAsn1Encoding[count];
+            for (int i = 0; i < count; ++i)
+            {
+                contentsEncodings[i] = elements[i].ToAsn1Object().GetEncoding(encoding);
+            }
+            return contentsEncodings;
+        }
+
+        internal static int GetLengthOfContents(IAsn1Encoding[] contentsEncodings)
+        {
+            int contentsLength = 0;
+            for (int i = 0, count = contentsEncodings.Length; i < count; ++i)
+            {
+                contentsLength += contentsEncodings[i].GetLength();
+            }
+            return contentsLength;
+        }
+
+        internal static int GetLengthOfDL(int dl)
+        {
+            if (dl < 128)
+                return 1;
+
+            int length = 2;
+            while ((dl >>= 8) > 0)
+            {
+                ++length;
+            }
+            return length;
+        }
+
+        internal static int GetLengthOfIdentifier(int tagNo)
+        {
+            if (tagNo < 31)
+                return 1;
+
+            int length = 2;
+            while ((tagNo >>= 7) > 0)
+            {
+                ++length;
+            }
+            return length;
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1OutputStream.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ca2e340a1bd44254cac396effbb16cda
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1ParsingException.cs

@@ -0,0 +1,34 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Runtime.Serialization;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    [Serializable]
+    public class Asn1ParsingException
+		: InvalidOperationException
+	{
+		public Asn1ParsingException()
+			: base()
+		{
+		}
+
+		public Asn1ParsingException(string message)
+			: base(message)
+		{
+		}
+
+		public Asn1ParsingException(string message, Exception innerException)
+			: base(message, innerException)
+		{
+		}
+
+		protected Asn1ParsingException(SerializationInfo info, StreamingContext context)
+			: base(info, context)
+		{
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1ParsingException.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e565a5f2f13a702468596b17c248ac68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1RelativeOid.cs

@@ -0,0 +1,320 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+using System.Text;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Math;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class Asn1RelativeOid
+        : Asn1Object
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1RelativeOid), Asn1Tags.RelativeOid) {}
+
+            internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+            {
+                return CreatePrimitive(octetString.GetOctets(), false);
+            }
+        }
+
+        public static Asn1RelativeOid FromContents(byte[] contents)
+        {
+            return CreatePrimitive(contents, true);
+        }
+
+        public static Asn1RelativeOid GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1RelativeOid asn1RelativeOid)
+                return asn1RelativeOid;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1RelativeOid converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1RelativeOid)FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct relative OID from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), "obj");
+        }
+
+        public static Asn1RelativeOid GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1RelativeOid)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        private const long LongLimit = (long.MaxValue >> 7) - 0x7F;
+
+        private readonly string identifier;
+        private byte[] contents;
+
+        public Asn1RelativeOid(string identifier)
+        {
+            if (identifier == null)
+                throw new ArgumentNullException("identifier");
+            if (!IsValidIdentifier(identifier, 0))
+                throw new FormatException("string " + identifier + " not a relative OID");
+
+            this.identifier = identifier;
+        }
+
+        private Asn1RelativeOid(Asn1RelativeOid oid, string branchID)
+        {
+            if (!IsValidIdentifier(branchID, 0))
+                throw new FormatException("string " + branchID + " not a valid relative OID branch");
+
+            this.identifier = oid.Id + "." + branchID;
+        }
+
+        private Asn1RelativeOid(byte[] contents, bool clone)
+        {
+            this.identifier = ParseContents(contents);
+            this.contents = clone ? Arrays.Clone(contents) : contents;
+        }
+
+        public virtual Asn1RelativeOid Branch(string branchID)
+        {
+            return new Asn1RelativeOid(this, branchID);
+        }
+
+        public string Id
+        {
+            get { return identifier; }
+        }
+
+        public override string ToString()
+        {
+            return identifier;
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            Asn1RelativeOid that = asn1Object as Asn1RelativeOid;
+            return null != that
+                && this.identifier == that.identifier;
+        }
+
+        protected override int Asn1GetHashCode()
+        {
+            return identifier.GetHashCode();
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.RelativeOid, GetContents());
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            return new PrimitiveEncoding(tagClass, tagNo, GetContents());
+        }
+
+        private void DoOutput(MemoryStream bOut)
+        {
+            OidTokenizer tok = new OidTokenizer(identifier);
+            while (tok.HasMoreTokens)
+            {
+                string token = tok.NextToken();
+                if (token.Length <= 18)
+                {
+                    WriteField(bOut, long.Parse(token));
+                }
+                else
+                {
+                    WriteField(bOut, new BigInteger(token));
+                }
+            }
+        }
+
+        private byte[] GetContents()
+        {
+            lock (this)
+            {
+                if (contents == null)
+                {
+                    MemoryStream bOut = new MemoryStream();
+                    DoOutput(bOut);
+                    contents = bOut.ToArray();
+                }
+
+                return contents;
+            }
+        }
+
+        internal static Asn1RelativeOid CreatePrimitive(byte[] contents, bool clone)
+        {
+            return new Asn1RelativeOid(contents, clone);
+        }
+
+        internal static bool IsValidIdentifier(string identifier, int from)
+        {
+            int digitCount = 0;
+
+            int pos = identifier.Length;
+            while (--pos >= from)
+            {
+                char ch = identifier[pos];
+
+                if (ch == '.')
+                {
+                    if (0 == digitCount || (digitCount > 1 && identifier[pos + 1] == '0'))
+                        return false;
+
+                    digitCount = 0;
+                }
+                else if ('0' <= ch && ch <= '9')
+                {
+                    ++digitCount;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            if (0 == digitCount || (digitCount > 1 && identifier[pos + 1] == '0'))
+                return false;
+
+            return true;
+        }
+
+        internal static void WriteField(Stream outputStream, long fieldValue)
+        {
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+            Span<byte> result = stackalloc byte[9];
+#else
+            byte[] result = new byte[9];
+#endif
+            int pos = 8;
+            result[pos] = (byte)((int)fieldValue & 0x7F);
+            while (fieldValue >= (1L << 7))
+            {
+                fieldValue >>= 7;
+                result[--pos] = (byte)((int)fieldValue | 0x80);
+            }
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+            outputStream.Write(result[pos..]);
+#else
+            outputStream.Write(result, pos, 9 - pos);
+#endif
+        }
+
+        internal static void WriteField(Stream outputStream, BigInteger fieldValue)
+        {
+            int byteCount = (fieldValue.BitLength + 6) / 7;
+            if (byteCount == 0)
+            {
+                outputStream.WriteByte(0);
+            }
+            else
+            {
+                BigInteger tmpValue = fieldValue;
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+                Span<byte> tmp = byteCount <= 16
+                    ? stackalloc byte[byteCount]
+                    : new byte[byteCount];
+#else
+                byte[] tmp = new byte[byteCount];
+#endif
+                for (int i = byteCount - 1; i >= 0; i--)
+                {
+                    tmp[i] = (byte)(tmpValue.IntValue | 0x80);
+                    tmpValue = tmpValue.ShiftRight(7);
+                }
+                tmp[byteCount - 1] &= 0x7F;
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+                outputStream.Write(tmp);
+#else
+                outputStream.Write(tmp, 0, tmp.Length);
+#endif
+            }
+        }
+
+        private static string ParseContents(byte[] contents)
+        {
+            StringBuilder objId = new StringBuilder();
+            long value = 0;
+            BigInteger bigValue = null;
+            bool first = true;
+
+            for (int i = 0; i != contents.Length; i++)
+            {
+                int b = contents[i];
+
+                if (value <= LongLimit)
+                {
+                    value += b & 0x7F;
+                    if ((b & 0x80) == 0)
+                    {
+                        if (first)
+                        {
+                            first = false;
+                        }
+                        else
+                        {
+                            objId.Append('.');
+                        }
+
+                        objId.Append(value);
+                        value = 0;
+                    }
+                    else
+                    {
+                        value <<= 7;
+                    }
+                }
+                else
+                {
+                    if (bigValue == null)
+                    {
+                        bigValue = BigInteger.ValueOf(value);
+                    }
+                    bigValue = bigValue.Or(BigInteger.ValueOf(b & 0x7F));
+                    if ((b & 0x80) == 0)
+                    {
+                        if (first)
+                        {
+                            first = false;
+                        }
+                        else
+                        {
+                            objId.Append('.');
+                        }
+
+                        objId.Append(bigValue);
+                        bigValue = null;
+                        value = 0;
+                    }
+                    else
+                    {
+                        bigValue = bigValue.ShiftLeft(7);
+                    }
+                }
+            }
+
+            return objId.ToString();
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1RelativeOid.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae6c5229271568c4f968518558270b85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Sequence.cs

@@ -0,0 +1,284 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Collections;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class Asn1Sequence
+        : Asn1Object, IEnumerable<Asn1Encodable>
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1Sequence), Asn1Tags.Sequence) {}
+
+            internal override Asn1Object FromImplicitConstructed(Asn1Sequence sequence)
+            {
+                return sequence;
+            }
+        }
+
+        /**
+         * return an Asn1Sequence from the given object.
+         *
+         * @param obj the object we want converted.
+         * @exception ArgumentException if the object cannot be converted.
+         */
+        public static Asn1Sequence GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1Sequence asn1Sequence)
+                return asn1Sequence;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1Sequence converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1Sequence)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct sequence from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), "obj");
+        }
+
+        /**
+         * Return an ASN1 sequence from a tagged object. There is a special
+         * case here, if an object appears to have been explicitly tagged on
+         * reading but we were expecting it to be implicitly tagged in the
+         * normal course of events it indicates that we lost the surrounding
+         * sequence - so we need to add it back (this will happen if the tagged
+         * object is a sequence that contains other sequences). If you are
+         * dealing with implicitly tagged sequences you really <b>should</b>
+         * be using this method.
+         *
+         * @param taggedObject the tagged object.
+         * @param declaredExplicit true if the object is meant to be explicitly tagged, false otherwise.
+         * @exception ArgumentException if the tagged object cannot be converted.
+         */
+        public static Asn1Sequence GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1Sequence)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        // NOTE: Only non-readonly to support LazyDLSequence
+        internal Asn1Encodable[] elements;
+
+        protected internal Asn1Sequence()
+        {
+            this.elements = Asn1EncodableVector.EmptyElements;
+        }
+
+        protected internal Asn1Sequence(Asn1Encodable element)
+        {
+            if (null == element)
+                throw new ArgumentNullException(nameof(element));
+
+            this.elements = new Asn1Encodable[]{ element };
+        }
+
+        protected internal Asn1Sequence(Asn1Encodable element1, Asn1Encodable element2)
+        {
+            if (null == element1)
+                throw new ArgumentNullException(nameof(element1));
+            if (null == element2)
+                throw new ArgumentNullException(nameof(element2));
+
+            this.elements = new Asn1Encodable[]{ element1, element2 };
+        }
+
+        protected internal Asn1Sequence(params Asn1Encodable[] elements)
+        {
+            if (Arrays.IsNullOrContainsNull(elements))
+                throw new NullReferenceException("'elements' cannot be null, or contain null");
+
+            this.elements = Asn1EncodableVector.CloneElements(elements);
+        }
+
+        internal Asn1Sequence(Asn1Encodable[] elements, bool clone)
+        {
+            this.elements = clone ? Asn1EncodableVector.CloneElements(elements) : elements;
+        }
+
+        protected internal Asn1Sequence(Asn1EncodableVector elementVector)
+        {
+            if (null == elementVector)
+                throw new ArgumentNullException("elementVector");
+
+            this.elements = elementVector.TakeElements();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public virtual IEnumerator<Asn1Encodable> GetEnumerator()
+        {
+            IEnumerable<Asn1Encodable> e = elements;
+            return e.GetEnumerator();
+        }
+
+        private class Asn1SequenceParserImpl
+            : Asn1SequenceParser
+        {
+            private readonly Asn1Sequence outer;
+            private readonly int max;
+            private int index;
+
+            public Asn1SequenceParserImpl(
+                Asn1Sequence outer)
+            {
+                this.outer = outer;
+                // NOTE: Call Count here to 'force' a LazyDerSequence
+                this.max = outer.Count;
+            }
+
+            public IAsn1Convertible ReadObject()
+            {
+                if (index == max)
+                    return null;
+
+                Asn1Encodable obj = outer[index++];
+
+                if (obj is Asn1Sequence)
+                    return ((Asn1Sequence)obj).Parser;
+
+                if (obj is Asn1Set)
+                    return ((Asn1Set)obj).Parser;
+
+                // NB: Asn1OctetString implements Asn1OctetStringParser directly
+//				if (obj is Asn1OctetString)
+//					return ((Asn1OctetString)obj).Parser;
+
+                return obj;
+            }
+
+            public Asn1Object ToAsn1Object()
+            {
+                return outer;
+            }
+        }
+
+        public virtual Asn1SequenceParser Parser
+        {
+            get { return new Asn1SequenceParserImpl(this); }
+        }
+
+        /**
+         * return the object at the sequence position indicated by index.
+         *
+         * @param index the sequence number (starting at zero) of the object
+         * @return the object at the sequence position indicated by index.
+         */
+        public virtual Asn1Encodable this[int index]
+        {
+            get { return elements[index]; }
+        }
+
+        public virtual int Count
+        {
+            get { return elements.Length; }
+        }
+
+        public virtual T[] MapElements<T>(Func<Asn1Encodable, T> func)
+        {
+            // NOTE: Call Count here to 'force' a LazyDerSequence
+            int count = Count;
+            T[] result = new T[count];
+            for (int i = 0; i < count; ++i)
+            {
+                result[i] = func(elements[i]);
+            }
+            return result;
+        }
+
+        public virtual Asn1Encodable[] ToArray()
+        {
+            return Asn1EncodableVector.CloneElements(elements);
+        }
+
+        protected override int Asn1GetHashCode()
+        {
+            // NOTE: Call Count here to 'force' a LazyDerSequence
+            int i = Count;
+            int hc = i + 1;
+
+            while (--i >= 0)
+            {
+                hc *= 257;
+                hc ^= elements[i].ToAsn1Object().CallAsn1GetHashCode();
+            }
+
+            return hc;
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            Asn1Sequence that = asn1Object as Asn1Sequence;
+            if (null == that)
+                return false;
+
+            // NOTE: Call Count here (on both) to 'force' a LazyDerSequence
+            int count = this.Count;
+            if (that.Count != count)
+                return false;
+
+            for (int i = 0; i < count; ++i)
+            {
+                Asn1Object o1 = this.elements[i].ToAsn1Object();
+                Asn1Object o2 = that.elements[i].ToAsn1Object();
+
+                if (!o1.Equals(o2))
+                    return false;
+            }
+
+            return true;
+        }
+
+        public override string ToString()
+        {
+            return CollectionUtilities.ToString(elements);
+        }
+
+        // TODO[asn1] Preferably return an Asn1BitString[] (doesn't exist yet)
+        internal DerBitString[] GetConstructedBitStrings()
+        {
+            return MapElements(DerBitString.GetInstance);
+        }
+
+        internal Asn1OctetString[] GetConstructedOctetStrings()
+        {
+            return MapElements(Asn1OctetString.GetInstance);
+        }
+
+        // TODO[asn1] Preferably return an Asn1BitString (doesn't exist yet)
+        internal abstract DerBitString ToAsn1BitString();
+
+        // TODO[asn1] Preferably return an Asn1External (doesn't exist yet)
+        internal abstract DerExternal ToAsn1External();
+
+        internal abstract Asn1OctetString ToAsn1OctetString();
+
+        internal abstract Asn1Set ToAsn1Set();
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Sequence.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 251efabb5e3250d49ad3fb7b45d68d01
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Set.cs

@@ -0,0 +1,331 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Collections;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class Asn1Set
+        : Asn1Object, IEnumerable<Asn1Encodable>
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1Set), Asn1Tags.Set) {}
+
+            internal override Asn1Object FromImplicitConstructed(Asn1Sequence sequence)
+            {
+                return sequence.ToAsn1Set();
+            }
+        }
+
+        /**
+         * return an ASN1Set from the given object.
+         *
+         * @param obj the object we want converted.
+         * @exception ArgumentException if the object cannot be converted.
+         */
+        public static Asn1Set GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1Set asn1Set)
+                return asn1Set;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1Set converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1Set)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct set from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), "obj");
+        }
+
+        /**
+         * Return an ASN1 set from a tagged object. There is a special
+         * case here, if an object appears to have been explicitly tagged on
+         * reading but we were expecting it to be implicitly tagged in the
+         * normal course of events it indicates that we lost the surrounding
+         * set - so we need to add it back (this will happen if the tagged
+         * object is a sequence that contains other sequences). If you are
+         * dealing with implicitly tagged sets you really <b>should</b>
+         * be using this method.
+         *
+         * @param taggedObject the tagged object.
+         * @param declaredExplicit true if the object is meant to be explicitly tagged false otherwise.
+         * @exception ArgumentException if the tagged object cannot be converted.
+         */
+        public static Asn1Set GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1Set)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+        // NOTE: Only non-readonly to support LazyDLSet
+        internal Asn1Encodable[] elements;
+        internal bool isSorted;
+
+        protected internal Asn1Set()
+        {
+            this.elements = Asn1EncodableVector.EmptyElements;
+            this.isSorted = true;
+        }
+
+        protected internal Asn1Set(Asn1Encodable element)
+        {
+            if (null == element)
+                throw new ArgumentNullException("element");
+
+            this.elements = new Asn1Encodable[]{ element };
+            this.isSorted = true;
+        }
+
+        protected internal Asn1Set(Asn1Encodable[] elements, bool doSort)
+        {
+            if (Arrays.IsNullOrContainsNull(elements))
+                throw new NullReferenceException("'elements' cannot be null, or contain null");
+
+            Asn1Encodable[] tmp = Asn1EncodableVector.CloneElements(elements);
+            if (doSort && tmp.Length >= 2)
+            {
+                tmp = Sort(tmp);
+            }
+
+            this.elements = tmp;
+            this.isSorted = doSort || tmp.Length < 2;
+        }
+
+        protected internal Asn1Set(Asn1EncodableVector elementVector, bool doSort)
+        {
+            if (null == elementVector)
+                throw new ArgumentNullException("elementVector");
+
+            Asn1Encodable[] tmp;
+            if (doSort && elementVector.Count >= 2)
+            {
+                tmp = Sort(elementVector.CopyElements());
+            }
+            else
+            {
+                tmp = elementVector.TakeElements();
+            }
+
+            this.elements = tmp;
+            this.isSorted = doSort || tmp.Length < 2;
+        }
+
+        protected internal Asn1Set(bool isSorted, Asn1Encodable[] elements)
+        {
+            this.elements = elements;
+            this.isSorted = isSorted || elements.Length < 2;
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public virtual IEnumerator<Asn1Encodable> GetEnumerator()
+        {
+            IEnumerable<Asn1Encodable> e = elements;
+            return e.GetEnumerator();
+        }
+
+        /**
+         * return the object at the set position indicated by index.
+         *
+         * @param index the set number (starting at zero) of the object
+         * @return the object at the set position indicated by index.
+         */
+        public virtual Asn1Encodable this[int index]
+        {
+            get { return elements[index]; }
+        }
+
+        public virtual int Count
+        {
+            get { return elements.Length; }
+        }
+
+        public virtual T[] MapElements<T>(Func<Asn1Encodable, T> func)
+        {
+            // NOTE: Call Count here to 'force' a LazyDerSet
+            int count = Count;
+            T[] result = new T[count];
+            for (int i = 0; i < count; ++i)
+            {
+                result[i] = func(elements[i]);
+            }
+            return result;
+        }
+
+        public virtual Asn1Encodable[] ToArray()
+        {
+            return Asn1EncodableVector.CloneElements(elements);
+        }
+
+        private class Asn1SetParserImpl
+            : Asn1SetParser
+        {
+            private readonly Asn1Set outer;
+            private readonly int max;
+            private int index;
+
+            public Asn1SetParserImpl(
+                Asn1Set outer)
+            {
+                this.outer = outer;
+                // NOTE: Call Count here to 'force' a LazyDerSet
+                this.max = outer.Count;
+            }
+
+            public IAsn1Convertible ReadObject()
+            {
+                if (index == max)
+                    return null;
+
+                Asn1Encodable obj = outer[index++];
+                if (obj is Asn1Sequence)
+                    return ((Asn1Sequence)obj).Parser;
+
+                if (obj is Asn1Set)
+                    return ((Asn1Set)obj).Parser;
+
+                // NB: Asn1OctetString implements Asn1OctetStringParser directly
+//				if (obj is Asn1OctetString)
+//					return ((Asn1OctetString)obj).Parser;
+
+                return obj;
+            }
+
+            public virtual Asn1Object ToAsn1Object()
+            {
+                return outer;
+            }
+        }
+
+        public Asn1SetParser Parser
+        {
+            get { return new Asn1SetParserImpl(this); }
+        }
+
+        protected override int Asn1GetHashCode()
+        {
+            // NOTE: Call Count here to 'force' a LazyDerSet
+            int i = Count;
+            int hc = i + 1;
+
+            while (--i >= 0)
+            {
+                hc *= 257;
+                hc ^= elements[i].ToAsn1Object().CallAsn1GetHashCode();
+            }
+
+            return hc;
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            Asn1Set that = asn1Object as Asn1Set;
+            if (null == that)
+                return false;
+
+            // NOTE: Call Count here (on both) to 'force' a LazyDerSet
+            int count = this.Count;
+            if (that.Count != count)
+                return false;
+
+            for (int i = 0; i < count; ++i)
+            {
+                Asn1Object o1 = this.elements[i].ToAsn1Object();
+                Asn1Object o2 = that.elements[i].ToAsn1Object();
+
+                if (!o1.Equals(o2))
+                    return false;
+            }
+
+            return true;
+        }
+
+        public override string ToString()
+        {
+            return CollectionUtilities.ToString(elements);
+        }
+
+        internal static Asn1Encodable[] Sort(Asn1Encodable[] elements)
+        {
+            int count = elements.Length;
+            if (count < 2)
+                return elements;
+
+            byte[][] keys = new byte[count][];
+            for (int i = 0; i < count; ++i)
+            {
+                keys[i] = elements[i].GetEncoded(Der);
+            }
+            Array.Sort(keys, elements, new DerComparer());
+            return elements;
+        }
+
+        private class DerComparer
+            : IComparer<byte[]>
+        {
+            public int Compare(byte[] a, byte[] b)
+            {
+                Debug.Assert(a.Length >= 2 && b.Length >= 2);
+
+                /*
+                 * NOTE: Set elements in DER encodings are ordered first according to their tags (class and
+                 * number); the CONSTRUCTED bit is not part of the tag.
+                 * 
+                 * For SET-OF, this is unimportant. All elements have the same tag and DER requires them to
+                 * either all be in constructed form or all in primitive form, according to that tag. The
+                 * elements are effectively ordered according to their content octets.
+                 * 
+                 * For SET, the elements will have distinct tags, and each will be in constructed or
+                 * primitive form accordingly. Failing to ignore the CONSTRUCTED bit could therefore lead to
+                 * ordering inversions.
+                 */
+                int a0 = a[0] & ~Asn1Tags.Constructed;
+                int b0 = b[0] & ~Asn1Tags.Constructed;
+                if (a0 != b0)
+                    return a0 < b0 ? -1 : 1;
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+                int compareLength = System.Math.Min(a.Length, b.Length) - 1;
+                return a.AsSpan(1, compareLength).SequenceCompareTo(b.AsSpan(1, compareLength));
+#else
+                int len = System.Math.Min(a.Length, b.Length);
+                for (int i = 1; i < len; ++i)
+                {
+                    byte ai = a[i], bi = b[i];
+                    if (ai != bi)
+                        return ai < bi ? -1 : 1;
+                }
+                Debug.Assert(a.Length == b.Length);
+                return 0;
+#endif
+            }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Set.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: db687a85bbc7c7240b1b2f57359d0c46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Tag.cs

@@ -0,0 +1,35 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal sealed class Asn1Tag
+    {
+        internal static Asn1Tag Create(int tagClass, int tagNo)
+        {
+            return new Asn1Tag(tagClass, tagNo);
+        }
+
+        private readonly int m_tagClass;
+        private readonly int m_tagNo;
+
+        private Asn1Tag(int tagClass, int tagNo)
+        {
+            m_tagClass = tagClass;
+            m_tagNo = tagNo;
+        }
+
+        internal int TagClass
+        {
+            get { return m_tagClass; }
+        }
+
+        internal int TagNo
+        {
+            get { return m_tagNo; }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Tag.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86fc5dd31416c1b4797892dbb3a76111
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1TaggedObject.cs

@@ -0,0 +1,409 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /**
+     * ASN.1 TaggedObject - in ASN.1 notation this is any object preceded by
+     * a [n] where n is some number - these are assumed to follow the construction
+     * rules (as with sequences).
+     */
+    public abstract class Asn1TaggedObject
+		: Asn1Object, Asn1TaggedObjectParser
+    {
+        private const int DeclaredExplicit = 1;
+        private const int DeclaredImplicit = 2;
+        // TODO It will probably be better to track parsing constructed vs primitive instead
+        private const int ParsedExplicit = 3;
+        private const int ParsedImplicit = 4;
+
+        public static Asn1TaggedObject GetInstance(object obj)
+		{
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1TaggedObject asn1TaggedObject)
+                return asn1TaggedObject;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1TaggedObject converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return CheckedCast(FromByteArray(bytes));
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct tagged object from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), "obj");
+		}
+
+        public static Asn1TaggedObject GetInstance(object obj, int tagClass)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+
+            Asn1TaggedObject taggedObject = GetInstance(obj);
+            if (tagClass != taggedObject.TagClass)
+                throw new ArgumentException("unexpected tag in GetInstance: " + Asn1Utilities.GetTagText(taggedObject));
+
+            return taggedObject;
+        }
+
+        public static Asn1TaggedObject GetInstance(object obj, int tagClass, int tagNo)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+
+            Asn1TaggedObject taggedObject = GetInstance(obj);
+            if (!taggedObject.HasTag(tagClass, tagNo))
+                throw new ArgumentException("unexpected tag in GetInstance: " + Asn1Utilities.GetTagText(taggedObject));
+
+            return taggedObject;
+        }
+
+        public static Asn1TaggedObject GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            if (Asn1Tags.ContextSpecific != taggedObject.TagClass)
+                throw new InvalidOperationException("this method only valid for CONTEXT_SPECIFIC tags");
+
+            if (declaredExplicit)
+                return taggedObject.GetExplicitBaseTagged();
+
+            throw new ArgumentException("this method not valid for implicitly tagged tagged objects");
+        }
+
+        internal readonly int explicitness;
+        internal readonly int tagClass;
+        internal readonly int tagNo;
+        internal readonly Asn1Encodable obj;
+
+		/**
+         * @param explicitly true if the object is explicitly tagged.
+         * @param tagNo the tag number for this object.
+         * @param obj the tagged object.
+         */
+        protected Asn1TaggedObject(bool isExplicit, int tagNo, Asn1Encodable obj)
+            : this(isExplicit, Asn1Tags.ContextSpecific, tagNo, obj)
+        {
+        }
+
+        protected Asn1TaggedObject(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+            : this(isExplicit ? DeclaredExplicit : DeclaredImplicit, tagClass, tagNo, obj)
+        {
+        }
+
+        internal Asn1TaggedObject(int explicitness, int tagClass, int tagNo, Asn1Encodable obj)
+        {
+            if (null == obj)
+                throw new ArgumentNullException("obj");
+            if (Asn1Tags.Universal == tagClass || (tagClass & Asn1Tags.Private) != tagClass)
+                throw new ArgumentException("invalid tag class: " + tagClass, "tagClass");
+
+            this.explicitness = (obj is IAsn1Choice) ? DeclaredExplicit : explicitness;
+            this.tagClass = tagClass;
+            this.tagNo = tagNo;
+            this.obj = obj;
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            Asn1TaggedObject that = asn1Object as Asn1TaggedObject;
+            if (null == that || this.tagNo != that.tagNo || this.tagClass != that.tagClass)
+                return false;
+
+            if (this.explicitness != that.explicitness)
+            {
+                /*
+                 * TODO This seems incorrect for some cases of implicit tags e.g. if one is a
+                 * declared-implicit SET and the other a parsed object.
+                 */
+                if (this.IsExplicit() != that.IsExplicit())
+                    return false;
+            }
+
+            Asn1Object p1 = this.obj.ToAsn1Object();
+            Asn1Object p2 = that.obj.ToAsn1Object();
+
+            if (p1 == p2)
+                return true;
+
+            if (!this.IsExplicit())
+            {
+                try
+                {
+                    byte[] d1 = this.GetEncoded();
+                    byte[] d2 = that.GetEncoded();
+
+                    return Arrays.AreEqual(d1, d2);
+                }
+                catch (IOException)
+                {
+                    return false;
+                }
+            }
+
+            return p1.CallAsn1Equals(p2);
+		}
+
+		protected override int Asn1GetHashCode()
+		{
+            return (tagClass * 7919) ^ tagNo ^ (IsExplicit() ? 0x0F : 0xF0) ^ obj.ToAsn1Object().CallAsn1GetHashCode();
+        }
+
+        public int TagClass
+        {
+            get { return tagClass; }
+        }
+
+		public int TagNo
+        {
+			get { return tagNo; }
+        }
+
+        public bool HasContextTag(int tagNo)
+        {
+            return this.tagClass == Asn1Tags.ContextSpecific && this.tagNo == tagNo;
+        }
+
+        public bool HasTag(int tagClass, int tagNo)
+        {
+            return this.tagClass == tagClass && this.tagNo == tagNo;
+        }
+
+        /**
+         * return whether or not the object may be explicitly tagged.
+         * <p>
+         * Note: if the object has been read from an input stream, the only
+         * time you can be sure if isExplicit is returning the true state of
+         * affairs is if it returns false. An implicitly tagged object may appear
+         * to be explicitly tagged, so you need to understand the context under
+         * which the reading was done as well, see GetObject below.</p>
+         */
+        public bool IsExplicit()
+        {
+            // TODO New methods like 'IsKnownExplicit' etc. to distinguish uncertain cases?
+            switch (explicitness)
+            {
+            case DeclaredExplicit:
+            case ParsedExplicit:
+                return true;
+            default:
+                return false;
+            }
+        }
+
+        internal bool IsParsed()
+        {
+            switch (explicitness)
+            {
+            case ParsedExplicit:
+            case ParsedImplicit:
+                return true;
+            default:
+                return false;
+            }
+        }
+
+        /**
+         * return whatever was following the tag.
+         * <p>
+         * Note: tagged objects are generally context dependent if you're
+         * trying to extract a tagged object you should be going via the
+         * appropriate GetInstance method.</p>
+         */
+        public Asn1Object GetObject()
+        {
+            if (Asn1Tags.ContextSpecific != TagClass)
+                throw new InvalidOperationException("this method only valid for CONTEXT_SPECIFIC tags");
+
+            return obj.ToAsn1Object();
+        }
+
+        /**
+         * Needed for open types, until we have better type-guided parsing support. Use sparingly for other
+         * purposes, and prefer {@link #getExplicitBaseTagged()}, {@link #getImplicitBaseTagged(int, int)} or
+         * {@link #getBaseUniversal(boolean, int)} where possible. Before using, check for matching tag
+         * {@link #getTagClass() class} and {@link #getTagNo() number}.
+         */
+        public Asn1Encodable GetBaseObject()
+        {
+            return obj;
+        }
+
+        /**
+         * Needed for open types, until we have better type-guided parsing support. Use
+         * sparingly for other purposes, and prefer {@link #getExplicitBaseTagged()} or
+         * {@link #getBaseUniversal(boolean, int)} where possible. Before using, check
+         * for matching tag {@link #getTagClass() class} and {@link #getTagNo() number}.
+         */
+        public Asn1Encodable GetExplicitBaseObject()
+        {
+            if (!IsExplicit())
+                throw new InvalidOperationException("object implicit - explicit expected.");
+
+            return obj;
+        }
+
+        public Asn1TaggedObject GetExplicitBaseTagged()
+        {
+            if (!IsExplicit())
+                throw new InvalidOperationException("object implicit - explicit expected.");
+
+            return CheckedCast(obj.ToAsn1Object());
+        }
+
+        public Asn1TaggedObject GetImplicitBaseTagged(int baseTagClass, int baseTagNo)
+        {
+            if (Asn1Tags.Universal == baseTagClass || (baseTagClass & Asn1Tags.Private) != baseTagClass)
+                throw new ArgumentException("invalid base tag class: " + baseTagClass, "baseTagClass");
+
+            switch (explicitness)
+            {
+            case DeclaredExplicit:
+                throw new InvalidOperationException("object explicit - implicit expected.");
+
+            case DeclaredImplicit:
+            {
+                Asn1TaggedObject declared = CheckedCast(obj.ToAsn1Object());
+                return Asn1Utilities.CheckTag(declared, baseTagClass, baseTagNo);
+            }
+
+            // Parsed; return a virtual tag (i.e. that couldn't have been present in the encoding)
+            default:
+                return ReplaceTag(baseTagClass, baseTagNo);
+            }
+        }
+
+        public Asn1Object GetBaseUniversal(bool declaredExplicit, int tagNo)
+        {
+            Asn1UniversalType universalType = Asn1UniversalTypes.Get(tagNo);
+            if (null == universalType)
+                throw new ArgumentException("unsupported UNIVERSAL tag number: " + tagNo, "tagNo");
+
+            return GetBaseUniversal(declaredExplicit, universalType);
+        }
+
+        internal Asn1Object GetBaseUniversal(bool declaredExplicit, Asn1UniversalType universalType)
+        {
+            if (declaredExplicit)
+            {
+                if (!IsExplicit())
+                    throw new InvalidOperationException("object explicit - implicit expected.");
+
+                return universalType.CheckedCast(obj.ToAsn1Object());
+            }
+
+            if (DeclaredExplicit == explicitness)
+                throw new InvalidOperationException("object explicit - implicit expected.");
+
+            Asn1Object baseObject = obj.ToAsn1Object();
+            switch (explicitness)
+            {
+            case ParsedExplicit:
+                return universalType.FromImplicitConstructed(RebuildConstructed(baseObject));
+            case ParsedImplicit:
+            {
+                if (baseObject is Asn1Sequence asn1Sequence)
+                    return universalType.FromImplicitConstructed(asn1Sequence);
+
+                return universalType.FromImplicitPrimitive((DerOctetString)baseObject);
+            }
+            default:
+                return universalType.CheckedCast(baseObject);
+            }
+        }
+
+        public IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo)
+        {
+            Asn1Object asn1Object = GetBaseUniversal(declaredExplicit, baseTagNo);
+
+            switch (baseTagNo)
+            {
+            case Asn1Tags.BitString:
+                return ((DerBitString)asn1Object).Parser;
+            case Asn1Tags.OctetString:
+                return ((Asn1OctetString)asn1Object).Parser;
+            case Asn1Tags.Sequence:
+                return ((Asn1Sequence)asn1Object).Parser;
+            case Asn1Tags.Set:
+                return ((Asn1Set)asn1Object).Parser;
+            }
+
+            return asn1Object;
+        }
+
+        public IAsn1Convertible ParseExplicitBaseObject()
+        {
+            return GetExplicitBaseObject();
+        }
+
+        public Asn1TaggedObjectParser ParseExplicitBaseTagged()
+        {
+            return GetExplicitBaseTagged();
+        }
+
+        public Asn1TaggedObjectParser ParseImplicitBaseTagged(int baseTagClass, int baseTagNo)
+        {
+            return GetImplicitBaseTagged(baseTagClass, baseTagNo);
+        }
+
+		public override string ToString()
+		{
+            return Asn1Utilities.GetTagText(tagClass, tagNo) + obj;
+		}
+
+        internal abstract string Asn1Encoding { get; }
+
+        internal abstract Asn1Sequence RebuildConstructed(Asn1Object asn1Object);
+
+        internal abstract Asn1TaggedObject ReplaceTag(int tagClass, int tagNo);
+
+        internal static Asn1Object CreateConstructedDL(int tagClass, int tagNo, Asn1EncodableVector contentsElements)
+        {
+            bool maybeExplicit = (contentsElements.Count == 1);
+
+            return maybeExplicit
+                ? new DLTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
+                : new DLTaggedObject(ParsedImplicit, tagClass, tagNo, DLSequence.FromVector(contentsElements));
+        }
+
+        internal static Asn1Object CreateConstructedIL(int tagClass, int tagNo, Asn1EncodableVector contentsElements)
+        {
+            bool maybeExplicit = (contentsElements.Count == 1);
+
+            return maybeExplicit
+                ? new BerTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
+                : new BerTaggedObject(ParsedImplicit, tagClass, tagNo, BerSequence.FromVector(contentsElements));
+        }
+
+        internal static Asn1Object CreatePrimitive(int tagClass, int tagNo, byte[] contentsOctets)
+        {
+            // Note: !CONSTRUCTED => IMPLICIT
+            return new DLTaggedObject(ParsedImplicit, tagClass, tagNo, new DerOctetString(contentsOctets));
+        }
+
+        private static Asn1TaggedObject CheckedCast(Asn1Object asn1Object)
+        {
+            Asn1TaggedObject taggedObject = asn1Object as Asn1TaggedObject;
+            if (null != taggedObject)
+                return taggedObject;
+
+            throw new InvalidOperationException("unexpected object: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(asn1Object));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1TaggedObject.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8dc761d7a5e48814998a495824555f3a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Tags.cs

@@ -0,0 +1,53 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class Asn1Tags
+    {
+        public const int Boolean = 0x01;
+        public const int Integer = 0x02;
+        public const int BitString = 0x03;
+        public const int OctetString = 0x04;
+        public const int Null = 0x05;
+        public const int ObjectIdentifier = 0x06;
+        public const int ObjectDescriptor = 0x07;
+        public const int External = 0x08;
+        public const int Real = 0x09;
+        public const int Enumerated = 0x0a;
+        public const int EmbeddedPdv = 0x0b;
+        public const int Utf8String = 0x0c;
+        public const int RelativeOid = 0x0d;
+                                                        // NOTE: 14-15 are reserved.
+        public const int Sequence = 0x10;
+        public const int SequenceOf = 0x10; // for completeness
+        public const int Set = 0x11;
+        public const int SetOf = 0x11; // for completeness
+
+        public const int NumericString = 0x12;
+        public const int PrintableString = 0x13;
+        public const int T61String = 0x14;
+        public const int VideotexString = 0x15;
+        public const int IA5String = 0x16;
+        public const int UtcTime = 0x17;
+        public const int GeneralizedTime = 0x18;
+        public const int GraphicString = 0x19;
+        public const int VisibleString = 0x1a;
+        public const int GeneralString = 0x1b;
+        public const int UniversalString = 0x1c;
+        public const int UnrestrictedString = 0x1d;
+        public const int BmpString = 0x1e;
+
+        public const int Constructed = 0x20;
+
+        public const int Universal = 0x00;
+        public const int Application = 0x40;
+        public const int ContextSpecific = 0x80;
+        public const int Private = 0xC0;
+
+        public const int Flags = 0xE0;
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Tags.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1d609f8d10b0a5c469fd85eb4b389e30
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Type.cs

@@ -0,0 +1,33 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal abstract class Asn1Type
+    {
+        internal readonly Type m_platformType;
+
+        internal Asn1Type(Type platformType)
+        {
+            m_platformType = platformType;
+        }
+
+        internal Type PlatformType
+        {
+            get { return m_platformType; }
+        }
+
+        public sealed override bool Equals(object that)
+        {
+            return this == that;
+        }
+
+        public sealed override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Type.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ffac7d6916dbabc449fd3c8f9f3b51c5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1UniversalType.cs

@@ -0,0 +1,63 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+#if UNITY_WSA && !UNITY_EDITOR && !ENABLE_IL2CPP
+using System.TypeFix;
+#endif
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal abstract class Asn1UniversalType
+        : Asn1Type
+    {
+        internal readonly Asn1Tag m_tag;
+
+        internal Asn1UniversalType(Type platformType, int tagNo)
+            : base(platformType)
+        {
+            m_tag = Asn1Tag.Create(Asn1Tags.Universal, tagNo);
+        }
+
+        internal Asn1Object CheckedCast(Asn1Object asn1Object)
+        {
+            if (PlatformType.IsInstanceOfType(asn1Object))
+                return asn1Object;
+
+            throw new InvalidOperationException("unexpected object: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(asn1Object));
+        }
+
+        internal virtual Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+        {
+            throw new InvalidOperationException("unexpected implicit primitive encoding");
+        }
+
+        internal virtual Asn1Object FromImplicitConstructed(Asn1Sequence sequence)
+        {
+            throw new InvalidOperationException("unexpected implicit constructed encoding");
+        }
+
+        /// <exception cref="IOException"/>
+        internal Asn1Object FromByteArray(byte[] bytes)
+        {
+            return CheckedCast(Asn1Object.FromByteArray(bytes));
+        }
+
+        internal Asn1Object GetContextInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            if (Asn1Tags.ContextSpecific != taggedObject.TagClass)
+                throw new InvalidOperationException("this method only valid for CONTEXT_SPECIFIC tags");
+
+            return CheckedCast(taggedObject.GetBaseUniversal(declaredExplicit, this));
+        }
+
+        internal Asn1Tag Tag
+        {
+            get { return m_tag; }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1UniversalType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1449dc3fb760c69478b79ac2d2d26975
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1UniversalTypes.cs

@@ -0,0 +1,78 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal sealed class Asn1UniversalTypes
+    {
+        private Asn1UniversalTypes()
+        {
+        }
+
+        internal static Asn1UniversalType Get(int tagNo)
+        {
+            switch (tagNo)
+            {
+            case Asn1Tags.Boolean:
+                return DerBoolean.Meta.Instance;
+            case Asn1Tags.Integer:
+                return DerInteger.Meta.Instance;
+            case Asn1Tags.BitString:
+                return DerBitString.Meta.Instance;
+            case Asn1Tags.OctetString:
+                return Asn1OctetString.Meta.Instance;
+            case Asn1Tags.Null:
+                return Asn1Null.Meta.Instance;
+            case Asn1Tags.ObjectIdentifier:
+                return DerObjectIdentifier.Meta.Instance;
+            case Asn1Tags.ObjectDescriptor:         // [UNIVERSAL 7] IMPLICIT GraphicString
+                return Asn1ObjectDescriptor.Meta.Instance;
+            case Asn1Tags.External:
+                return DerExternal.Meta.Instance;
+            case Asn1Tags.Enumerated:
+                return DerEnumerated.Meta.Instance;
+            case Asn1Tags.Utf8String:               // [UNIVERSAL 12] IMPLICIT OCTET STRING (encode as if)
+                return DerUtf8String.Meta.Instance;
+            case Asn1Tags.RelativeOid:
+                return Asn1RelativeOid.Meta.Instance;
+            case Asn1Tags.Sequence:
+                return Asn1Sequence.Meta.Instance;
+            case Asn1Tags.Set:
+                return Asn1Set.Meta.Instance;
+            case Asn1Tags.NumericString:            // [UNIVERSAL 18] IMPLICIT OCTET STRING (encode as if)
+                return DerNumericString.Meta.Instance;
+            case Asn1Tags.PrintableString:          // [UNIVERSAL 19] IMPLICIT OCTET STRING (encode as if)
+                return DerPrintableString.Meta.Instance;
+            case Asn1Tags.T61String:                // [UNIVERSAL 20] IMPLICIT OCTET STRING (encode as if)
+                return DerT61String.Meta.Instance;
+            case Asn1Tags.VideotexString:           // [UNIVERSAL 21] IMPLICIT OCTET STRING (encode as if)
+                return DerVideotexString.Meta.Instance;
+            case Asn1Tags.IA5String:                // [UNIVERSAL 22] IMPLICIT OCTET STRING (encode as if)
+                return DerIA5String.Meta.Instance;
+            case Asn1Tags.UtcTime:                  // [UNIVERSAL 23] IMPLICIT VisibleString (restricted values)
+                return Asn1UtcTime.Meta.Instance;
+            case Asn1Tags.GeneralizedTime:          // [UNIVERSAL 24] IMPLICIT VisibleString (restricted values)
+                return Asn1GeneralizedTime.Meta.Instance;
+            case Asn1Tags.GraphicString:            // [UNIVERSAL 25] IMPLICIT OCTET STRING (encode as if)
+                return DerGraphicString.Meta.Instance;
+            case Asn1Tags.VisibleString:            // [UNIVERSAL 26] IMPLICIT OCTET STRING (encode as if)
+                return DerVisibleString.Meta.Instance;
+            case Asn1Tags.GeneralString:            // [UNIVERSAL 27] IMPLICIT OCTET STRING (encode as if)
+                return DerGeneralString.Meta.Instance;
+            case Asn1Tags.UniversalString:          // [UNIVERSAL 28] IMPLICIT OCTET STRING (encode as if)
+                return DerUniversalString.Meta.Instance;
+            case Asn1Tags.BmpString:                // [UNIVERSAL 30] IMPLICIT OCTET STRING (encode as if)
+                return DerBmpString.Meta.Instance;
+
+            case Asn1Tags.Real:
+            case Asn1Tags.EmbeddedPdv:
+            case Asn1Tags.UnrestrictedString:
+            default:
+                return null;
+            }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1UniversalTypes.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 839094e1a57356a4eaefab55a4481ef9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1UtcTime.cs

@@ -0,0 +1,257 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Date;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /// <summary>UTCTime ASN.1 type</summary>
+    public class Asn1UtcTime
+        : Asn1Object
+    {
+        internal class Meta : Asn1UniversalType
+        {
+            internal static readonly Asn1UniversalType Instance = new Meta();
+
+            private Meta() : base(typeof(Asn1UtcTime), Asn1Tags.UtcTime) {}
+
+            internal override Asn1Object FromImplicitPrimitive(DerOctetString octetString)
+            {
+                return CreatePrimitive(octetString.GetOctets());
+            }
+        }
+
+		/**
+         * return a UTC Time from the passed in object.
+         *
+         * @exception ArgumentException if the object cannot be converted.
+         */
+        public static Asn1UtcTime GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+
+            if (obj is Asn1UtcTime asn1UtcTime)
+                return asn1UtcTime;
+
+            if (obj is IAsn1Convertible asn1Convertible)
+            {
+                Asn1Object asn1Object = asn1Convertible.ToAsn1Object();
+                if (asn1Object is Asn1UtcTime converted)
+                    return converted;
+            }
+            else if (obj is byte[] bytes)
+            {
+                try
+                {
+                    return (Asn1UtcTime)Meta.Instance.FromByteArray(bytes);
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct UTC time from byte[]: " + e.Message);
+                }
+            }
+
+            throw new ArgumentException("illegal object in GetInstance: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(obj), nameof(obj));
+        }
+
+        public static Asn1UtcTime GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return (Asn1UtcTime)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
+        }
+
+		private readonly string m_timeString;
+		private readonly DateTime m_dateTime;
+        private readonly bool m_dateTimeLocked;
+        private readonly int m_twoDigitYearMax;
+
+		public Asn1UtcTime(string timeString)
+		{
+			m_timeString = timeString ?? throw new ArgumentNullException(nameof(timeString));
+
+			try
+			{
+				m_dateTime = FromString(timeString, out m_twoDigitYearMax);
+                m_dateTimeLocked = false;
+            }
+            catch (FormatException e)
+			{
+				throw new ArgumentException("invalid date string: " + e.Message);
+			}
+		}
+
+
+		public Asn1UtcTime(DateTime dateTime)
+		{
+            dateTime = DateTimeUtilities.WithPrecisionSecond(dateTime.ToUniversalTime());
+
+            m_dateTime = dateTime;
+            m_dateTimeLocked = true;
+            m_timeString = ToStringCanonical(dateTime, out m_twoDigitYearMax);
+        }
+
+        public Asn1UtcTime(DateTime dateTime, int twoDigitYearMax)
+        {
+            dateTime = DateTimeUtilities.WithPrecisionSecond(dateTime.ToUniversalTime());
+
+            Validate(dateTime, twoDigitYearMax);
+
+            m_dateTime = dateTime;
+            m_dateTimeLocked = true;
+            m_timeString = ToStringCanonical(dateTime);
+            m_twoDigitYearMax = twoDigitYearMax;
+        }
+
+        internal Asn1UtcTime(byte[] contents)
+            // NOTE: Non-ASCII characters will produce '?' characters, which will fail DateTime parsing
+			: this(Encoding.ASCII.GetString(contents))
+		{
+		}
+
+        public string TimeString => m_timeString;
+
+        public DateTime ToDateTime()
+		{
+			return m_dateTime;
+		}
+
+        public DateTime ToDateTime(int twoDigitYearMax)
+        {
+            if (InRange(m_dateTime, twoDigitYearMax))
+                return m_dateTime;
+
+            if (m_dateTimeLocked)
+                throw new InvalidOperationException();
+
+            int twoDigitYear = m_dateTime.Year % 100;
+            int twoDigitYearCutoff = twoDigitYearMax % 100;
+
+            int diff = twoDigitYear - twoDigitYearCutoff;
+            int newYear = twoDigitYearMax + diff;
+            if (diff > 0)
+            {
+                newYear -= 100;
+            }
+
+            return m_dateTime.AddYears(newYear - m_dateTime.Year);
+        }
+
+        public DateTime ToDateTime(Calendar calendar)
+        {
+            return ToDateTime(calendar.TwoDigitYearMax);
+        }
+
+        /// <summary>Return an adjusted date in the range of 1950 - 2049.</summary>
+
+        public DateTime ToAdjustedDateTime()
+        {
+            return ToDateTime(2049);
+        }
+
+        public int TwoDigitYearMax => m_twoDigitYearMax;
+
+        internal byte[] GetContents(int encoding)
+        {
+            if (encoding == Asn1OutputStream.EncodingDer && m_timeString.Length != 13)
+            {
+                string canonical = ToStringCanonical(m_dateTime);
+                return Encoding.ASCII.GetBytes(canonical);
+            }
+
+            return Encoding.ASCII.GetBytes(m_timeString);
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.UtcTime, GetContents(encoding));
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            return new PrimitiveEncoding(tagClass, tagNo, GetContents(encoding));
+        }
+
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            if (!(asn1Object is Asn1UtcTime that))
+                return false;
+
+            // TODO Performance
+            return Arrays.AreEqual(
+                this.GetContents(Asn1OutputStream.EncodingDer),
+                that.GetContents(Asn1OutputStream.EncodingDer));
+        }
+
+        protected override int Asn1GetHashCode()
+        {
+            // TODO Performance
+            return Arrays.GetHashCode(
+                this.GetContents(Asn1OutputStream.EncodingDer));
+        }
+
+        public override string ToString()
+        {
+            return m_timeString;
+        }
+
+        internal static Asn1UtcTime CreatePrimitive(byte[] contents)
+        {
+            return new Asn1UtcTime(contents);
+        }
+
+        private static DateTime FromString(string s, out int twoDigitYearMax)
+        {
+            var provider = DateTimeFormatInfo.InvariantInfo;
+            twoDigitYearMax = provider.Calendar.TwoDigitYearMax;
+
+            switch (s.Length)
+            {
+            case 11:
+                return DateTime.ParseExact(s, @"yyMMddHHmm\Z", provider,
+                    DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+            case 13:
+                return DateTime.ParseExact(s, @"yyMMddHHmmss\Z", provider,
+                    DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
+            case 15:
+                return DateTime.ParseExact(s, @"yyMMddHHmmzzz", provider, DateTimeStyles.AdjustToUniversal);
+            case 17:
+                return DateTime.ParseExact(s, @"yyMMddHHmmsszzz", provider, DateTimeStyles.AdjustToUniversal);
+            default:
+                throw new FormatException();
+            }
+        }
+
+        private static bool InRange(DateTime dateTime, int twoDigitYearMax)
+        {
+            return (uint)(twoDigitYearMax - dateTime.Year) < 100;
+        }
+
+        private static string ToStringCanonical(DateTime dateTime, out int twoDigitYearMax)
+        {
+            var provider = DateTimeFormatInfo.InvariantInfo;
+            twoDigitYearMax = provider.Calendar.TwoDigitYearMax;
+
+            Validate(dateTime, twoDigitYearMax);
+
+            return dateTime.ToString(@"yyMMddHHmmss\Z", provider);
+        }
+
+        private static string ToStringCanonical(DateTime dateTime)
+        {
+            return dateTime.ToString(@"yyMMddHHmmss\Z", DateTimeFormatInfo.InvariantInfo);
+        }
+
+        private static void Validate(DateTime dateTime, int twoDigitYearMax)
+        {
+            if (!InRange(dateTime, twoDigitYearMax))
+                throw new ArgumentOutOfRangeException(nameof(dateTime));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1UtcTime.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: edf61982cdff33c408181b8d191ae7ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Utilities.cs

@@ -0,0 +1,333 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class Asn1Utilities
+    {
+        internal static Asn1TaggedObject CheckTag(Asn1TaggedObject taggedObject, int tagClass, int tagNo)
+        {
+            if (!taggedObject.HasTag(tagClass, tagNo))
+            {
+                string expected = GetTagText(tagClass, tagNo);
+                string found = GetTagText(taggedObject);
+                throw new InvalidOperationException("Expected " + expected + " tag but found " + found);
+            }
+            return taggedObject;
+        }
+
+        internal static Asn1TaggedObjectParser CheckTag(Asn1TaggedObjectParser taggedObjectParser, int tagClass,
+            int tagNo)
+        {
+            if (!taggedObjectParser.HasTag(tagClass, tagNo))
+            {
+                string expected = GetTagText(tagClass, tagNo);
+                string found = GetTagText(taggedObjectParser);
+                throw new InvalidOperationException("Expected " + expected + " tag but found " + found);
+            }
+            return taggedObjectParser;
+        }
+
+
+        internal static string GetTagText(Asn1Tag tag)
+        {
+            return GetTagText(tag.TagClass, tag.TagNo);
+        }
+
+        public static string GetTagText(Asn1TaggedObject taggedObject)
+        {
+            return GetTagText(taggedObject.TagClass, taggedObject.TagNo);
+        }
+
+        public static string GetTagText(Asn1TaggedObjectParser taggedObjectParser)
+        {
+            return GetTagText(taggedObjectParser.TagClass, taggedObjectParser.TagNo);
+        }
+
+        public static string GetTagText(int tagClass, int tagNo)
+        {
+            switch (tagClass)
+            {
+            case Asn1Tags.Application:
+                return "[APPLICATION " + tagNo + "]";
+            case Asn1Tags.ContextSpecific:
+                return "[CONTEXT " + tagNo + "]";
+            case Asn1Tags.Private:
+                return "[PRIVATE " + tagNo + "]";
+            default:
+                return "[UNIVERSAL " + tagNo + "]";
+            }
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObject.GetExplicitBaseObject
+         */
+
+        public static Asn1Encodable GetExplicitBaseObject(Asn1TaggedObject taggedObject, int tagClass, int tagNo)
+        {
+            return CheckTag(taggedObject, tagClass, tagNo).GetExplicitBaseObject();
+        }
+
+        public static Asn1Encodable GetExplicitContextBaseObject(Asn1TaggedObject taggedObject, int tagNo)
+        {
+            return GetExplicitBaseObject(taggedObject, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+        public static Asn1Encodable TryGetExplicitBaseObject(Asn1TaggedObject taggedObject, int tagClass, int tagNo)
+        {
+            if (!taggedObject.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObject.GetExplicitBaseObject();
+        }
+
+        public static Asn1Encodable TryGetExplicitContextBaseObject(Asn1TaggedObject taggedObject, int tagNo)
+        {
+            return TryGetExplicitBaseObject(taggedObject, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObject.GetExplicitBaseTagged
+         */
+
+        public static Asn1TaggedObject GetExplicitBaseTagged(Asn1TaggedObject taggedObject, int tagClass, int tagNo)
+        {
+            return CheckTag(taggedObject, tagClass, tagNo).GetExplicitBaseTagged();
+        }
+
+        public static Asn1TaggedObject GetExplicitContextBaseTagged(Asn1TaggedObject taggedObject, int tagNo)
+        {
+            return GetExplicitBaseTagged(taggedObject, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+        public static Asn1TaggedObject TryGetExplicitBaseTagged(Asn1TaggedObject taggedObject, int tagClass, int tagNo)
+        {
+            if (!taggedObject.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObject.GetExplicitBaseTagged();
+        }
+
+        public static Asn1TaggedObject TryGetExplicitContextBaseTagged(Asn1TaggedObject taggedObject, int tagNo)
+        {
+            return TryGetExplicitBaseTagged(taggedObject, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObject.GetImplicitBaseTagged
+         */
+
+        public static Asn1TaggedObject GetImplicitBaseTagged(Asn1TaggedObject taggedObject, int tagClass, int tagNo,
+            int baseTagClass, int baseTagNo)
+        {
+            return CheckTag(taggedObject, tagClass, tagNo).GetImplicitBaseTagged(baseTagClass, baseTagNo);
+        }
+
+        public static Asn1TaggedObject GetImplicitContextBaseTagged(Asn1TaggedObject taggedObject, int tagNo,
+            int baseTagClass, int baseTagNo)
+        {
+            return GetImplicitBaseTagged(taggedObject, Asn1Tags.ContextSpecific, tagNo, baseTagClass, baseTagNo);
+        }
+
+        public static Asn1TaggedObject TryGetImplicitBaseTagged(Asn1TaggedObject taggedObject, int tagClass, int tagNo,
+            int baseTagClass, int baseTagNo)
+        {
+            if (!taggedObject.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObject.GetImplicitBaseTagged(baseTagClass, baseTagNo);
+        }
+
+        public static Asn1TaggedObject TryGetImplicitContextBaseTagged(Asn1TaggedObject taggedObject, int tagNo,
+            int baseTagClass, int baseTagNo)
+        {
+            return TryGetImplicitBaseTagged(taggedObject, Asn1Tags.ContextSpecific, tagNo, baseTagClass, baseTagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObject.GetBaseUniversal
+         */
+
+        public static Asn1Object GetBaseUniversal(Asn1TaggedObject taggedObject, int tagClass, int tagNo,
+            bool declaredExplicit, int baseTagNo)
+        {
+            return CheckTag(taggedObject, tagClass, tagNo).GetBaseUniversal(declaredExplicit, baseTagNo);
+        }
+
+        public static Asn1Object GetContextBaseUniversal(Asn1TaggedObject taggedObject, int tagNo,
+            bool declaredExplicit, int baseTagNo)
+        {
+            return GetBaseUniversal(taggedObject, Asn1Tags.ContextSpecific, tagNo, declaredExplicit, baseTagNo);
+        }
+
+        public static Asn1Object TryGetBaseUniversal(Asn1TaggedObject taggedObject, int tagClass, int tagNo,
+            bool declaredExplicit, int baseTagNo)
+        {
+            if (!taggedObject.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObject.GetBaseUniversal(declaredExplicit, baseTagNo);
+        }
+
+        public static Asn1Object TryGetContextBaseUniversal(Asn1TaggedObject taggedObject, int tagNo,
+            bool declaredExplicit, int baseTagNo)
+        {
+            return TryGetBaseUniversal(taggedObject, Asn1Tags.ContextSpecific, tagNo, declaredExplicit, baseTagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObjectParser.ParseExplicitBaseTagged
+         */
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser ParseExplicitBaseTagged(Asn1TaggedObjectParser taggedObjectParser,
+            int tagClass, int tagNo)
+        {
+            return CheckTag(taggedObjectParser, tagClass, tagNo).ParseExplicitBaseTagged();
+        }
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser ParseExplicitContextBaseTagged(Asn1TaggedObjectParser taggedObjectParser,
+            int tagNo)
+        {
+            return ParseExplicitBaseTagged(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser TryParseExplicitBaseTagged(Asn1TaggedObjectParser taggedObjectParser,
+            int tagClass, int tagNo)
+        {
+            if (!taggedObjectParser.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObjectParser.ParseExplicitBaseTagged();
+        }
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser TryParseExplicitContextBaseTagged(
+            Asn1TaggedObjectParser taggedObjectParser, int tagNo)
+        {
+            return TryParseExplicitBaseTagged(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObjectParser.ParseImplicitBaseTagged
+         */
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser ParseImplicitBaseTagged(Asn1TaggedObjectParser taggedObjectParser,
+            int tagClass, int tagNo, int baseTagClass, int baseTagNo)
+        {
+            return CheckTag(taggedObjectParser, tagClass, tagNo).ParseImplicitBaseTagged(baseTagClass, baseTagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser ParseImplicitContextBaseTagged(Asn1TaggedObjectParser taggedObjectParser,
+            int tagNo, int baseTagClass, int baseTagNo)
+        {
+            return ParseImplicitBaseTagged(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo, baseTagClass,
+                baseTagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser TryParseImplicitBaseTagged(Asn1TaggedObjectParser taggedObjectParser,
+            int tagClass, int tagNo, int baseTagClass, int baseTagNo)
+        {
+            if (!taggedObjectParser.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObjectParser.ParseImplicitBaseTagged(baseTagClass, baseTagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static Asn1TaggedObjectParser TryParseImplicitContextBaseTagged(
+            Asn1TaggedObjectParser taggedObjectParser, int tagNo, int baseTagClass, int baseTagNo)
+        {
+            return TryParseImplicitBaseTagged(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo, baseTagClass,
+                baseTagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObjectParser.ParseBaseUniversal
+         */
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible ParseBaseUniversal(Asn1TaggedObjectParser taggedObjectParser, int tagClass,
+            int tagNo, bool declaredExplicit, int baseTagNo)
+        {
+            return CheckTag(taggedObjectParser, tagClass, tagNo).ParseBaseUniversal(declaredExplicit, baseTagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible ParseContextBaseUniversal(Asn1TaggedObjectParser taggedObjectParser, int tagNo,
+            bool declaredExplicit, int baseTagNo)
+        {
+            return ParseBaseUniversal(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo, declaredExplicit, baseTagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible TryParseBaseUniversal(Asn1TaggedObjectParser taggedObjectParser, int tagClass,
+            int tagNo, bool declaredExplicit, int baseTagNo)
+        {
+            if (!taggedObjectParser.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObjectParser.ParseBaseUniversal(declaredExplicit, baseTagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible TryParseContextBaseUniversal(Asn1TaggedObjectParser taggedObjectParser,
+            int tagNo, bool declaredExplicit, int baseTagNo)
+        {
+            return TryParseBaseUniversal(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo, declaredExplicit,
+                baseTagNo);
+        }
+
+
+        /*
+         * Wrappers for Asn1TaggedObjectParser.ParseExplicitBaseObject
+         */
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible ParseExplicitBaseObject(Asn1TaggedObjectParser taggedObjectParser, int tagClass,
+            int tagNo)
+        {
+            return CheckTag(taggedObjectParser, tagClass, tagNo).ParseExplicitBaseObject();
+        }
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible ParseExplicitContextBaseObject(Asn1TaggedObjectParser taggedObjectParser,
+            int tagNo)
+        {
+            return ParseExplicitBaseObject(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo);
+        }
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible TryParseExplicitBaseObject(Asn1TaggedObjectParser taggedObjectParser,
+            int tagClass, int tagNo)
+        {
+            if (!taggedObjectParser.HasTag(tagClass, tagNo))
+                return null;
+
+            return taggedObjectParser.ParseExplicitBaseObject();
+        }
+
+        /// <exception cref="IOException"/>
+        public static IAsn1Convertible TryParseExplicitContextBaseObject(Asn1TaggedObjectParser taggedObjectParser,
+            int tagNo)
+        {
+            return TryParseExplicitBaseObject(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/Asn1Utilities.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 62e229680bdece24987221dc054bce7d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERBitString.cs

@@ -0,0 +1,142 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Diagnostics;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class BerBitString
+        : DerBitString
+    {
+        private const int DefaultSegmentLimit = 1000;
+
+        internal static byte[] FlattenBitStrings(DerBitString[] bitStrings)
+        {
+            int count = bitStrings.Length;
+            switch (count)
+            {
+            case 0:
+                // No bits
+                return new byte[]{ 0 };
+            case 1:
+                return bitStrings[0].contents;
+            default:
+            {
+                int last = count - 1, totalLength = 0;
+                for (int i = 0; i < last; ++i)
+                {
+                    byte[] elementContents = bitStrings[i].contents;
+                    if (elementContents[0] != 0)
+                        throw new ArgumentException("only the last nested bitstring can have padding", "bitStrings");
+
+                    totalLength += elementContents.Length - 1;
+                }
+
+                // Last one can have padding
+                byte[] lastElementContents = bitStrings[last].contents;
+                byte padBits = lastElementContents[0];
+                totalLength += lastElementContents.Length;
+
+                byte[] contents = new byte[totalLength];
+                contents[0] = padBits;
+
+                int pos = 1;
+                for (int i = 0; i < count; ++i)
+                {
+                    byte[] elementContents = bitStrings[i].contents;
+                    int length = elementContents.Length - 1;
+                    Array.Copy(elementContents, 1, contents, pos, length);
+                    pos += length;
+                }
+
+                Debug.Assert(pos == totalLength);
+                return contents;
+            }
+            }
+        }
+
+        private readonly int segmentLimit;
+        private readonly DerBitString[] elements;
+
+        public BerBitString(byte data, int padBits)
+            : base(data, padBits)
+        {
+            this.elements = null;
+            this.segmentLimit = DefaultSegmentLimit;
+        }
+
+        public BerBitString(byte[] data)
+            : this(data, 0)
+        {
+        }
+
+        public BerBitString(byte[] data, int padBits)
+            : this(data, padBits, DefaultSegmentLimit)
+		{
+        }
+
+        public BerBitString(byte[] data, int padBits, int segmentLimit)
+            : base(data, padBits)
+        {
+            this.elements = null;
+            this.segmentLimit = segmentLimit;
+        }
+
+        public BerBitString(int namedBits)
+            : base(namedBits)
+        {
+            this.elements = null;
+            this.segmentLimit = DefaultSegmentLimit;
+        }
+
+        public BerBitString(Asn1Encodable obj)
+            : this(obj.GetDerEncoded(), 0)
+		{
+        }
+
+        public BerBitString(DerBitString[] elements)
+            : this(elements, DefaultSegmentLimit)
+        {
+        }
+
+        public BerBitString(DerBitString[] elements, int segmentLimit)
+            : base(FlattenBitStrings(elements), false)
+        {
+            this.elements = elements;
+            this.segmentLimit = segmentLimit;
+        }
+
+        internal BerBitString(byte[] contents, bool check)
+            : base(contents, check)
+        {
+            this.elements = null;
+            this.segmentLimit = DefaultSegmentLimit;
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncoding(encoding);
+
+            if (null == elements)
+                return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.BitString, contents);
+
+            return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.BitString,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncodingImplicit(encoding, tagClass, tagNo);
+
+            if (null == elements)
+                return new PrimitiveEncoding(tagClass, tagNo, contents);
+
+            return new ConstructedILEncoding(tagClass, tagNo,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERBitString.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2e6d38188b772c2409c7dad9240d601a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERGenerator.cs

@@ -0,0 +1,110 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public abstract class BerGenerator
+        : Asn1Generator
+    {
+        private bool      _tagged = false;
+        private bool      _isExplicit;
+        private int          _tagNo;
+
+        protected BerGenerator(
+            Stream outStream)
+            : base(outStream)
+        {
+        }
+
+        protected BerGenerator(
+            Stream outStream,
+            int tagNo,
+            bool isExplicit)
+            : base(outStream)
+        {
+            _tagged = true;
+            _isExplicit = isExplicit;
+            _tagNo = tagNo;
+        }
+
+		public override void AddObject(Asn1Encodable obj)
+		{
+            obj.EncodeTo(Out);
+		}
+
+        public override void AddObject(Asn1Object obj)
+        {
+            obj.EncodeTo(Out);
+        }
+
+        public override Stream GetRawOutputStream()
+        {
+            return Out;
+        }
+
+		public override void Close()
+		{
+			WriteBerEnd();
+		}
+
+        private void WriteHdr(
+            int tag)
+        {
+            Out.WriteByte((byte) tag);
+            Out.WriteByte(0x80);
+        }
+
+        protected void WriteBerHeader(
+            int tag)
+        {
+            if (_tagged)
+            {
+                int tagNum = _tagNo | Asn1Tags.ContextSpecific;
+
+                if (_isExplicit)
+                {
+                    WriteHdr(tagNum | Asn1Tags.Constructed);
+                    WriteHdr(tag);
+                }
+                else
+                {
+                    if ((tag & Asn1Tags.Constructed) != 0)
+                    {
+                        WriteHdr(tagNum | Asn1Tags.Constructed);
+                    }
+                    else
+                    {
+                        WriteHdr(tagNum);
+                    }
+                }
+            }
+            else
+            {
+                WriteHdr(tag);
+            }
+        }
+
+		protected void WriteBerBody(
+            Stream contentStream)
+        {
+			Streams.PipeAll(contentStream, Out);
+        }
+
+		protected void WriteBerEnd()
+        {
+            Out.WriteByte(0x00);
+            Out.WriteByte(0x00);
+
+            if (_tagged && _isExplicit)  // write extra end for tag header
+            {
+                Out.WriteByte(0x00);
+                Out.WriteByte(0x00);
+            }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ebf471a1d43735f4aa2425eda406c2d7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BEROctetStringGenerator.cs

@@ -0,0 +1,162 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public class BerOctetStringGenerator
+		: BerGenerator
+	{
+		public BerOctetStringGenerator(Stream outStream)
+			: base(outStream)
+		{
+			WriteBerHeader(Asn1Tags.Constructed | Asn1Tags.OctetString);
+		}
+
+		public BerOctetStringGenerator(
+			Stream	outStream,
+			int		tagNo,
+			bool	isExplicit)
+			: base(outStream, tagNo, isExplicit)
+		{
+			WriteBerHeader(Asn1Tags.Constructed | Asn1Tags.OctetString);
+		}
+
+		public Stream GetOctetOutputStream()
+		{
+			return GetOctetOutputStream(new byte[1000]); // limit for CER encoding.
+		}
+
+		public Stream GetOctetOutputStream(
+			int bufSize)
+		{
+			return bufSize < 1
+				?	GetOctetOutputStream()
+				:	GetOctetOutputStream(new byte[bufSize]);
+		}
+
+		public Stream GetOctetOutputStream(
+			byte[] buf)
+		{
+			return new BufferedBerOctetStream(this, buf);
+		}
+
+		private class BufferedBerOctetStream
+			: BaseOutputStream
+		{
+			private byte[] _buf;
+			private int    _off;
+			private readonly BerOctetStringGenerator _gen;
+			private readonly Asn1OutputStream _derOut;
+
+			internal BufferedBerOctetStream(
+				BerOctetStringGenerator	gen,
+				byte[]					buf)
+			{
+				_gen = gen;
+				_buf = buf;
+				_off = 0;
+				_derOut = Asn1OutputStream.Create(_gen.Out, Asn1Encodable.Der);
+			}
+
+			public override void Write(byte[] buffer, int offset, int count)
+			{
+				Streams.ValidateBufferArguments(buffer, offset, count);
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+                Write(buffer.AsSpan(offset, count));
+#else
+                int bufLen = _buf.Length;
+                int available = bufLen - _off;
+                if (count < available)
+                {
+                    Array.Copy(buffer, offset, _buf, _off, count);
+                    _off += count;
+                    return;
+                }
+
+                int pos = 0;
+                if (_off > 0)
+                {
+                    Array.Copy(buffer, offset, _buf, _off, available);
+                    pos = available;
+                    DerOctetString.Encode(_derOut, _buf, 0, bufLen);
+                    //_off = 0;
+                }
+
+                int remaining;
+                while ((remaining = count - pos) >= bufLen)
+                {
+                    DerOctetString.Encode(_derOut, buffer, offset + pos, bufLen);
+                    pos += bufLen;
+                }
+
+                Array.Copy(buffer, offset + pos, _buf, 0, remaining);
+                this._off = remaining;
+#endif
+            }
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+            public override void Write(ReadOnlySpan<byte> buffer)
+			{
+                int bufLen = _buf.Length;
+                int available = bufLen - _off;
+                if (buffer.Length < available)
+                {
+                    buffer.CopyTo(_buf.AsSpan(_off));
+                    _off += buffer.Length;
+                    return;
+                }
+
+                if (_off > 0)
+                {
+                    DerOctetString.Encode(_derOut, _buf.AsSpan(0, _off), buffer[..available]);
+                    buffer = buffer[available..];
+                    //_off = 0;
+                }
+
+                while (buffer.Length >= bufLen)
+                {
+                    DerOctetString.Encode(_derOut, buffer[..bufLen]);
+                    buffer = buffer[bufLen..];
+                }
+
+                buffer.CopyTo(_buf.AsSpan());
+                _off = buffer.Length;
+            }
+#endif
+
+            public override void WriteByte(byte value)
+			{
+				_buf[_off++] = value;
+
+				if (_off == _buf.Length)
+				{
+					DerOctetString.Encode(_derOut, _buf, 0, _off);
+					_off = 0;
+				}
+			}
+
+            protected override void Dispose(bool disposing)
+            {
+                if (disposing)
+                {
+                    if (_off != 0)
+                    {
+                        DerOctetString.Encode(_derOut, _buf, 0, _off);
+                    }
+
+                    _derOut.FlushInternal();
+
+                    _gen.WriteBerEnd();
+                }
+                base.Dispose(disposing);
+            }
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BEROctetStringGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d5318cc9ca270a547b9434252273ff30
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BEROctetStringParser.cs

@@ -0,0 +1,44 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class BerOctetStringParser
+        : Asn1OctetStringParser
+    {
+        private readonly Asn1StreamParser _parser;
+
+        internal BerOctetStringParser(Asn1StreamParser parser)
+        {
+            _parser = parser;
+        }
+
+        public Stream GetOctetStream()
+        {
+            return new ConstructedOctetStream(_parser);
+        }
+
+        public Asn1Object ToAsn1Object()
+        {
+            try
+            {
+                return Parse(_parser);
+            }
+            catch (IOException e)
+            {
+                throw new Asn1ParsingException("IOException converting stream to byte array: " + e.Message, e);
+            }
+        }
+
+        internal static BerOctetString Parse(Asn1StreamParser sp)
+        {
+            return new BerOctetString(Streams.ReadAll(new ConstructedOctetStream(sp)));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BEROctetStringParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f349002b9962c3f449219681235b114a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSequenceGenerator.cs

@@ -0,0 +1,28 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public class BerSequenceGenerator
+		: BerGenerator
+	{
+		public BerSequenceGenerator(
+			Stream outStream)
+			: base(outStream)
+		{
+			WriteBerHeader(Asn1Tags.Constructed | Asn1Tags.Sequence);
+		}
+
+		public BerSequenceGenerator(
+			Stream	outStream,
+			int		tagNo,
+			bool	isExplicit)
+			: base(outStream, tagNo, isExplicit)
+		{
+			WriteBerHeader(Asn1Tags.Constructed | Asn1Tags.Sequence);
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSequenceGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 39e69b682926f0348a2f183f3d1c8913
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSequenceParser.cs

@@ -0,0 +1,34 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class BerSequenceParser
+        : Asn1SequenceParser
+    {
+        private readonly Asn1StreamParser _parser;
+
+        internal BerSequenceParser(Asn1StreamParser parser)
+        {
+            this._parser = parser;
+        }
+
+        public IAsn1Convertible ReadObject()
+        {
+            return _parser.ReadObject();
+        }
+
+        public Asn1Object ToAsn1Object()
+        {
+            return Parse(_parser);
+        }
+
+        internal static BerSequence Parse(Asn1StreamParser sp)
+        {
+            return new BerSequence(sp.ReadVector());
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSequenceParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6d593cc0e2b63d14a8aeed9ce0369876
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSetGenerator.cs

@@ -0,0 +1,28 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public class BerSetGenerator
+		: BerGenerator
+	{
+		public BerSetGenerator(
+			Stream outStream)
+			: base(outStream)
+		{
+			WriteBerHeader(Asn1Tags.Constructed | Asn1Tags.Set);
+		}
+
+		public BerSetGenerator(
+			Stream	outStream,
+			int		tagNo,
+			bool	isExplicit)
+			: base(outStream, tagNo, isExplicit)
+		{
+			WriteBerHeader(Asn1Tags.Constructed | Asn1Tags.Set);
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSetGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0fbdbc3f5ccf9f446b5a5b30159adca1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSetParser.cs

@@ -0,0 +1,34 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class BerSetParser
+        : Asn1SetParser
+    {
+        private readonly Asn1StreamParser _parser;
+
+        internal BerSetParser(Asn1StreamParser parser)
+        {
+            this._parser = parser;
+        }
+
+        public IAsn1Convertible ReadObject()
+        {
+            return _parser.ReadObject();
+        }
+
+        public Asn1Object ToAsn1Object()
+        {
+            return Parse(_parser);
+        }
+
+        internal static BerSet Parse(Asn1StreamParser sp)
+        {
+            return new BerSet(sp.ReadVector());
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERSetParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0260d4642cd5cf94c965eb9cd0ea9635
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERTaggedObjectParser.cs

@@ -0,0 +1,84 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	internal class BerTaggedObjectParser
+		: Asn1TaggedObjectParser
+	{
+        internal readonly int m_tagClass;
+        internal readonly int m_tagNo;
+        internal readonly Asn1StreamParser m_parser;
+
+		internal BerTaggedObjectParser(int tagClass, int tagNo, Asn1StreamParser parser)
+		{
+            m_tagClass = tagClass;
+            m_tagNo = tagNo;
+            m_parser = parser;
+		}
+
+		public virtual bool IsConstructed
+		{
+			get { return true; }
+		}
+
+        public int TagClass
+        {
+            get { return m_tagClass; }
+        }
+
+		public int TagNo
+		{
+			get { return m_tagNo; }
+		}
+
+        public bool HasContextTag(int tagNo)
+        {
+            return m_tagClass == Asn1Tags.ContextSpecific && m_tagNo == tagNo;
+        }
+
+        public bool HasTag(int tagClass, int tagNo)
+        {
+            return m_tagClass == tagClass && m_tagNo == tagNo;
+        }
+
+        public virtual IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo)
+        {
+            if (declaredExplicit)
+                return m_parser.ParseObject(baseTagNo);
+
+            return m_parser.ParseImplicitConstructedIL(baseTagNo);
+        }
+
+        public virtual IAsn1Convertible ParseExplicitBaseObject()
+        {
+            return m_parser.ReadObject();
+        }
+
+        public virtual Asn1TaggedObjectParser ParseExplicitBaseTagged()
+        {
+            return m_parser.ParseTaggedObject();
+        }
+
+        public virtual Asn1TaggedObjectParser ParseImplicitBaseTagged(int baseTagClass, int baseTagNo)
+        {
+            return new BerTaggedObjectParser(baseTagClass, baseTagNo, m_parser);
+        }
+
+        public virtual Asn1Object ToAsn1Object()
+		{
+			try
+			{
+                return m_parser.LoadTaggedIL(TagClass, TagNo);
+            }
+			catch (IOException e)
+			{
+				throw new Asn1ParsingException(e.Message);
+			}
+		}
+	}
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BERTaggedObjectParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 59190053596d8924a9902581e3b94f46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerApplicationSpecific.cs

@@ -0,0 +1,3 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerApplicationSpecific.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2d565bd50647e32459915b52caf8d736
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerApplicationSpecificParser.cs

@@ -0,0 +1,2 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerApplicationSpecificParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f60af26f2a3ecad4ab67ab32b5796bbe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerBitStringParser.cs

@@ -0,0 +1,60 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    /// <summary>A parser for indefinite-length BIT STRINGs.</summary>
+    internal class BerBitStringParser
+        : Asn1BitStringParser
+    {
+        private readonly Asn1StreamParser m_parser;
+
+        private ConstructedBitStream m_bitStream;
+
+        internal BerBitStringParser(Asn1StreamParser parser)
+        {
+            m_parser = parser;
+        }
+
+        public Stream GetOctetStream()
+        {
+            return m_bitStream = new ConstructedBitStream(m_parser, true);
+        }
+
+        public Stream GetBitStream()
+        {
+            return m_bitStream = new ConstructedBitStream(m_parser, false);
+        }
+
+        public int PadBits
+        {
+            get { return m_bitStream.PadBits; }
+        }
+
+        public Asn1Object ToAsn1Object()
+        {
+            try
+            {
+                return Parse(m_parser);
+            }
+            catch (IOException e)
+            {
+                throw new Asn1ParsingException("IOException converting stream to byte array: " + e.Message, e);
+            }
+        }
+
+        internal static BerBitString Parse(Asn1StreamParser sp)
+        {
+            ConstructedBitStream bitStream = new ConstructedBitStream(sp, false);
+            byte[] data = Streams.ReadAll(bitStream);
+            int padBits = bitStream.PadBits;
+            return new BerBitString(data, padBits);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerBitStringParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0935e7c4731287a488fd95f8f9670666
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerOctetString.cs

@@ -0,0 +1,112 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.Diagnostics;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class BerOctetString
+        : DerOctetString
+    {
+        private const int DefaultSegmentLimit = 1000;
+
+        public static BerOctetString FromSequence(Asn1Sequence seq)
+        {
+            int count = seq.Count;
+            Asn1OctetString[] v = new Asn1OctetString[count];
+            for (int i = 0; i < count; ++i)
+            {
+                v[i] = GetInstance(seq[i]);
+            }
+            return new BerOctetString(v);
+        }
+
+        internal static byte[] FlattenOctetStrings(Asn1OctetString[] octetStrings)
+        {
+            int count = octetStrings.Length;
+            switch (count)
+            {
+            case 0:
+                return EmptyOctets;
+            case 1:
+                return octetStrings[0].contents;
+            default:
+            {
+                int totalOctets = 0;
+                for (int i = 0; i < count; ++i)
+                {
+                    totalOctets += octetStrings[i].contents.Length;
+                }
+
+                byte[] str = new byte[totalOctets];
+                int pos = 0;
+                for (int i = 0; i < count; ++i)
+                {
+                    byte[] octets = octetStrings[i].contents;
+                    Array.Copy(octets, 0, str, pos, octets.Length);
+                    pos += octets.Length;
+                }
+
+                Debug.Assert(pos == totalOctets);
+                return str;
+            }
+            }
+        }
+
+        private readonly int segmentLimit;
+        private readonly Asn1OctetString[] elements;
+
+        public BerOctetString(byte[] contents)
+			: this(contents, DefaultSegmentLimit)
+		{
+		}
+
+        public BerOctetString(Asn1OctetString[] elements)
+            : this(elements, DefaultSegmentLimit)
+        {
+        }
+
+        public BerOctetString(byte[] contents, int segmentLimit)
+            : this(contents, null, segmentLimit)
+        {
+        }
+
+        public BerOctetString(Asn1OctetString[] elements, int segmentLimit)
+            : this(FlattenOctetStrings(elements), elements, segmentLimit)
+        {
+        }
+
+        private BerOctetString(byte[] contents, Asn1OctetString[] elements, int segmentLimit)
+            : base(contents)
+        {
+            this.elements = elements;
+            this.segmentLimit = segmentLimit;
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncoding(encoding);
+
+            if (null == elements)
+                return new PrimitiveEncoding(Asn1Tags.Universal, Asn1Tags.OctetString, contents);
+
+            return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.OctetString,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncodingImplicit(encoding, tagClass, tagNo);
+
+            if (null == elements)
+                return new PrimitiveEncoding(tagClass, tagNo, contents);
+
+            return new ConstructedILEncoding(tagClass, tagNo,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerOctetString.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d06a07cbd3b71a74f8cb664efab20cd0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerOutputStream.cs

@@ -0,0 +1,3 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerOutputStream.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4acf00c72bf317e489e931a8c0c3c3da
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerSequence.cs

@@ -0,0 +1,101 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	public class BerSequence
+		: DerSequence
+	{
+		public static new readonly BerSequence Empty = new BerSequence();
+
+		public static new BerSequence FromVector(Asn1EncodableVector elementVector)
+		{
+            return elementVector.Count < 1 ? Empty : new BerSequence(elementVector);
+		}
+
+		/**
+		 * create an empty sequence
+		 */
+		public BerSequence()
+            : base()
+		{
+		}
+
+		/**
+		 * create a sequence containing one object
+		 */
+		public BerSequence(Asn1Encodable element)
+            : base(element)
+		{
+		}
+
+        /**
+		 * create a sequence containing two objects
+		 */
+        public BerSequence(Asn1Encodable element1, Asn1Encodable element2)
+            : base(element1, element2)
+        {
+        }
+
+        public BerSequence(params Asn1Encodable[] elements)
+            : base(elements)
+		{
+		}
+
+		/**
+		 * create a sequence containing a vector of objects.
+		 */
+		public BerSequence(Asn1EncodableVector elementVector)
+            : base(elementVector)
+		{
+		}
+
+        internal BerSequence(Asn1Encodable[] elements, bool clone)
+            : base(elements, clone)
+        {
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncoding(encoding);
+
+            return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.Sequence,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncodingImplicit(encoding, tagClass, tagNo);
+
+            return new ConstructedILEncoding(tagClass, tagNo,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+
+        internal override DerBitString ToAsn1BitString()
+        {
+            return new BerBitString(GetConstructedBitStrings());
+        }
+
+        internal override DerExternal ToAsn1External()
+        {
+            // TODO There is currently no BerExternal class (or ToDLObject/ToDerObject)
+            //return ((Asn1Sequence)ToDLObject()).ToAsn1External();
+            return new DLSequence(elements).ToAsn1External();
+        }
+
+        internal override Asn1OctetString ToAsn1OctetString()
+        {
+            return new BerOctetString(GetConstructedOctetStrings());
+        }
+
+        internal override Asn1Set ToAsn1Set()
+        {
+            return new BerSet(false, elements);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerSequence.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c5bc0026174da4a4e878a4914a50457b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerSet.cs

@@ -0,0 +1,73 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    public class BerSet
+        : DerSet
+    {
+		public static new readonly BerSet Empty = new BerSet();
+
+		public static new BerSet FromVector(Asn1EncodableVector elementVector)
+		{
+            return elementVector.Count < 1 ? Empty : new BerSet(elementVector);
+		}
+
+		/**
+         * create an empty set
+         */
+        public BerSet()
+            : base()
+        {
+        }
+
+        /**
+         * create a set containing one object
+         */
+        public BerSet(Asn1Encodable element)
+            : base(element)
+        {
+        }
+
+        public BerSet(params Asn1Encodable[] elements)
+            : base(elements, false)
+        {
+        }
+
+        /**
+         * create a set containing a vector of objects.
+         */
+        public BerSet(Asn1EncodableVector elementVector)
+            : base(elementVector, false)
+        {
+        }
+
+        internal BerSet(bool isSorted, Asn1Encodable[] elements)
+            : base(isSorted, elements)
+        {
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncoding(encoding);
+
+            return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.Set,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncodingImplicit(encoding, tagClass, tagNo);
+
+            return new ConstructedILEncoding(tagClass, tagNo,
+                Asn1OutputStream.GetContentsEncodings(encoding, elements));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerSet.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01890d0dd345cff48bdbba411a658317
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerTaggedObject.cs

@@ -0,0 +1,92 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+	/**
+	 * BER TaggedObject - in ASN.1 notation this is any object preceded by
+	 * a [n] where n is some number - these are assumed to follow the construction
+	 * rules (as with sequences).
+	 */
+	public class BerTaggedObject
+		: DerTaggedObject
+	{
+        /**
+		 * @param tagNo the tag number for this object.
+		 * @param obj the tagged object.
+		 */
+        public BerTaggedObject(int tagNo, Asn1Encodable obj)
+			: base(true, tagNo, obj)
+		{
+		}
+
+        public BerTaggedObject(int tagClass, int tagNo, Asn1Encodable obj)
+            : base(true, tagClass, tagNo, obj)
+        {
+        }
+
+        /**
+		 * @param isExplicit true if an explicitly tagged object.
+		 * @param tagNo the tag number for this object.
+		 * @param obj the tagged object.
+		 */
+        public BerTaggedObject(bool isExplicit, int tagNo, Asn1Encodable obj)
+			: base(isExplicit, tagNo, obj)
+		{
+		}
+
+        public BerTaggedObject(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(isExplicit, tagClass, tagNo, obj)
+        {
+        }
+
+        internal BerTaggedObject(int explicitness, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(explicitness, tagClass, tagNo, obj)
+        {
+        }
+
+        internal override string Asn1Encoding
+        {
+            get { return Ber; }
+        }
+
+        internal override IAsn1Encoding GetEncoding(int encoding)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncoding(encoding);
+
+            Asn1Object baseObject = GetBaseObject().ToAsn1Object();
+
+            if (!IsExplicit())
+                return baseObject.GetEncodingImplicit(encoding, TagClass, TagNo);
+
+            return new ConstructedILEncoding(TagClass, TagNo, new IAsn1Encoding[]{ baseObject.GetEncoding(encoding) });
+        }
+
+        internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
+        {
+            if (Asn1OutputStream.EncodingBer != encoding)
+                return base.GetEncodingImplicit(encoding, tagClass, tagNo);
+
+            Asn1Object baseObject = GetBaseObject().ToAsn1Object();
+
+            if (!IsExplicit())
+                return baseObject.GetEncodingImplicit(encoding, tagClass, tagNo);
+
+            return new ConstructedILEncoding(tagClass, tagNo, new IAsn1Encoding[]{ baseObject.GetEncoding(encoding) });
+        }
+
+        internal override Asn1Sequence RebuildConstructed(Asn1Object asn1Object)
+        {
+            return new BerSequence(asn1Object);
+        }
+
+        internal override Asn1TaggedObject ReplaceTag(int tagClass, int tagNo)
+        {
+            return new BerTaggedObject(explicitness, tagClass, tagNo, obj);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/BerTaggedObject.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cb57ca2d9225e0340bc7c9ef54c0bd13
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedBitStream.cs

@@ -0,0 +1,192 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+using System.IO;
+
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities;
+using BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.IO;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal class ConstructedBitStream
+        : BaseInputStream
+    {
+        private readonly Asn1StreamParser m_parser;
+        private readonly bool m_octetAligned;
+
+        private bool m_first = true;
+        private int m_padBits = 0;
+
+        private Asn1BitStringParser m_currentParser;
+        private Stream m_currentStream;
+
+        internal ConstructedBitStream(Asn1StreamParser parser, bool octetAligned)
+        {
+            m_parser = parser;
+            m_octetAligned = octetAligned;
+        }
+
+        internal int PadBits
+        {
+            get { return m_padBits; }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            Streams.ValidateBufferArguments(buffer, offset, count);
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+            return Read(buffer.AsSpan(offset, count));
+#else
+            if (count < 1)
+                return 0;
+
+            if (m_currentStream == null)
+            {
+                if (!m_first)
+                    return 0;
+
+                m_currentParser = GetNextParser();
+                if (m_currentParser == null)
+                    return 0;
+
+                m_first = false;
+                m_currentStream = m_currentParser.GetBitStream();
+            }
+
+            int totalRead = 0;
+
+            for (;;)
+            {
+                int numRead = m_currentStream.Read(buffer, offset + totalRead, count - totalRead);
+
+                if (numRead > 0)
+                {
+                    totalRead += numRead;
+
+                    if (totalRead == count)
+                        return totalRead;
+                }
+                else
+                {
+                    m_padBits = m_currentParser.PadBits;
+                    m_currentParser = GetNextParser();
+                    if (m_currentParser == null)
+                    {
+                        m_currentStream = null;
+                        return totalRead;
+                    }
+
+                    m_currentStream = m_currentParser.GetBitStream();
+                }
+            }
+#endif
+        }
+
+#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || _UNITY_2021_2_OR_NEWER_
+        public override int Read(Span<byte> buffer)
+        {
+            if (buffer.IsEmpty)
+                return 0;
+
+            if (m_currentStream == null)
+            {
+                if (!m_first)
+                    return 0;
+
+                m_currentParser = GetNextParser();
+                if (m_currentParser == null)
+                    return 0;
+
+                m_first = false;
+                m_currentStream = m_currentParser.GetBitStream();
+            }
+
+            int totalRead = 0;
+
+            for (;;)
+            {
+                int numRead = m_currentStream.Read(buffer[totalRead..]);
+
+                if (numRead > 0)
+                {
+                    totalRead += numRead;
+
+                    if (totalRead == buffer.Length)
+                        return totalRead;
+                }
+                else
+                {
+                    m_padBits = m_currentParser.PadBits;
+                    m_currentParser = GetNextParser();
+                    if (m_currentParser == null)
+                    {
+                        m_currentStream = null;
+                        return totalRead;
+                    }
+
+                    m_currentStream = m_currentParser.GetBitStream();
+                }
+            }
+        }
+#endif
+
+        public override int ReadByte()
+        {
+            if (m_currentStream == null)
+            {
+                if (!m_first)
+                    return -1;
+
+                m_currentParser = GetNextParser();
+                if (m_currentParser == null)
+                    return -1;
+
+                m_first = false;
+                m_currentStream = m_currentParser.GetBitStream();
+            }
+
+            for (;;)
+            {
+                int b = m_currentStream.ReadByte();
+
+                if (b >= 0)
+                    return b;
+
+                m_padBits = m_currentParser.PadBits;
+                m_currentParser = GetNextParser();
+                if (m_currentParser == null)
+                {
+                    m_currentStream = null;
+                    return -1;
+                }
+
+                m_currentStream = m_currentParser.GetBitStream();
+            }
+        }
+
+        private Asn1BitStringParser GetNextParser()
+        {
+            IAsn1Convertible asn1Obj = m_parser.ReadObject();
+            if (asn1Obj == null)
+            {
+                if (m_octetAligned && m_padBits != 0)
+                    throw new IOException("expected octet-aligned bitstring, but found padBits: " + m_padBits);
+
+                return null;
+            }
+
+            if (asn1Obj is Asn1BitStringParser)
+            {
+                if (m_padBits != 0)
+                    throw new IOException("only the last nested bitstring can have padding");
+
+                return (Asn1BitStringParser)asn1Obj;
+            }
+
+            throw new IOException("unknown object encountered: " + Org.BouncyCastle.Utilities.Platform.GetTypeName(asn1Obj));
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedBitStream.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86bbb9386c084ce47a3672ac12a5afa1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedDLEncoding.cs

@@ -0,0 +1,39 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal class ConstructedDLEncoding
+        : IAsn1Encoding
+    {
+        private readonly int m_tagClass;
+        private readonly int m_tagNo;
+        private readonly IAsn1Encoding[] m_contentsElements;
+        private readonly int m_contentsLength;
+
+        internal ConstructedDLEncoding(int tagClass, int tagNo, IAsn1Encoding[] contentsElements)
+        {
+            m_tagClass = tagClass;
+            m_tagNo = tagNo;
+            m_contentsElements = contentsElements;
+            m_contentsLength = Asn1OutputStream.GetLengthOfContents(contentsElements);
+        }
+
+        void IAsn1Encoding.Encode(Asn1OutputStream asn1Out)
+        {
+            asn1Out.WriteIdentifier(Asn1Tags.Constructed | m_tagClass, m_tagNo);
+            asn1Out.WriteDL(m_contentsLength);
+            asn1Out.EncodeContents(m_contentsElements);
+        }
+
+        int IAsn1Encoding.GetLength()
+        {
+            return Asn1OutputStream.GetLengthOfIdentifier(m_tagNo)
+                +  Asn1OutputStream.GetLengthOfDL(m_contentsLength)
+                +  m_contentsLength;
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedDLEncoding.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 95ca1443910ef7d48b13c585349fd261
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedILEncoding.cs

@@ -0,0 +1,39 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal class ConstructedILEncoding
+        : IAsn1Encoding
+    {
+        private readonly int m_tagClass;
+        private readonly int m_tagNo;
+        private readonly IAsn1Encoding[] m_contentsElements;
+
+        internal ConstructedILEncoding(int tagClass, int tagNo, IAsn1Encoding[] contentsElements)
+        {
+            m_tagClass = tagClass;
+            m_tagNo = tagNo;
+            m_contentsElements = contentsElements;
+        }
+
+        void IAsn1Encoding.Encode(Asn1OutputStream asn1Out)
+        {
+            asn1Out.WriteIdentifier(Asn1Tags.Constructed | m_tagClass, m_tagNo);
+            asn1Out.WriteByte(0x80);
+            asn1Out.EncodeContents(m_contentsElements);
+            asn1Out.WriteByte(0x00);
+            asn1Out.WriteByte(0x00);
+        }
+
+        int IAsn1Encoding.GetLength()
+        {
+            return Asn1OutputStream.GetLengthOfIdentifier(m_tagNo)
+                +  3
+                +  Asn1OutputStream.GetLengthOfContents(m_contentsElements);
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedILEncoding.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8ddca6f0e8886b5409e7379e9d09dc77
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedLazyDLEncoding.cs

@@ -0,0 +1,37 @@
+#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
+#pragma warning disable
+using System;
+
+namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Asn1
+{
+    internal class ConstructedLazyDLEncoding
+        : IAsn1Encoding
+    {
+        private readonly int m_tagClass;
+        private readonly int m_tagNo;
+        private readonly byte[] m_contentsOctets;
+
+        internal ConstructedLazyDLEncoding(int tagClass, int tagNo, byte[] contentsOctets)
+        {
+            m_tagClass = tagClass;
+            m_tagNo = tagNo;
+            m_contentsOctets = contentsOctets;
+        }
+
+        void IAsn1Encoding.Encode(Asn1OutputStream asn1Out)
+        {
+            asn1Out.WriteIdentifier(Asn1Tags.Constructed | m_tagClass, m_tagNo);
+            asn1Out.WriteDL(m_contentsOctets.Length);
+            asn1Out.Write(m_contentsOctets, 0, m_contentsOctets.Length);
+        }
+
+        int IAsn1Encoding.GetLength()
+        {
+            return Asn1OutputStream.GetLengthOfIdentifier(m_tagNo)
+                +  Asn1OutputStream.GetLengthOfDL(m_contentsOctets.Length)
+                +  m_contentsOctets.Length;
+        }
+    }
+}
+#pragma warning restore
+#endif

JNFrame2/Assets/Plugins/Best HTTP/Source/SecureProtocol/asn1/ConstructedLazyDLEncoding.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c7c2fedd867a2bf41bb4a45ced6041d4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: