Imported Upstream version 4.3.2.467

Former-commit-id: 9c2cb47f45fa221e661ab616387c9cda183f283d

mcs/class/Mono.Security.Providers.NewTls/Makefile

@@ -0,0 +1,12 @@
+thisdir = class/Mono.Security.Providers.NewTls
+SUBDIRS = 
+include ../../build/rules.make
+
+LIBRARY = Mono.Security.Providers.NewTls.dll
+LIB_MCS_FLAGS = -unsafe -nowarn:1030 -keyfile:../mono.pub -delaysign -r:System.dll \
+	-r:NewSystemSource=Mono.Security.Providers.NewSystemSource.dll -r:Mono.Security.dll
+
+include ../../build/library.make
+
+$(the_lib): ../Mono.Security/Makefile
+

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls.dll.sources

@@ -0,0 +1,13 @@
+./Properties/AssemblyInfo.cs
+../../build/common/SR.cs
+../../build/common/Consts.cs
+../../build/common/Locale.cs
+
+./Mono.Security.Providers.NewTls/ITlsConfiguration.cs
+./Mono.Security.Providers.NewTls/ITlsContext.cs
+
+./Mono.Security.Providers.NewTls/MonoNewTlsStream.cs
+./Mono.Security.Providers.NewTls/MonoNewTlsStreamFactory.cs
+./Mono.Security.Providers.NewTls/NewTlsProvider.cs
+./Mono.Security.Providers.NewTls/TlsContextWrapper.cs
+./Mono.Security.Providers.NewTls/TlsProviderFactory.cs

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/ITlsConfiguration.cs

@@ -0,0 +1,47 @@
+//
+// ITlsContext.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015-2016 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Security.Cryptography;
+
+using Mono.Security.Interface;
+using MX = Mono.Security.X509;
+
+namespace Mono.Security.Providers.NewTls
+{
+	interface ITlsConfiguration
+	{
+		bool HasCredentials {
+			get;
+		}
+
+		void SetCertificate (MX.X509Certificate certificate, AsymmetricAlgorithm privateKey);
+
+		bool? AskForClientCertificate {
+			get; set;
+		}
+	}
+}

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/ITlsContext.cs

@@ -0,0 +1,70 @@
+//
+// ITlsContext.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015-2016 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+extern alias NewSystemSource;
+
+using System;
+using System.Security.Cryptography;
+
+using Mono.Security.Interface;
+using MX = Mono.Security.X509;
+
+namespace Mono.Security.Providers.NewTls
+{
+	interface ITlsContext : IDisposable
+	{
+		bool IsValid {
+			get;
+		}
+
+		TlsException LastError {
+			get;
+		}
+
+		bool ReceivedCloseNotify {
+			get;
+		}
+
+		MonoTlsConnectionInfo ConnectionInfo {
+			get;
+		}
+
+		MX.X509Certificate GetRemoteCertificate (out MX.X509CertificateCollection remoteCertificateStore);
+
+		bool VerifyRemoteCertificate ();
+
+		int GenerateNextToken (TlsBuffer incoming, TlsMultiBuffer outgoing);
+
+		int DecryptMessage (ref TlsBuffer incoming);
+
+		int EncryptMessage (ref TlsBuffer incoming);
+
+		byte[] CreateAlert (Alert alert);
+
+		byte[] CreateHelloRequest ();
+	}
+}
+

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/MonoNewTlsStream.cs

