static SimpleConnectionParameters CreateParameters(MonoConnectionTestCategory category, SimpleConnectionType type, params object[] args)
{
var sb = new StringBuilder();
sb.Append(type);
foreach (var arg in args)
{
sb.AppendFormat(":{0}", arg);
}
var name = sb.ToString();
return(new SimpleConnectionParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = AcceptAnyCertificate
});
}
public static ConnectionTestFlags GetConnectionFlags(TestContext ctx, MonoConnectionTestCategory category)
{
switch (category)
{
case MonoConnectionTestCategory.SimpleMonoClient:
case MonoConnectionTestCategory.SelectClientCipher:
return(ConnectionTestFlags.RequireMonoClient);
case MonoConnectionTestCategory.SimpleMonoServer:
case MonoConnectionTestCategory.SelectServerCipher:
return(ConnectionTestFlags.RequireMonoServer);
case MonoConnectionTestCategory.SimpleMonoConnection:
case MonoConnectionTestCategory.MonoProtocolVersions:
case MonoConnectionTestCategory.SelectCipher:
return(ConnectionTestFlags.RequireMono);
case MonoConnectionTestCategory.ClientConnection:
case MonoConnectionTestCategory.MartinTestClient:
return(ConnectionTestFlags.RequireMonoClient);
case MonoConnectionTestCategory.ServerConnection:
case MonoConnectionTestCategory.MartinTestServer:
return(ConnectionTestFlags.RequireMonoServer);
case MonoConnectionTestCategory.Connection:
case MonoConnectionTestCategory.CertificateChecks:
case MonoConnectionTestCategory.SecurityFramework:
return(ConnectionTestFlags.RequireMono);
case MonoConnectionTestCategory.MartinTest:
// return ConnectionTestFlags.RequireMono | ConnectionTestFlags.RequireTls12;
return(ConnectionTestFlags.None);
default:
ctx.AssertFail("Unsupported instrumentation category: '{0}'.", category);
return(ConnectionTestFlags.None);
}
}
public MonoConnectionProviderFilter(MonoConnectionTestCategory category, MonoConnectionTestFlags flags)
{
Category = category;
Flags = flags;
}
public MonoConnectionTestCategoryAttribute(MonoConnectionTestCategory category)
{
this.category = category;
this.identifier = Type.Name;
}
public static IEnumerable <SimpleConnectionType> GetTestTypes(TestContext ctx, MonoConnectionTestCategory category)
{
switch (category)
{
case MonoConnectionTestCategory.SimpleMonoClient:
yield return(SimpleConnectionType.SimpleTls10);
yield return(SimpleConnectionType.SimpleTls11);
yield return(SimpleConnectionType.SimpleTls12);
yield break;
case MonoConnectionTestCategory.SimpleMonoServer:
yield return(SimpleConnectionType.SimpleTls10);
yield return(SimpleConnectionType.SimpleTls11);
yield return(SimpleConnectionType.SimpleTls12);
yield break;
case MonoConnectionTestCategory.SimpleMonoConnection:
yield return(SimpleConnectionType.SimpleTls10);
yield return(SimpleConnectionType.SimpleTls11);
yield return(SimpleConnectionType.SimpleTls12);
yield return(SimpleConnectionType.DefaultCipherTls10);
yield return(SimpleConnectionType.DefaultCipherTls11);
yield return(SimpleConnectionType.DefaultCipherTls12);
yield return(SimpleConnectionType.CipherSelectionOrder);
yield return(SimpleConnectionType.CipherSelectionOrder2);
yield break;
case MonoConnectionTestCategory.MonoProtocolVersions:
yield return(SimpleConnectionType.Simple);
yield return(SimpleConnectionType.ValidateCertificate);
yield return(SimpleConnectionType.RequestClientCertificate);
yield return(SimpleConnectionType.RequireClientCertificateRSA);
yield return(SimpleConnectionType.RequireClientCertificateDHE);
yield break;
case MonoConnectionTestCategory.SecurityFramework:
yield return(SimpleConnectionType.Simple);
yield break;
case MonoConnectionTestCategory.MartinTest:
yield return(SimpleConnectionType.MartinTest);
// goto case MonoConnectionTestCategory.SimpleMonoConnection;
yield break;
default:
ctx.AssertFail("Unspported connection category: '{0}.", category);
yield break;
}
}
static SimpleConnectionParameters Create(TestContext ctx, ClientAndServerProvider provider, MonoConnectionTestCategory category, SimpleConnectionType type)
{
var parameters = CreateParameters(category, type);
var certificateProvider = DependencyInjector.Get <ICertificateProvider> ();
var acceptSelfSigned = certificateProvider.AcceptThisCertificate(ResourceManager.SelfSignedServerCertificate);
var acceptFromCA = certificateProvider.AcceptFromCA(ResourceManager.LocalCACertificate);
bool clientSupportsEcDhe;
bool serverSupportsEcDhe;
CipherSuiteCode defaultCipher;
CipherSuiteCode defaultCipher12;
CipherSuiteCode alternateCipher12;
if (provider != null)
{
clientSupportsEcDhe = (provider.Client.Flags & ConnectionProviderFlags.SupportsEcDheCiphers) != 0;
serverSupportsEcDhe = (provider.Server.Flags & ConnectionProviderFlags.SupportsEcDheCiphers) != 0;
}
else
{
clientSupportsEcDhe = serverSupportsEcDhe = false;
}
if (clientSupportsEcDhe && serverSupportsEcDhe)
{
defaultCipher = CipherSuiteCode.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
defaultCipher12 = CipherSuiteCode.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384;
alternateCipher12 = CipherSuiteCode.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA;
}
else
{
defaultCipher = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_256_CBC_SHA;
defaultCipher12 = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384;
alternateCipher12 = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA;
}
switch (type)
{
case SimpleConnectionType.Simple:
break;
case SimpleConnectionType.ValidateCertificate:
parameters.ServerCertificate = ResourceManager.ServerCertificateFromCA;
parameters.ClientCertificateValidator = acceptFromCA;
break;
case SimpleConnectionType.SimpleTls10:
parameters.ProtocolVersion = ProtocolVersions.Tls10;
break;
case SimpleConnectionType.SimpleTls11:
parameters.ProtocolVersion = ProtocolVersions.Tls11;
break;
case SimpleConnectionType.SimpleTls12:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
break;
case SimpleConnectionType.DefaultCipherTls10:
parameters.ProtocolVersion = ProtocolVersions.Tls10;
parameters.ExpectedCipher = defaultCipher;
break;
case SimpleConnectionType.DefaultCipherTls11:
parameters.ProtocolVersion = ProtocolVersions.Tls11;
parameters.ExpectedCipher = defaultCipher;
break;
case SimpleConnectionType.DefaultCipherTls12:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
parameters.ExpectedCipher = defaultCipher12;
break;
case SimpleConnectionType.SelectCiphersTls10:
parameters.ProtocolVersion = ProtocolVersions.Tls10;
break;
case SimpleConnectionType.SelectCiphersTls11:
parameters.ProtocolVersion = ProtocolVersions.Tls11;
break;
case SimpleConnectionType.SelectCiphersTls12:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
break;
case SimpleConnectionType.RequestClientCertificate:
/*
* Request client certificate, but do not require it.
*
* FIXME:
* SslStream with Mono's old implementation fails here.
*/
parameters.ClientCertificate = ResourceManager.MonkeyCertificate;
parameters.ClientCertificateValidator = acceptSelfSigned;
parameters.AskForClientCertificate = true;
parameters.ServerCertificateValidator = acceptFromCA;
break;
case SimpleConnectionType.RequireClientCertificateRSA:
/*
* Require client certificate.
*
*/
parameters.ClientCertificate = ResourceManager.MonkeyCertificate;
parameters.ClientCertificateValidator = acceptSelfSigned;
parameters.RequireClientCertificate = true;
parameters.ServerCertificateValidator = acceptFromCA;
parameters.ServerCiphers = new CipherSuiteCode[] {
CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA
};
break;
case SimpleConnectionType.RequireClientCertificateDHE:
/*
* Require client certificate.
*
*/
parameters.ClientCertificate = ResourceManager.MonkeyCertificate;
parameters.ClientCertificateValidator = acceptSelfSigned;
parameters.RequireClientCertificate = true;
parameters.ServerCertificateValidator = acceptFromCA;
parameters.ServerCiphers = new CipherSuiteCode[] {
CipherSuiteCode.TLS_DHE_RSA_WITH_AES_256_CBC_SHA
};
break;
case SimpleConnectionType.CipherSelectionOrder:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
parameters.ClientCiphers = new CipherSuiteCode[] {
CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA,
alternateCipher12
};
parameters.ExpectedServerCipher = CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA;
break;
case SimpleConnectionType.CipherSelectionOrder2:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
parameters.ClientCiphers = new CipherSuiteCode[] {
alternateCipher12,
CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA
};
parameters.ExpectedServerCipher = alternateCipher12;
break;
case SimpleConnectionType.MartinTest:
parameters.ServerCertificate = ResourceManager.GetCertificateWithKey(CertificateResourceType.SelfSignedServerCertificate);
break;
default:
ctx.AssertFail("Unsupported connection type: '{0}'.", type);
break;
}
return(parameters);
}
public static IEnumerable <SimpleConnectionParameters> GetParameters(TestContext ctx, ClientAndServerProvider provider, MonoConnectionTestCategory category)
{
return(GetTestTypes(ctx, category).Select(t => Create(ctx, provider, category, t)));
}
public SimpleConnectionParameters(MonoConnectionTestCategory category, SimpleConnectionType type, string identifier, X509Certificate certificate)
: base(category, identifier, certificate)
{
Type = type;
}
public MonoConnectionProviderFilter(MonoConnectionTestCategory category, ConnectionTestFlags flags)
: base(flags)
{
Category = category;
}
public MonoConnectionTestProvider(ConnectionProvider client, ConnectionProvider server, MonoConnectionTestCategory category, MonoConnectionTestFlags flags)
: base(client, server, string.Format("{0}:{1}:{2}{3}", client.Name, server.Name, category, GetFlagsName(flags)))
{
Category = category;
Flags = flags;
}
public MonoConnectionTestParameters(MonoConnectionTestCategory category, string identifier, X509Certificate certificate)
: base(identifier, certificate)
{
Category = category;
}
