internal static IPortableEndPoint GetEndPoint(IPEndPoint endpoint)
{
var support = DependencyInjector.Get <IPortableEndPointSupport> ();
return(support.GetEndpoint(endpoint.Address.ToString(), endpoint.Port));
}
static bool SupportsRenegotiation()
{
var setup = DependencyInjector.Get <IMonoConnectionFrameworkSetup> ();
return(setup.SupportsRenegotiation);
}
async Task Instrumentation_CleanClientShutdown(TestContext ctx, CancellationToken cancellationToken)
{
var me = "Instrumentation_CleanClientShutdown";
LogDebug(ctx, 4, me);
int bytesWritten = 0;
clientInstrumentation.OnNextWrite(WriteHandler);
try {
cancellationToken.ThrowIfCancellationRequested();
await Client.Shutdown(ctx, cancellationToken).ConfigureAwait(false);
LogDebug(ctx, 4, "{0} - done", me);
} catch (OperationCanceledException) {
LogDebug(ctx, 4, "{0} - canceled");
clientTcs.TrySetCanceled();
throw;
} catch (Exception ex) {
LogDebug(ctx, 4, "{0} - error", me, ex);
clientTcs.TrySetException(ex);
throw;
}
var ok = ctx.Expect(bytesWritten, Is.GreaterThan(0), "{0} - bytes written", me);
ok &= ctx.Expect(Client.SslStream.CanWrite, Is.False, "{0} - SslStream.CanWrite", me);
clientTcs.TrySetResult(ok);
cancellationToken.ThrowIfCancellationRequested();
switch (EffectiveType)
{
case StreamInstrumentationType.CleanShutdown:
break;
case StreamInstrumentationType.DoubleShutdown:
await DoubleShutdown();
break;
case StreamInstrumentationType.WriteAfterShutdown:
await WriteAfterShutdown();
break;
case StreamInstrumentationType.ReadAfterShutdown:
await ReadAfterShutdown();
break;
case StreamInstrumentationType.WaitForShutdown:
break;
default:
throw ctx.AssertFail(EffectiveType);
}
Task DoubleShutdown()
{
// Don't use Client.Shutdown() as that might throw a different exception.
var setup = DependencyInjector.Get <IConnectionFrameworkSetup> ();
return(ctx.AssertException <InvalidOperationException> (
() => setup.ShutdownAsync(Client.SslStream), "double shutdown"));
}
Task WriteAfterShutdown()
{
return(ctx.AssertException <InvalidOperationException> (() => ConnectionHandler.WriteBlob(ctx, Client, cancellationToken)));
}
async Task ReadAfterShutdown()
{
LogDebug(ctx, 4, "{0} reading", me);
await ConnectionHandler.ExpectBlob(ctx, Client, cancellationToken).ConfigureAwait(false);
LogDebug(ctx, 4, "{0} reading done", me);
}
async Task WriteHandler(byte[] buffer, int offset, int size,
StreamInstrumentation.AsyncWriteFunc func,
CancellationToken innerCancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
innerCancellationToken.ThrowIfCancellationRequested();
LogDebug(ctx, 4, "{0} - write handler: {1} {2}", me, offset, size);
await func(buffer, offset, size, innerCancellationToken).ConfigureAwait(false);
LogDebug(ctx, 4, "{0} - write handler done", me);
bytesWritten += size;
}
}
static IPortableEndPoint GetEndPoint()
{
var support = DependencyInjector.Get <IPortableEndPointSupport> ();
return(support.GetEndpoint(8888));
}
public static SslStreamTestParameters GetParameters(TestContext ctx, ConnectionTestCategory category, ConnectionTestType type)
{
var certificateProvider = DependencyInjector.Get <ICertificateProvider> ();
var acceptAll = certificateProvider.AcceptAll();
var rejectAll = certificateProvider.RejectAll();
var acceptNull = certificateProvider.AcceptNull();
var acceptSelfSigned = certificateProvider.AcceptThisCertificate(ResourceManager.SelfSignedServerCertificate);
var acceptFromLocalCA = certificateProvider.AcceptFromCA(ResourceManager.LocalCACertificate);
var name = GetTestName(category, type);
switch (type)
{
case ConnectionTestType.Default:
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptAll
});
case ConnectionTestType.AcceptFromLocalCA:
return(new SslStreamTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
ClientCertificateValidator = acceptFromLocalCA
});
case ConnectionTestType.NoValidator:
// The default validator only allows ResourceManager.SelfSignedServerCertificate.
return(new SslStreamTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
ExpectClientException = true
});
case ConnectionTestType.RejectAll:
// Explicit validator overrides the default ServicePointManager.ServerCertificateValidationCallback.
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ExpectClientException = true, ClientCertificateValidator = rejectAll
});
case ConnectionTestType.UnrequestedClientCertificate:
// Provide a client certificate, but do not require it.
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.PenguinCertificate, ClientCertificateValidator = acceptSelfSigned,
ServerCertificateValidator = acceptNull
});
case ConnectionTestType.RequestClientCertificate:
/*
* Request client certificate, but do not require it.
*
* FIXME:
* SslStream with Mono's old implementation fails here.
*/
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned,
AskForClientCertificate = true, ServerCertificateValidator = acceptFromLocalCA
});
case ConnectionTestType.RequireClientCertificate:
// Require client certificate.
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned,
AskForClientCertificate = true, RequireClientCertificate = true,
ServerCertificateValidator = acceptFromLocalCA
});
case ConnectionTestType.OptionalClientCertificate:
/*
* Request client certificate without requiring one and do not provide it.
*
* To ask for an optional client certificate (without requiring it), you need to specify a custom validation
* callback and then accept the null certificate with `SslPolicyErrors.RemoteCertificateNotAvailable' in it.
*
* FIXME:
* Mono with the old TLS implementation throws SecureChannelFailure.
*/
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptSelfSigned, AskForClientCertificate = true,
ServerCertificateValidator = acceptNull
});
case ConnectionTestType.RejectClientCertificate:
// Reject client certificate.
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned,
ServerCertificateValidator = rejectAll, AskForClientCertificate = true,
ExpectClientException = true, ExpectServerException = true
});
case ConnectionTestType.MissingClientCertificate:
// Missing client certificate.
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptSelfSigned,
AskForClientCertificate = true, RequireClientCertificate = true,
ExpectClientException = true, ExpectServerException = true
});
case ConnectionTestType.MustNotInvokeGlobalValidator:
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptAll,
GlobalValidationFlags = GlobalValidationFlags.MustNotInvoke
});
case ConnectionTestType.MustNotInvokeGlobalValidator2:
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
GlobalValidationFlags = GlobalValidationFlags.MustNotInvoke,
ExpectClientException = true
});
case ConnectionTestType.SyncAuthenticate:
return(new SslStreamTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptAll, SslStreamFlags = SslStreamFlags.SyncAuthenticate
});
default:
throw ctx.AssertFail("Invalid ConnectionTestType: `{0}'.", type);
}
}
static SimpleConnectionParameters Create(TestContext ctx, InstrumentationCategory category, SimpleConnectionType type)
{
var parameters = CreateParameters(category, type);
var provider = DependencyInjector.Get <ICertificateProvider> ();
var acceptSelfSigned = provider.AcceptThisCertificate(ResourceManager.SelfSignedServerCertificate);
var acceptFromCA = provider.AcceptFromCA(ResourceManager.LocalCACertificate);
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;
parameters.ExpectedCipher = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_256_CBC_SHA;
break;
case SimpleConnectionType.SimpleTls12:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
parameters.ExpectedCipher = CipherSuiteCode.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384;
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, CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA
};
parameters.ExpectedServerCipher = CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA;
break;
case SimpleConnectionType.CipherSelectionOrder2:
parameters.ProtocolVersion = ProtocolVersions.Tls12;
parameters.ClientCiphers = new CipherSuiteCode[] {
CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA, CipherSuiteCode.TLS_RSA_WITH_AES_128_CBC_SHA
};
parameters.ExpectedServerCipher = CipherSuiteCode.TLS_DHE_RSA_WITH_AES_128_CBC_SHA;
break;
case SimpleConnectionType.MartinTest:
goto case SimpleConnectionType.SimpleTls12;
default:
ctx.AssertFail("Unsupported connection type: '{0}'.", type);
break;
}
return(parameters);
}
static ConnectionTestHelper()
{
Factory = DependencyInjector.Get <ConnectionProviderFactory> ();
}
public AppleCertificateHost(X509Certificate certificate)
{
CertificateAndKey = certificate;
provider = DependencyInjector.Get <IAppleCertificateProvider> ();
AppleCertificate = provider.GetAppleCertificate(CertificateAndKey);
}
static bool HasAppleTls()
{
var setup = DependencyInjector.Get <IMonoConnectionFrameworkSetup> ();
return(setup.UsingAppleTls);
}
bool SupportsCertificateTests()
{
var support = DependencyInjector.Get <IHttpProvider> ();
return(support.SupportsPerRequestCertificateValidator);
}
static bool UsingDotNetRuntime()
{
var provider = DependencyInjector.Get <IPortableSupport> ();
return(provider.IsMicrosoftRuntime);
}
static bool IsOpenSslSupported()
{
var provider = DependencyInjector.Get <ICryptoProvider> ();
return(provider.IsSupported(CryptoProviderType.OpenSsl, true));
}
static ResourceManager()
{
provider = DependencyInjector.Get <ICertificateProvider> ();
cacertData = ResourceManager.ReadResource("CA.Hamiller-Tube-CA.pem");
cacert = provider.GetCertificateFromData(cacertData);
hamillerTubeIMData = ResourceManager.ReadResource("CA.Hamiller-Tube-IM.pem");
hamillerTubeIM = provider.GetCertificateFromData(hamillerTubeIMData);
serverCertNoKeyData = ResourceManager.ReadResource("CA.server-cert.pem");
serverCertNoKey = provider.GetCertificateFromData(serverCertNoKeyData);
selfServerCertNoKeyData = ResourceManager.ReadResource("CA.server-self.pem");
selfServerCertNoKey = provider.GetCertificateFromData(selfServerCertNoKeyData);
selfServerCert = provider.GetCertificateWithKey(ReadResource("CA.server-self.pfx"), "monkey");
serverCert = provider.GetCertificateWithKey(ReadResource("CA.server-cert.pfx"), "monkey");
invalidServerCert = provider.GetCertificateWithKey(ReadResource("CA.invalid-server-cert.pfx"), "monkey");
invalidClientCert = provider.GetCertificateWithKey(ReadResource("CA.invalid-client-cert.pfx"), "monkey");
invalidClientCaCert = provider.GetCertificateWithKey(ReadResource("CA.invalid-client-ca-cert.pfx"), "monkey");
invalidClientCertRsa512 = provider.GetCertificateWithKey(ReadResource("CA.client-cert-rsa512.pfx"), "monkey");
monkeyCert = provider.GetCertificateWithKey(ReadResource("CA.monkey.pfx"), "monkey");
penguinCert = provider.GetCertificateWithKey(ReadResource("CA.penguin.pfx"), "penguin");
serverCertRsaOnly = provider.GetCertificateWithKey(ReadResource("CA.server-cert-rsaonly.pfx"), "monkey");
serverCertDheOnly = provider.GetCertificateWithKey(ReadResource("CA.server-cert-dhonly.pfx"), "monkey");
invalidServerCertRsa512 = provider.GetCertificateWithKey(ReadResource("CA.server-cert-rsa512.pfx"), "monkey");
clientCertRsaOnly = provider.GetCertificateWithKey(ReadResource("CA.client-cert-rsaonly.pfx"), "monkey");
clientCertDheOnly = provider.GetCertificateWithKey(ReadResource("CA.client-cert-dheonly.pfx"), "monkey");
tlsTestXamDevExpiredData = ResourceManager.ReadResource("CA.tlstest-xamdev-expired.pem");
tlsTestXamDevExpired = provider.GetCertificateFromData(tlsTestXamDevExpiredData);
tlsTestXamDevNewData = ResourceManager.ReadResource("CA.tlstest-xamdev-new.pem");
tlsTestXamDevNew = provider.GetCertificateFromData(tlsTestXamDevNewData);
tlsTestXamDevCAData = ResourceManager.ReadResource("CA.tlstest-xamdev-ca.pem");
tlsTestXamDevCA = provider.GetCertificateFromData(tlsTestXamDevCAData);
intermediateCAData = ResourceManager.ReadResource("CA.intermediate-ca.pem");
intermediateCA = provider.GetCertificateFromData(intermediateCAData);
intermediateServerData = ResourceManager.ReadResource("CA.intermediate-server.pem");
intermediateServer = provider.GetCertificateWithKey(ResourceManager.ReadResource("CA.intermediate-server.pfx"), "monkey");
hamillerTubeCAInfo = new HamillerTubeCAData(cacertData);
selfSignedServerInfo = new SelfSignedServerData(selfServerCertNoKeyData);
tlsTestXamDevNewInfo = new TlsTestXamDevNewData(tlsTestXamDevNewData);
tlsTestXamDevExpiredInfo = new TlsTestXamDevExpiredData(tlsTestXamDevExpiredData);
tlsTestXamDevCAInfo = new TlsTestXamDevCAData(tlsTestXamDevCAData);
intermediateCAInfo = new IntermediateCAData(intermediateCAData);
intermediateServerInfo = new IntermediateServerData(intermediateServerData);
serverCertWithCAData = ResourceManager.ReadResource("CA.server-cert-with-ca.pfx");
serverCertWithCA = provider.GetCertificateWithKey(serverCertWithCAData, "monkey");
intermediateServerCertData = ResourceManager.ReadResource("CA.server-cert-im.pfx");
intermediateServerCert = provider.GetCertificateWithKey(intermediateServerCertData, "monkey");
intermediateServerCertNoKeyData = ResourceManager.ReadResource("CA.server-cert-im.pem");
intermediateServerCertNoKey = provider.GetCertificateFromData(intermediateServerCertNoKeyData);
intermediateServerCertBareData = ResourceManager.ReadResource("CA.server-cert-im-bare.pfx");
intermediateServerCertBare = provider.GetCertificateWithKey(intermediateServerCertBareData, "monkey");
intermediateServerCertFullData = ResourceManager.ReadResource("CA.server-cert-im-full.pfx");
intermediateServerCertFull = provider.GetCertificateWithKey(intermediateServerCertFullData, "monkey");
trustedIMCAData = ResourceManager.ReadResource("CA.trusted-im-ca.pem");
trustedIMCA = provider.GetCertificateFromData(trustedIMCAData);
serverCertTrustedIMBareData = ResourceManager.ReadResource("CA.server-cert-trusted-im-bare.pfx");
serverCertTrustedIMBare = provider.GetCertificateWithKey(serverCertTrustedIMBareData, "monkey");
serverCertTrustedIMData = ResourceManager.ReadResource("CA.server-cert-trusted-im.pfx");
serverCertTrustedIM = provider.GetCertificateWithKey(serverCertTrustedIMData, "monkey");
}
public IEncryptionTestHost CreateInstance(TestContext context)
{
var provider = DependencyInjector.Get <ICryptoProvider> ();
return(provider.GetEncryptionTestHost(ProviderType, GetParameters()));
}
async Task <Response> GetResponseFromHttp(TestContext ctx, ChunkedRequest request, HttpWebResponse response, WebException error, CancellationToken cancellationToken)
{
var content = string.Empty;
var status = response.StatusCode;
ctx.Assert(status, Is.EqualTo(HttpStatusCode.OK), "success");
ctx.Assert(error, Is.Null, "null error");
var stream = response.GetResponseStream();
try {
if (Type == ChunkedOperationType.BeginEndAsyncRead || Type == ChunkedOperationType.BeginEndAsyncReadNoWait)
{
var provider = DependencyInjector.Get <IStreamProvider> ();
var buffer = new byte [1024];
var result = provider.BeginRead(stream, buffer, 0, buffer.Length, null, null);
if (Type != ChunkedOperationType.BeginEndAsyncReadNoWait)
{
await Task.Run(() => {
var timeout = ctx.Settings.DisableTimeouts ? -1 : 500;
var waitResult = result.AsyncWaitHandle.WaitOne(timeout);
ctx.Assert(waitResult, "WaitOne");
});
}
var ret = provider.EndRead(stream, result);
ctx.Assert(ret, Is.GreaterThan(0), "non-zero read");
content = Encoding.UTF8.GetString(buffer, 0, ret);
}
var reader = new StreamReader(stream);
if (Type == ChunkedOperationType.SyncRead || Type == ChunkedOperationType.SyncReadTimeout)
{
content += reader.ReadToEnd();
}
else
{
content += await reader.ReadToEndAsync();
}
if (Type == ChunkedOperationType.ServerAbort)
{
ctx.Assert(content.Length, Is.EqualTo(1), "read one byte");
}
if (ExpectException)
{
ctx.AssertFail("expected exception");
}
} catch (IOException ex) {
error = new WebException("failed to read response", ex, (XWebExceptionStatus)WebExceptionStatus.ResponseContentException, response);
content = null;
} catch (WebException ex) {
if (Type == ChunkedOperationType.SyncReadTimeout)
{
ctx.Assert((WebExceptionStatus)ex.Status, Is.EqualTo(WebExceptionStatus.Timeout), "expected Timeout");
error = new WebException(ex.Message, ex, (XWebExceptionStatus)WebExceptionStatus.Timeout, response);
}
else if (Type == ChunkedOperationType.TruncatedChunk)
{
ctx.Assert((WebExceptionStatus)ex.Status, Is.EqualTo(WebExceptionStatus.ConnectionClosed), "expected ConnectionClosed");
error = new WebException(ex.Message, ex, (XWebExceptionStatus)WebExceptionStatus.ResponseContentTruncated, response);
}
else
{
throw;
}
content = null;
} finally {
stream.Dispose();
response.Dispose();
}
return(new SimpleResponse(request, status, StringContent.CreateMaybeNull(content), error));
}
static bool IsMobile()
{
var support = DependencyInjector.Get <IPortableSupport> ();
return(support.IsMobile);
}
public RestAPIAddIdeaStateResponse UpdateIdeaStatus([FromUri] int IdeaID)
{
RestAPIAddIdeaStateResponse response = new RestAPIAddIdeaStateResponse();
submitIdeaUtil.InsertIdeaStatus(response, IdeaID, UserID);
logUtil.InsertIdeaLog(response, IdeaID, LogMessages.UpdateIdeaStatus, (int)IdeaLogTypes.Info, Enum.GetName(typeof(IdeaMethodTypes), IdeaMethodTypes.UpdateIdeaStatus), EnumDescriptor.GetEnumDescription(IdeaMethodTypes.UpdateIdeaStatus), UserID);
if (response.ErrorList.Count == 0)
{
ISubmitIdeaUtil ideautils = DependencyInjector.Get <ISubmitIdeaUtil, SubmitIdeaUtil>();
RESTAPIIdeaBasicDetailsInterchange ideaDetails = new RESTAPIIdeaBasicDetailsInterchange();
ideaDetails = ideautils.GetIdeaBasicDetails(IdeaID);
List <IdeaEmailToDetails> emailTo = submitIdeaUtil.GetAllStakeholdersEmailAdd(IdeaID);
EmailUtil emailObj = new EmailUtil();
// TODO: The below email logic is written here since there is no ISubmitIdeaUtil in InnovationPortalService, the database util is directly called, this needs to be changed in code refactoring.
// Determine the current state of Idea: if the highest status is 2, it is currently reviewed if 3 it is sponsored
if (emailTo[0].IdeaState == (int)IdeaStatusTypes.SponsorPending)
{
// This is an Idea Status update request for changing state from Submitted to Reviewed
foreach (var usr in emailTo)
{
if (usr.IdeaState == (int)IdeaStatusTypes.ReviewPending)
{
// Send Email to Submitter
EmailTemplate emailTemp = emailObj.GetEmailTemplate(EmailTemplateType.IdeaReviewedSubmitter.ToString());
emailObj.SendEmail(usr.EmailAddress, emailTemp.Body, emailTemp.Subject);
}
if (usr.IdeaState == (int)IdeaStatusTypes.SponsorPending)
{
// Send Email to Reviwer
EmailTemplate emailTemp = emailObj.GetEmailTemplate(EmailTemplateType.IdeaReviewedReviewer.ToString());
emailObj.SendEmail(usr.EmailAddress, emailTemp.Body, emailTemp.Subject);
}
if (usr.IdeaState == (int)IdeaStatusTypes.Default)
{
//The user in Assignment table should be Sponsor
EmailTemplate emailTemp = emailObj.GetEmailTemplate(EmailTemplateType.IdeaAssignedSponsor.ToString());
emailObj.SendEmail(usr.EmailAddress, emailTemp.Body, emailTemp.Subject);
}
}
}
else if (emailTo[0].IdeaState == (int)IdeaStatusTypes.Sponsored)
{
// This is an Idea Status update request for changing state from Reviewed to Sponsored
foreach (var usr in emailTo)
{
if (usr.IdeaState == (int)IdeaStatusTypes.ReviewPending)
{
// Send Email to Submitter
EmailTemplate emailTemp = emailObj.GetEmailTemplate(EmailTemplateType.IdeaSponsoredSubmitter.ToString());
emailObj.SendEmail(usr.EmailAddress, emailTemp.Body, emailTemp.Subject);
}
if (usr.IdeaState == (int)IdeaStatusTypes.SponsorPending)
{
// Send Email to Reviewer
EmailTemplate emailTemp = emailObj.GetEmailTemplate(EmailTemplateType.IdeaSponsoredReviewer.ToString());
emailObj.SendEmail(usr.EmailAddress, emailTemp.Body, emailTemp.Subject);
}
if (usr.IdeaState == (int)IdeaStatusTypes.Sponsored)
{
// Send Email to Sponsor
EmailTemplate emailTemp = emailObj.GetEmailTemplate(EmailTemplateType.IdeaSponsoredSponsor.ToString());
emailObj.SendEmail(usr.EmailAddress, emailTemp.Body, emailTemp.Subject);
}
//if (usr.IdeaState == 0)
//{
// //This user should be a Sales Guy. No action needs to be taken currently. This case is kept for future requirement.
//}
}
}
}
return(response);
}
public AppleCertificateHost(CertificateResourceType type)
{
CertificateAndKey = ResourceManager.GetCertificateWithKey(type);
provider = DependencyInjector.Get <IAppleCertificateProvider> ();
AppleCertificate = provider.GetAppleCertificate(CertificateAndKey);
}
public static async Task <TestServer> LaunchApplication(TestApp app, IPortableEndPoint address, ApplicationLauncher launcher, LauncherOptions options, CancellationToken cancellationToken)
{
var support = DependencyInjector.Get <IServerHost> ();
var connection = await support.Listen(address, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
var sb = new StringBuilder();
if (options != null)
{
if (options.Category != null)
{
sb.AppendFormat("--category={0} ", options.Category);
}
if (options.Features != null)
{
sb.AppendFormat("--features={0} ", options.Features);
}
}
if (!string.IsNullOrWhiteSpace(app.PackageName))
{
sb.AppendFormat("--package-name={0} ", app.PackageName);
}
sb.AppendFormat("connect {0}:{1}", address.Address, address.Port);
var process = await launcher.LaunchApplication(sb.ToString(), cancellationToken);
var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
cts.CancelAfter(60000);
bool launcherError = false;
var launcherTask = process.WaitForExit(cts.Token).ContinueWith(t => {
if (t.IsFaulted || t.IsCanceled)
{
launcherError = true;
cts.Cancel();
}
});
Stream stream;
try {
stream = await connection.Open(cts.Token);
cts.Token.ThrowIfCancellationRequested();
} catch {
if (launcherError || launcherTask.IsCanceled || cts.IsCancellationRequested)
{
throw new LauncherErrorException("Launcher exited abnormally before establishing connection.");
}
throw;
}
var launcherConnection = new LauncherConnection(app, stream, connection, process);
var client = new Client(app, launcherConnection);
await client.Initialize(cancellationToken);
cts.Token.ThrowIfCancellationRequested();
return(client);
}
public IHashTestHost CreateInstance(TestContext context)
{
var provider = DependencyInjector.Get <ICryptoProvider> ();
return(provider.GetHashTestHost(ProviderType));
}
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 Stream CreateClientStream(TestContext ctx, Connection connection, Socket socket)
{
if ((EffectiveFlags & InstrumentationFlags.NeedClientInstrumentation) == 0)
{
throw ctx.AssertFail("CreateClientStream()");
}
var name = string.Format("Client:{0}", EffectiveType);
var ownsSocket = !HasFlag(InstrumentationFlags.ReuseClientSocket);
var instrumentation = new StreamInstrumentation(ctx, name, socket, ownsSocket);
var setup = DependencyInjector.Get <IConnectionFrameworkSetup> ();
switch (EffectiveType)
{
case StreamInstrumentationType.VerifyAsyncStreamCalls:
instrumentation.RequireAsync = true;
if (setup.UsingDotNet)
{
instrumentation.AllowBeginEndAsync = true;
instrumentation.AllowSyncFlush = true;
}
break;
}
if (Interlocked.CompareExchange(ref clientInstrumentation, instrumentation, null) != null)
{
throw new InternalErrorException();
}
LogDebug(ctx, 4, "CreateClientStream()");
if (!HasFlag(InstrumentationFlags.ClientStream))
{
return(instrumentation);
}
instrumentation.OnNextRead(ReadHandler);
return(instrumentation);
async Task <int> ReadHandler(byte[] buffer, int offset, int size,
StreamInstrumentation.AsyncReadFunc func,
CancellationToken cancellationToken)
{
ctx.Assert(Client.Stream, Is.Not.Null);
ctx.Assert(Client.SslStream, Is.Not.Null);
ctx.Assert(Client.SslStream.IsAuthenticated, Is.False);
switch (EffectiveType)
{
case StreamInstrumentationType.ClientHandshake:
LogDebug(ctx, 4, "CreateClientStream(): client handshake");
break;
case StreamInstrumentationType.ReadDuringClientAuth:
await ctx.AssertException <InvalidOperationException> (ReadClient).ConfigureAwait(false);
break;
case StreamInstrumentationType.ShortReadDuringClientAuth:
if (size <= 5)
{
instrumentation.OnNextRead(ReadHandler);
}
size = 1;
break;
case StreamInstrumentationType.VerifyAsyncStreamCalls:
break;
default:
throw ctx.AssertFail(EffectiveType);
}
return(await func(buffer, offset, size, cancellationToken));
}
Task <int> ReadClient()
{
const int bufferSize = 100;
return(Client.Stream.ReadAsync(new byte[bufferSize], 0, bufferSize));
}
}
static bool HasNewWebStack()
{
var setup = DependencyInjector.Get <IConnectionFrameworkSetup> ();
return(setup.HasNewWebStack);
}
public static IEnumerable <StreamInstrumentationType> GetStreamInstrumentationTypes(TestContext ctx, ConnectionTestCategory category)
{
var setup = DependencyInjector.Get <IConnectionFrameworkSetup> ();
switch (category)
{
case ConnectionTestCategory.SslStreamInstrumentation:
yield return(StreamInstrumentationType.ClientHandshake);
yield return(StreamInstrumentationType.ReadDuringClientAuth);
yield return(StreamInstrumentationType.CloseBeforeClientAuth);
yield return(StreamInstrumentationType.CloseDuringClientAuth);
yield return(StreamInstrumentationType.DisposeDuringClientAuth);
yield return(StreamInstrumentationType.InvalidDataDuringClientAuth);
yield return(StreamInstrumentationType.ShortReadDuringClientAuth);
yield return(StreamInstrumentationType.ShortReadAndClose);
yield return(StreamInstrumentationType.RemoteClosesConnectionDuringRead);
if (setup.UsingDotNet || setup.InternalVersion >= 1)
{
yield return(StreamInstrumentationType.Flush);
yield return(StreamInstrumentationType.WriteDoesNotFlush);
yield return(StreamInstrumentationType.FlushAfterDispose);
yield return(StreamInstrumentationType.PropertiesAfterDispose);
}
yield break;
case ConnectionTestCategory.SslStreamInstrumentationRecentlyFixed:
yield break;
case ConnectionTestCategory.SslStreamInstrumentationShutdown:
yield return(StreamInstrumentationType.CleanShutdown);
yield return(StreamInstrumentationType.DoubleShutdown);
yield return(StreamInstrumentationType.WriteAfterShutdown);
yield return(StreamInstrumentationType.WaitForShutdown);
yield return(StreamInstrumentationType.ReadAfterShutdown);
yield return(StreamInstrumentationType.ConnectionReuse);
yield return(StreamInstrumentationType.ConnectionReuseWithShutdown);
yield break;
case ConnectionTestCategory.SslStreamInstrumentationServerShutdown:
yield return(StreamInstrumentationType.ServerRequestsShutdown);
yield break;
case ConnectionTestCategory.SslStreamInstrumentationExperimental:
yield break;
case ConnectionTestCategory.SslStreamInstrumentationNewWebStack:
yield return(StreamInstrumentationType.VerifyAsyncStreamCalls);
yield break;
case ConnectionTestCategory.SslStreamInstrumentationMono:
yield break;
case ConnectionTestCategory.MartinTest:
yield return(StreamInstrumentationType.MartinTest);
yield break;
default:
throw ctx.AssertFail(category);
}
}
static bool SupportsCleanShutdown()
{
var setup = DependencyInjector.Get <IConnectionFrameworkSetup> ();
return(setup.SupportsCleanShutdown);
}
public MobileTestOptions(string options)
{
Settings = SettingsBag.CreateDefault();
Settings.LocalLogLevel = -1;
if (string.IsNullOrEmpty(options))
{
Settings.LogLevel = 0;
Settings.LocalLogLevel = 0;
Settings.DisableTimeouts = false;
SessionMode = MobileSessionMode.Local;
return;
}
int? logLevel = null;
bool debugMode = false;
string category = null;
string features = null;
string packageName = null;
string customSettings = null;
var p = new NDesk.Options.OptionSet();
p.Add("debug", v => debugMode = true);
p.Add("log-level=", v => logLevel = int.Parse(v));
p.Add("category=", v => category = v);
p.Add("features=", v => features = v);
p.Add("package-name=", v => packageName = v);
p.Add("set=", v => customSettings = v);
var optArray = options.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var args = p.Parse(optArray);
Category = category;
Features = features;
PackageName = packageName;
if (debugMode)
{
Settings.LogLevel = -1;
Settings.LocalLogLevel = -1;
Settings.DisableTimeouts = true;
}
else
{
Settings.DisableTimeouts = false;
}
if (logLevel != null)
{
Settings.LogLevel = logLevel.Value;
}
if (customSettings != null)
{
ParseSettings(customSettings);
}
if (args.Count == 0)
{
SessionMode = MobileSessionMode.Local;
return;
}
if (args [0] == "server")
{
SessionMode = MobileSessionMode.Server;
if (args.Count == 2)
{
EndPoint = DependencyInjector.Get <IPortableEndPointSupport> ().ParseEndpoint(args [1]);
}
else if (args.Count == 1)
{
EndPoint = GetEndPoint();
}
else
{
throw new InvalidOperationException("Invalid 'XAMARIN_ASYNCTESTS_OPTIONS' argument.");
}
}
else if (args [0] == "connect")
{
SessionMode = MobileSessionMode.Connect;
if (args.Count != 2)
{
throw new InvalidOperationException("Invalid 'XAMARIN_ASYNCTESTS_OPTIONS' argument.");
}
EndPoint = DependencyInjector.Get <IPortableEndPointSupport> ().ParseEndpoint(args [1]);
}
else if (args [0] == "local")
{
SessionMode = MobileSessionMode.Local;
if (args.Count != 1)
{
throw new InvalidOperationException("Invalid 'XAMARIN_ASYNCTESTS_OPTIONS' argument.");
}
return;
}
else
{
throw new InvalidOperationException("Invalid 'XAMARIN_ASYNCTESTS_OPTIONS' argument.");
}
}
public static HttpsTestParameters GetParameters(TestContext ctx, ConnectionTestCategory category, ConnectionTestType type)
{
var certificateProvider = DependencyInjector.Get <ICertificateProvider> ();
var acceptAll = certificateProvider.AcceptAll();
var rejectAll = certificateProvider.RejectAll();
var acceptNull = certificateProvider.AcceptNull();
var acceptSelfSigned = certificateProvider.AcceptThisCertificate(ResourceManager.SelfSignedServerCertificate);
var acceptFromLocalCA = certificateProvider.AcceptFromCA(ResourceManager.LocalCACertificate);
var name = GetTestName(category, type);
switch (type)
{
case ConnectionTestType.Default:
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptAll
});
case ConnectionTestType.AcceptFromLocalCA:
return(new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
ClientCertificateValidator = acceptFromLocalCA
});
case ConnectionTestType.NoValidator:
// The default validator only allows ResourceManager.SelfSignedServerCertificate.
return(new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
ExpectTrustFailure = true, ClientAbortsHandshake = true
});
case ConnectionTestType.RejectAll:
// Explicit validator overrides the default ServicePointManager.ServerCertificateValidationCallback.
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ExpectTrustFailure = true, ClientCertificateValidator = rejectAll,
ClientAbortsHandshake = true
});
case ConnectionTestType.UnrequestedClientCertificate:
// Provide a client certificate, but do not require it.
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.PenguinCertificate, ClientCertificateValidator = acceptSelfSigned,
ServerCertificateValidator = acceptNull
});
case ConnectionTestType.RequestClientCertificate:
/*
* Request client certificate, but do not require it.
*
* FIXME:
* SslStream with Mono's old implementation fails here.
*/
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned,
AskForClientCertificate = true, ServerCertificateValidator = acceptFromLocalCA
});
case ConnectionTestType.RequireClientCertificate:
// Require client certificate.
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned,
AskForClientCertificate = true, RequireClientCertificate = true,
ServerCertificateValidator = acceptFromLocalCA
});
case ConnectionTestType.OptionalClientCertificate:
/*
* Request client certificate without requiring one and do not provide it.
*
* To ask for an optional client certificate (without requiring it), you need to specify a custom validation
* callback and then accept the null certificate with `SslPolicyErrors.RemoteCertificateNotAvailable' in it.
*
* FIXME:
* Mono with the old TLS implementation throws SecureChannelFailure.
*/
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptSelfSigned, AskForClientCertificate = true,
ServerCertificateValidator = acceptNull
});
case ConnectionTestType.RejectClientCertificate:
// Reject client certificate.
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificate = ResourceManager.MonkeyCertificate, ClientCertificateValidator = acceptSelfSigned,
ExpectWebException = true, ServerCertificateValidator = rejectAll,
AskForClientCertificate = true, ClientAbortsHandshake = true
});
case ConnectionTestType.MissingClientCertificate:
// Missing client certificate.
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
ClientCertificateValidator = acceptSelfSigned, ExpectWebException = true,
AskForClientCertificate = true, RequireClientCertificate = true,
ClientAbortsHandshake = true
});
case ConnectionTestType.DontInvokeGlobalValidator:
return(new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
ClientCertificateValidator = acceptAll,
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner | GlobalValidationFlags.MustNotInvoke
});
case ConnectionTestType.DontInvokeGlobalValidator2:
return(new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
ClientCertificateValidator = rejectAll,
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner | GlobalValidationFlags.MustNotInvoke,
ExpectTrustFailure = true, ClientAbortsHandshake = true
});
case ConnectionTestType.GlobalValidatorIsNull:
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
GlobalValidationFlags = GlobalValidationFlags.SetToNull,
ExpectTrustFailure = true, ClientAbortsHandshake = true
});
case ConnectionTestType.MustInvokeGlobalValidator:
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner |
GlobalValidationFlags.MustInvoke | GlobalValidationFlags.AlwaysSucceed
});
case ConnectionTestType.CheckChain:
return(new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
GlobalValidationFlags = GlobalValidationFlags.CheckChain,
ExpectPolicyErrors = SslPolicyErrors.RemoteCertificateChainErrors | SslPolicyErrors.RemoteCertificateNameMismatch,
ExpectChainStatus = X509ChainStatusFlags.UntrustedRoot
});
case ConnectionTestType.ExternalServer:
return(new HttpsTestParameters(category, type, name, CertificateResourceType.TlsTestXamDevNew)
{
ExternalServer = new Uri("https://tlstest-1.xamdev.com/"),
GlobalValidationFlags = GlobalValidationFlags.CheckChain,
ExpectPolicyErrors = SslPolicyErrors.None
});
case ConnectionTestType.ServerCertificateWithCA:
var parameters = new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateWithCA)
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectChainStatus = X509ChainStatusFlags.UntrustedRoot
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.ServerCertificateFromLocalCA);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.ExpectSuccess = false;
return(parameters);
case ConnectionTestType.TrustedRootCA:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
GlobalValidationFlags = GlobalValidationFlags.CheckChain,
ExpectPolicyErrors = SslPolicyErrors.None, OverrideTargetHost = "Hamiller-Tube.local"
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.ExpectSuccess = true;
return(parameters);
case ConnectionTestType.TrustedIntermediateCA:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.GetCertificate(CertificateResourceType.IntermediateServerCertificateBare))
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectChainStatus = X509ChainStatusFlags.NoError,
ExpectPolicyErrors = SslPolicyErrors.None, OverrideTargetHost = "Intermediate-Server.local"
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.HamillerTubeIM);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.IntermediateServerCertificateNoKey);
parameters.ValidationParameters.ExpectSuccess = true;
return(parameters);
case ConnectionTestType.TrustedSelfSigned:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.SelfSignedServerCertificate)
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectChainStatus = X509ChainStatusFlags.NoError,
ExpectPolicyErrors = SslPolicyErrors.None, OverrideTargetHost = "Hamiller-Tube.local"
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.SelfSignedServerCertificate);
parameters.ValidationParameters.ExpectSuccess = true;
return(parameters);
case ConnectionTestType.HostNameMismatch:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.ServerCertificateFromCA)
{
GlobalValidationFlags = GlobalValidationFlags.CheckChain,
ExpectPolicyErrors = SslPolicyErrors.RemoteCertificateNameMismatch,
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.ExpectSuccess = false;
return(parameters);
case ConnectionTestType.IntermediateServerCertificate:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.GetCertificate(CertificateResourceType.IntermediateServerCertificate))
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectChainStatus = X509ChainStatusFlags.NoError,
ExpectPolicyErrors = SslPolicyErrors.None, OverrideTargetHost = "Intermediate-Server.local"
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.IntermediateServerCertificateNoKey);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.HamillerTubeIM);
parameters.ValidationParameters.ExpectSuccess = true;
return(parameters);
case ConnectionTestType.IntermediateServerCertificateFull:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.GetCertificate(CertificateResourceType.IntermediateServerCertificateFull))
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectChainStatus = X509ChainStatusFlags.NoError,
ExpectPolicyErrors = SslPolicyErrors.None, OverrideTargetHost = "Intermediate-Server.local"
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.IntermediateServerCertificateNoKey);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.HamillerTubeIM);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.ExpectSuccess = true;
return(parameters);
case ConnectionTestType.IntermediateServerCertificateBare:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.GetCertificate(CertificateResourceType.IntermediateServerCertificateBare))
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectPolicyErrors = SslPolicyErrors.RemoteCertificateChainErrors, OverrideTargetHost = "Intermediate-Server.local"
};
parameters.ValidationParameters = new ValidationParameters();
parameters.ValidationParameters.AddTrustedRoot(CertificateResourceType.HamillerTubeCA);
parameters.ValidationParameters.AddExpectedExtraStore(CertificateResourceType.IntermediateServerCertificateNoKey);
parameters.ValidationParameters.ExpectSuccess = false;
return(parameters);
case ConnectionTestType.CertificateStore:
parameters = new HttpsTestParameters(category, type, name, ResourceManager.GetCertificate(CertificateResourceType.ServerFromTrustedIntermediateCABare))
{
GlobalValidationFlags = GlobalValidationFlags.SetToTestRunner,
ExpectChainStatus = X509ChainStatusFlags.NoError,
ExpectPolicyErrors = SslPolicyErrors.None, OverrideTargetHost = "Trusted-IM-Server.local"
};
return(parameters);
case ConnectionTestType.MartinTest:
goto case ConnectionTestType.ServerCertificateWithCA;
default:
throw new InternalErrorException();
}
}
static bool HasTls12()
{
var setup = DependencyInjector.Get <IConnectionFrameworkSetup> ();
return(setup.SupportsTls12);
}
// DocLiteral hppService;
public AuthenticationUtils()
{
commonHelper = DependencyInjector.Get <ICommonHelper, CommonHelper>();
//hppService = DependencyInjector.Get<DocLiteral, HPPClient>();
//commonHelper.SetHPPAuthenticationHeaders(hppService);
}