@@ -0,0 +1,93 @@
+//
+// MonoNewTlsStream.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+extern alias NewSystemSource;
+
+using EncryptionPolicy = NewSystemSource::System.Net.Security.EncryptionPolicy;
+using LocalCertificateSelectionCallback = NewSystemSource::System.Net.Security.LocalCertificateSelectionCallback;
+using RemoteCertificateValidationCallback = NewSystemSource::System.Net.Security.RemoteCertificateValidationCallback;
+using SslStream = NewSystemSource::System.Net.Security.SslStream;
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+using MSI = Mono.Security.Interface;
+
+using XAuthenticatedStream = System.Net.Security.AuthenticatedStream;
+using System.Security.Cryptography.X509Certificates;
+
+namespace Mono.Security.Providers.NewTls
+{
+	public class MonoNewTlsStream : SslStream, MSI.IMonoSslStream
+	{
+		MSI.MonoTlsProvider provider;
+
+		internal MonoNewTlsStream (Stream innerStream, MSI.MonoTlsProvider provider, MSI.MonoTlsSettings settings)
+			: this (innerStream, false, provider, settings)
+		{
+		}
+
+		internal MonoNewTlsStream (Stream innerStream, bool leaveOpen, MSI.MonoTlsProvider provider, MSI.MonoTlsSettings settings)
+			: base (innerStream, leaveOpen, EncryptionPolicy.RequireEncryption, provider, settings)
+		{
+			this.provider = provider;
+		}
+
+		public MSI.MonoTlsProvider Provider {
+			get { return provider; }
+		}
+
+		new public bool IsClosed {
+			get { return base.IsClosed; }
+		}
+
+		public MSI.MonoTlsConnectionInfo GetConnectionInfo ()
+		{
+			return GetMonoConnectionInfo ();
+		}
+
+		public Task Shutdown ()
+		{
+			return Task.Factory.FromAsync ((state, result) => BeginShutdown (state, result), EndShutdown, null);
+		}
+
+		public Task RequestRenegotiation ()
+		{
+			return Task.Factory.FromAsync ((state, result) => BeginRenegotiate (state, result), EndRenegotiate, null);
+		}
+
+		 X509Certificate MSI.IMonoSslStream.InternalLocalCertificate {
+			get { return InternalLocalCertificate; }
+		}
+
+		XAuthenticatedStream MSI.IMonoSslStream.AuthenticatedStream {
+			get { return this; }
+		}
+	}
+}
+
+

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/MonoNewTlsStreamFactory.cs

@@ -0,0 +1,91 @@
+//
+// MonoNewTlsStreamFactory.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+extern alias NewSystemSource;
+
+using XEncryptionPolicy = NewSystemSource::System.Net.Security.EncryptionPolicy;
+using XSslPolicyErrors = NewSystemSource::System.Net.Security.SslPolicyErrors;
+using XLocalCertificateSelectionCallback = NewSystemSource::System.Net.Security.LocalCertificateSelectionCallback;
+using XRemoteCertificateValidationCallback = NewSystemSource::System.Net.Security.RemoteCertificateValidationCallback;
+
+using System;
+using System.IO;
+using System.Net.Security;
+using System.Security.Authentication;
+
+using Mono.Security.Interface;
+
+using PSSCX = System.Security.Cryptography.X509Certificates;
+using SSCX = System.Security.Cryptography.X509Certificates;
+
+namespace Mono.Security.Providers.NewTls
+{
+	public static class MonoNewTlsStreamFactory
+	{
+		internal static IMonoSslStream CreateSslStream (
+			Stream innerStream, bool leaveInnerStreamOpen,
+			MonoTlsProvider provider, MonoTlsSettings settings = null)
+		{
+			return new MonoNewTlsStream (innerStream, leaveInnerStreamOpen, provider, settings);
+		}
+
+		public static MonoNewTlsStream CreateServer (
+			Stream innerStream, bool leaveOpen, MonoTlsProvider provider, MonoTlsSettings settings,
+			SSCX.X509Certificate serverCertificate, bool clientCertificateRequired,
+			SslProtocols enabledSslProtocols, bool checkCertificateRevocation)
+		{
+			var stream = new MonoNewTlsStream (innerStream, leaveOpen, provider, settings);
+
+			try {
+				stream.AuthenticateAsServer (serverCertificate, clientCertificateRequired, enabledSslProtocols, checkCertificateRevocation);
+			} catch (Exception ex) {
+				var tlsEx = stream.LastError;
+				if (tlsEx != null)
+					throw new AggregateException (ex, tlsEx);
+				throw;
+			}
+
+			return stream;
+		}
+
+		public static MonoNewTlsStream CreateClient (
+			Stream innerStream, bool leaveOpen, MonoTlsProvider provider, MonoTlsSettings settings,
+			string targetHost, PSSCX.X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation)
+		{
+			var stream = new MonoNewTlsStream (innerStream, leaveOpen, provider, settings);
+
+			try {
+				stream.AuthenticateAsClient (targetHost, clientCertificates, enabledSslProtocols, checkCertificateRevocation);
+			} catch (Exception ex) {
+				var tlsEx = stream.LastError;
+				if (tlsEx != null)
+					throw new AggregateException (ex, tlsEx);
+				throw;
+			}
+			return stream;
+		}
+	}
+}

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/NewTlsProvider.cs

@@ -0,0 +1,95 @@
+//
+// NewTlsProvider.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+extern alias NewSystemSource;
+
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Security;
+using System.Security.Authentication;
+
+using MSI = Mono.Security.Interface;
+using MX = Mono.Security.X509;
+
+using PSSCX = System.Security.Cryptography.X509Certificates;
+using SSCX = System.Security.Cryptography.X509Certificates;
+
+namespace Mono.Security.Providers.NewTls
+{
+	public class NewTlsProvider : MSI.MonoTlsProvider
+	{
+		static readonly Guid id = new Guid ("e5ff34f1-8b7a-4aa6-aff9-24719d709693");
+
+		public override Guid ID {
+			get { return id; }
+		}
+
+		public override string Name {
+			get { return "newtls"; }
+		}
+
+		public override bool SupportsSslStream {
+			get { return true; }
+		}
+
+		public override bool SupportsConnectionInfo {
+			get { return true; }
+		}
+
+		public override bool SupportsMonoExtensions {
+			get { return true; }
+		}
+
+		internal override bool SupportsTlsContext {
+			get { return true; }
+		}
+
+		public override SslProtocols SupportedProtocols {
+			get { return SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls; }
+		}
+
+		public override MSI.IMonoSslStream CreateSslStream (
+			Stream innerStream, bool leaveInnerStreamOpen,
+			MSI.MonoTlsSettings settings = null)
+		{
+			return MonoNewTlsStreamFactory.CreateSslStream (innerStream, leaveInnerStreamOpen, this, settings);
+		}
+
+		internal override MSI.IMonoTlsContext CreateTlsContext (
+			string hostname, bool serverMode, MSI.TlsProtocols protocolFlags,
+			SSCX.X509Certificate serverCertificate, PSSCX.X509CertificateCollection clientCertificates,
+			bool remoteCertRequired, MSI.MonoEncryptionPolicy encryptionPolicy,
+			MSI.MonoTlsSettings settings)
+		{
+			var config = TlsProviderFactory.CreateTlsConfiguration (
+				hostname, serverMode, protocolFlags, serverCertificate,
+				remoteCertRequired, settings);
+			return new TlsContextWrapper (config, serverMode);
+		}
+	}
+}
+

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/TlsContextWrapper.cs

@@ -0,0 +1,221 @@
+//
+// TlsContextWrapper.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+extern alias NewSystemSource;
+
+using System;
+using System.Security.Cryptography;
+
+using SSCX = System.Security.Cryptography.X509Certificates;
+using PSSCX = System.Security.Cryptography.X509Certificates;
+
+using MSI = Mono.Security.Interface;
+using MX = Mono.Security.X509;
+
+namespace Mono.Security.Providers.NewTls
+{
+	class TlsContextWrapper : IDisposable, MSI.IMonoTlsContext
+	{
+		ITlsConfiguration config;
+		ITlsContext context;
+		bool serverMode;
+
+		public TlsContextWrapper (ITlsConfiguration config, bool serverMode)
+		{
+			this.config = config;
+			this.serverMode = serverMode;
+		}
+
+		public bool IsServer {
+			get { return serverMode; }
+		}
+
+		public bool IsValid {
+			get { return context != null && context.IsValid; }
+		}
+
+		public void Initialize (MSI.IMonoTlsEventSink eventSink)
+		{
+			if (context != null)
+				throw new InvalidOperationException ();
+			context = TlsProviderFactory.CreateTlsContext (config, serverMode, eventSink);
+		}
+
+		void Clear ()
+		{
+			if (context != null) {
+				context.Dispose ();
+				context = null;
+			}
+		}
+
+		public ITlsConfiguration Configuration {
+			get {
+				if (config == null)
+					throw new ObjectDisposedException ("TlsConfiguration");
+				return config;
+			}
+		}
+
+		public ITlsContext Context {
+			get {
+				if (!IsValid)
+					throw new ObjectDisposedException ("TlsContext");
+				return context;
+			}
+		}
+
+		public bool HasCredentials {
+			get { return Configuration.HasCredentials; }
+		}
+
+		public void SetCertificate (SSCX.X509Certificate certificate, AsymmetricAlgorithm privateKey)
+		{
+			var monoCert = new MX.X509Certificate (certificate.GetRawCertData ());
+			Configuration.SetCertificate (monoCert, privateKey);
+		}
+
+		public int GenerateNextToken (MSI.IBufferOffsetSize incoming, out MSI.IBufferOffsetSize outgoing)
+		{
+			var input = incoming != null ? new MSI.TlsBuffer (BOSWrapper.Wrap (incoming)) : null;
+			var output = new MSI.TlsMultiBuffer ();
+			var retval = Context.GenerateNextToken (input, output);
+			if (output.IsEmpty)
+				outgoing = null;
+			outgoing = BOSWrapper.Wrap (output.StealBuffer ());
+			return (int)retval;
+		}
+
+		public int EncryptMessage (ref MSI.IBufferOffsetSize incoming)
+		{
+			var buffer = new MSI.TlsBuffer (BOSWrapper.Wrap (incoming));
+			var retval = Context.EncryptMessage (ref buffer);
+			incoming = BOSWrapper.Wrap (buffer.GetRemaining ());
+			return (int)retval;
+		}
+
+		public int DecryptMessage (ref MSI.IBufferOffsetSize incoming)
+		{
+			var buffer = new MSI.TlsBuffer (BOSWrapper.Wrap (incoming));
+			var retval = Context.DecryptMessage (ref buffer);
+			incoming = buffer != null ? BOSWrapper.Wrap (buffer.GetRemaining ()) : null;
+			return (int)retval;
+		}
+
+		class BOSWrapper : MSI.IBufferOffsetSize
+		{
+			public byte[] Buffer {
+				get;
+				private set;
+			}
+
+			public int Offset {
+				get;
+				private set;
+			}
+
+			public int Size {
+				get;
+				private set;
+			}
+
+			BOSWrapper (byte[] buffer, int offset, int size)
+			{
+				Buffer = buffer;
+				Offset = offset;
+				Size = size;
+			}
+
+			public static BOSWrapper Wrap (MSI.IBufferOffsetSize bos)
+			{
+				return bos != null ? new BOSWrapper (bos.Buffer, bos.Offset, bos.Size) : null;
+			}
+		}
+
+		public byte[] CreateCloseNotify ()
+		{
+			return Context.CreateAlert (new MSI.Alert (MSI.AlertLevel.Warning, MSI.AlertDescription.CloseNotify));
+		}
+
+		public byte[] CreateHelloRequest ()
+		{
+			return Context.CreateHelloRequest ();
+		}
+
+		public SSCX.X509Certificate GetRemoteCertificate (out PSSCX.X509CertificateCollection remoteCertificateStore)
+		{
+			MX.X509CertificateCollection monoCollection;
+			var remoteCert = Context.GetRemoteCertificate (out monoCollection);
+			if (remoteCert == null) {
+				remoteCertificateStore = null;
+				return null;
+			}
+
+			remoteCertificateStore = new PSSCX.X509CertificateCollection ();
+			foreach (var cert in monoCollection) {
+				remoteCertificateStore.Add (new PSSCX.X509Certificate2 (cert.RawData));
+			}
+			return new PSSCX.X509Certificate2 (remoteCert.RawData);
+
+		}
+
+		public bool VerifyRemoteCertificate ()
+		{
+			return Context.VerifyRemoteCertificate ();
+		}
+
+		public Exception LastError {
+			get {
+				if (context != null)
+					return context.LastError;
+				return null;
+			}
+		}
+
+		public bool ReceivedCloseNotify {
+			get {
+				return Context.ReceivedCloseNotify;
+			}
+		}
+
+		public MSI.MonoTlsConnectionInfo GetConnectionInfo ()
+		{
+			return Context.ConnectionInfo;
+		}
+
+		public void Dispose ()
+		{
+			Dispose (true);
+			GC.SuppressFinalize (this);
+		}
+
+		void Dispose (bool disposing)
+		{
+			Clear ();
+		}
+	}
+}
+

mcs/class/Mono.Security.Providers.NewTls/Mono.Security.Providers.NewTls/TlsProviderFactory.cs

@@ -0,0 +1,97 @@
+//
+// TlsProviderFactory.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015-2016 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+extern alias NewSystemSource;
+
+using System;
+using System.IO;
+
+using System.Net;
+using System.Net.Security;
+using System.Security.Authentication;
+
+using MSI = Mono.Security.Interface;
+using MX = Mono.Security.X509;
+
+using PSSCX = System.Security.Cryptography.X509Certificates;
+using SSCX = System.Security.Cryptography.X509Certificates;
+
+namespace Mono.Security.Providers.NewTls
+{
+	static class TlsProviderFactory
+	{
+		const string assemblyName = "Mono.Security.NewTls, Version=4.0.0.0, Culture=neutral, PublicKeyToken=84e3aee7225169c2";
+		const string tlsConfigTypeName = "Mono.Security.NewTls.TlsConfiguration";
+		const string tlsContextTypeName = "Mono.Security.NewTls.TlsContext";
+
+		static object CreateInstance (string typeName, object[] args)
+		{
+			var type = Type.GetType (typeName + ", " + assemblyName);
+			return Activator.CreateInstance (type, args);
+		}
+
+		internal static ITlsConfiguration CreateTlsConfiguration (
+			string hostname, bool serverMode, MSI.TlsProtocols protocolFlags,
+			SSCX.X509Certificate serverCertificate, bool remoteCertRequired,
+			MSI.MonoTlsSettings settings)
+		{
+			object[] args;
+			ITlsConfiguration config;
+			if (serverMode) {
+				var cert = (PSSCX.X509Certificate2)serverCertificate;
+				var monoCert = new MX.X509Certificate (cert.RawData);
+				args = new object[] {
+					(MSI.TlsProtocols)protocolFlags,
+					(MSI.MonoTlsSettings)settings,
+					monoCert,
+					cert.PrivateKey
+				};
+			} else {
+				args = new object[] {
+					(MSI.TlsProtocols)protocolFlags,
+					(MSI.MonoTlsSettings)settings,
+					hostname
+				};
+			}
+
+			config = (ITlsConfiguration)CreateInstance (tlsConfigTypeName, args);
+
+			if (serverMode && remoteCertRequired)
+				config.AskForClientCertificate = true;
+
+			return config;
+		}
+
+		internal static ITlsContext CreateTlsContext (
+			ITlsConfiguration config, bool serverMode,
+			MSI.IMonoTlsEventSink eventSink)
+		{
+			return (ITlsContext)CreateInstance (
+				tlsContextTypeName,
+				new object[] { config, serverMode, eventSink });
+		}
+	}
+}

mcs/class/Mono.Security.Providers.NewTls/Properties/AssemblyInfo.cs

@@ -0,0 +1,47 @@
+//
+// AssemblyInfo.cs
+//
+// Author:
+//       Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2015 Xamarin, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Reflection;
+using System.Resources;
+using System.Security;
+using System.Security.Permissions;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about the system assembly
+
+[assembly: AssemblyVersion (Consts.FxVersion)]
+
+[assembly: AssemblyCompany ("Xamarin")]
+[assembly: AssemblyCopyright ("(c) 2015 Xamarin")]
+[assembly: AssemblyDescription ("Mono.Security.Providers.NewTls.dll")]
+[assembly: AssemblyProduct ("MONO CLI")]
+[assembly: AssemblyTitle ("Mono.Security.Providers.NewTls.dll")]
+[assembly: CLSCompliant (false)]
+[assembly: ComVisible (false)]
+[assembly: NeutralResourcesLanguage ("en-US")]
+
+[assembly: InternalsVisibleTo ("Mono.Security.NewTls, PublicKey=002400000480000094000000060200000024000052534131000400001100000003336d6aed41624ca156ab579881fe90a576f1dfec48378fc94e4e440f4556776224e2d70c18996d91f36227f539fdb44340e07651f1455a489b29a7e6219a8f85e52b0f8588b4f8a857746a8468d37b556223d1452f3fcbaf0f269cdf1900ceb68f69485dc5887750d19571030c732331e00387d9b813a9ad52891087301793")]

mcs/class/Mono.Security.Providers.NewTls/mobile_Mono.Security.Providers.NewTls.dll.sources

@@ -0,0 +1,7 @@
+Properties/AssemblyInfo.cs
+
+Mono.Security.Providers.NewTls/ITlsConfiguration.cs
+Mono.Security.Providers.NewTls/ITlsContext.cs
+
+Mono.Security.Providers.NewTls/MonoNewTlsStream.cs
+Mono.Security.Providers.NewTls/MonoNewTlsStreamFactory.cs

mcs/class/Mono.Security.Providers.NewTls/mobile_static_Mono.Security.Providers.NewTls.dll.sources

@@ -0,0 +1 @@
+#include mobile_Mono.Security.Providers.NewTls.dll.sources