public async Task ParseResponse_failed_2_nested_status_code_Test()
{
//ARRANGE
var inResponseTo = Guid.NewGuid().ToString();
var response = ResponseFactoryMock.GetTokenResponse(inResponseTo, StatusCodes.Responder);
ResponseFactoryMock.GetStatusCode(StatusCodes.NoAuthnContext, response.Status.StatusCode);
ResponseFactoryMock.GetStatusCode(StatusCodes.InvalidNameIdPolicy, response.Status.StatusCode.SubStatusCode);
response.Status.StatusMessage = "Test message";
var logger = new LogProviderMock();
var serialised = ResponseFactoryMock.Serialize(response);
var parser = new SamlTokenResponseParser(logger);
//ACT
var tokenResponse = await parser.Parse(serialised);
//ASSERT
Assert.AreEqual(StatusCodes.Responder, tokenResponse.Status.StatusCode.Value);
Assert.IsNotNull(tokenResponse.Status.StatusCode.SubStatusCode);
Assert.AreEqual(StatusCodes.NoAuthnContext, tokenResponse.Status.StatusCode.SubStatusCode.Value);
Assert.IsNotNull(tokenResponse.Status.StatusCode.SubStatusCode.SubStatusCode);
Assert.AreEqual(StatusCodes.InvalidNameIdPolicy, tokenResponse.Status.StatusCode.SubStatusCode.SubStatusCode.Value);
Assert.IsNull(tokenResponse.Status.StatusCode.SubStatusCode.SubStatusCode.SubStatusCode);
Assert.AreEqual("Test message", tokenResponse.Status.StatusMessage);
Assert.IsNull(tokenResponse.Status.StatusDetail);
}
public async Task SPMetadataGenerationTest()
{
////ARRANGE
var result = String.Empty;
var metadataWriter = new TestMetadatWriter(el => result = el.OuterXml);
var logger = new LogProviderMock();
var contextBuilder = new InlineMetadataContextBuilder();
var metadataRequest = new MetadataGenerateRequest(MetadataType.SP, "local");
var metadataContext = contextBuilder.BuildContext(metadataRequest);
var context = new FederationPartyConfiguration(metadataRequest.FederationPartyId, "localhost");
context.MetadataContext = metadataContext;
var configurationProvider = new CertificateValidationConfigurationProvider();
var certificateValidator = new CertificateValidator(configurationProvider, logger);
var ssoCryptoProvider = new CertificateManager(logger);
var metadataSerialiser = new FederationMetadataSerialiser(certificateValidator, logger);
var metadataDispatcher = new FederationMetadataDispatcherMock(() => new[] { metadataWriter });
var sPSSOMetadataProvider = new SPSSOMetadataProvider(metadataDispatcher, ssoCryptoProvider, metadataSerialiser, g => context, logger);
//ACT
await sPSSOMetadataProvider.CreateMetadata(metadataRequest);
//ASSERT
Assert.IsFalse(String.IsNullOrWhiteSpace(result));
}
public async Task ListnerTest_2_listeners()
{
//ARRANGE
var logger = new LogProviderMock();
Func <ITransportConfiguration> configuration = () => new TransportConfiguration();
var transport = new InMemoryQueueTransport(logger, configuration);
var manager = new TransportManager(transport, logger);
var message = new byte[] { 0, 1, 2 };
byte[] messageReceived1 = null;
byte[] messageReceived2 = null;
var listener1 = new MessageListener1(m => messageReceived1 = m);
var listener2 = new MessageListener2(m => messageReceived2 = m);
//ACT
await listener1.AttachTo(manager);
await listener2.AttachTo(manager);
await transport.Start();
await manager.EnqueueMessage(message);
Thread.Sleep(500);
//ASSERT
Assert.AreEqual(message, messageReceived1);
Assert.AreEqual(message, messageReceived2);
}
public void AuthnRequestSerialiser_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var supportedNameIdentifierFormats = new List <Uri> {
new Uri(NameIdentifierFormats.Transient)
};
var authnRequestContext = new AuthnRequestContext(requestUri, new Uri("http://localhost"), federationContex, supportedNameIdentifierFormats);
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as ISerializer;
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory();
var authnRequest = RequestHelper.BuildRequest(authnRequestContext);
//ACT
var serialised = serialiser.Serialize(authnRequest);
var deserialised = serialiser.Deserialize <AuthnRequest>(serialised);
//ASSERT
Assert.NotNull(serialised);
Assert.AreEqual(authnRequest.Issuer.Value, deserialised.Issuer.Value);
}
public async Task ParseResponse_failed_nested_status_code_with_details_Test()
{
//ARRANGE
var inResponseTo = Guid.NewGuid().ToString();
var response = ResponseFactoryMock.GetTokenResponse(inResponseTo, StatusCodes.Responder);
ResponseFactoryMock.GetStatusCode(StatusCodes.NoAuthnContext, response.Status.StatusCode);
response.Status.StatusMessage = "Test message";
var doc = new XmlDocument();
//doc.PreserveWhitespace = true;
var el = doc.CreateElement("DetailElement");
el.SetAttribute("MessageId", "Status details");
var el1 = doc.CreateElement("AditionalDetailElement");
el1.SetAttribute("AdditionalDetail", "Additional details");
ResponseFactoryMock.BuildStatuseDetail(response.Status, new[] { el, el1 });
var logger = new LogProviderMock();
var serialised = ResponseFactoryMock.Serialize(response);
var parser = new SamlTokenResponseParser(logger);
//ACT
var tokenResponse = await parser.Parse(serialised);
//ASSERT
Assert.AreEqual(StatusCodes.Responder, tokenResponse.Status.StatusCode.Value);
Assert.IsNotNull(tokenResponse.Status.StatusCode.SubStatusCode);
Assert.AreEqual(StatusCodes.NoAuthnContext, tokenResponse.Status.StatusCode.SubStatusCode.Value);
Assert.IsNull(tokenResponse.Status.StatusCode.SubStatusCode.SubStatusCode);
Assert.AreEqual("Test message", tokenResponse.Status.StatusMessage);
Assert.IsNotNull(tokenResponse.Status.StatusDetail);
Assert.AreEqual(2, tokenResponse.Status.StatusDetail.Any.Length);
}
public void DeserialiseTokenTest_signed_only_assertion_read_assertion()
{
//ARRANGE
var path = FileHelper.GetSignedAssertion();
var certValidator = new CertificateValidatorMock();
var logger = new LogProviderMock();
var certManager = new CertificateManager(logger);
certManager.CertificateValidator = certValidator;
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var xmlReader = XmlReader.Create(path);
var reader = XmlReader.Create(xmlReader, xmlReader.Settings);
var tokenHandlerConfigurationProvider = new TokenHandlerConfigurationProvider(federationPartyContextBuilder, certManager);
var configuration = tokenHandlerConfigurationProvider.GetConfiguration("testshib");
var saml2SecurityTokenHandler = new SecurityTokenHandlerMock();
saml2SecurityTokenHandler.SetConfiguration(configuration);
//ACT
var assertion = saml2SecurityTokenHandler.GetAssertion(reader);
//Assert
Assert.NotNull(assertion);
}
public void LogoutRequestType_test_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var logoutContext = new SamlLogoutContext(new Uri(Reasons.User), new System.IdentityModel.Tokens.Saml2NameIdentifier("testUser", new Uri(NameIdentifierFormats.Persistent)), "local");
var authnRequestContext = new LogoutRequestContext(requestUri, new Uri("http://localhost"), federationContex, logoutContext);
var types = ReflectionHelper.GetAllTypes(t => !t.IsAbstract && !t.IsInterface && typeof(RequestAbstract).IsAssignableFrom(t));
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as IRequestSerialiser;
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetLogoutRequestBuildersFactory();
var logoutRequest = RequestHelper.BuildRequest(authnRequestContext);
var typeResolver = new MessageTypeResolver();
//ACT
var serialised = serialiser.Serialize(logoutRequest);
var type = typeResolver.ResolveMessageType(serialised, types);
//ASSERT
Assert.AreEqual(typeof(LogoutRequest), type);
}
public async Task CopyAllMessagesTest_many_messages()
{
//ARRANGE
var messageToEnque = 10000;
var consumed = 0;
var logger = new LogProviderMock();
var listener = new MessageListener1(m => Interlocked.Increment(ref consumed));
Func <ITransportConfiguration> configuration = () =>
{
var config = new TransportConfiguration
{
ConsumerPeriod = Timeout.InfiniteTimeSpan
};
config.Listeners.Add(listener);
return(config);
};
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
await transport.Start();
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
var destination = new byte[transport.PendingMessages][];
//ACT
await transport.CopyMessages(destination);
//ASSERT
Assert.AreEqual(messageToEnque, destination.Count());
Assert.AreEqual(messageToEnque, transport.PendingMessages);
}
public void AuthnRequestType_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var supportedNameIdentifierFormats = new List <Uri> {
new Uri(NameIdentifierFormats.Transient)
};
var authnRequestContext = new AuthnRequestContext(requestUri, new Uri("http://localhost"), federationContex, supportedNameIdentifierFormats);
var types = ReflectionHelper.GetAllTypes(t => !t.IsAbstract && !t.IsInterface && typeof(RequestAbstract).IsAssignableFrom(t));
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as IRequestSerialiser;
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory();
var authnRequest = RequestHelper.BuildRequest(authnRequestContext);
var typeResolver = new MessageTypeResolver();
//ACT
var serialised = serialiser.Serialize(authnRequest);
var type = typeResolver.ResolveMessageType(serialised, types);
//ASSERT
Assert.AreEqual(typeof(AuthnRequest), type);
}
public async Task AuthnRequestSerialiser_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var supportedNameIdentifierFormats = new List <Uri> {
new Uri(NameIdentifierFormats.Transient)
};
var authnRequestContext = new AuthnRequestContext(requestUri, federationContex, supportedNameIdentifierFormats);
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new AuthnRequestSerialiser(xmlSerialiser, encoder, logger);
AuthnRequestHelper.GetBuilders = AuthnRequestBuildersFactoryMock.GetBuildersFactory();
var authnRequest = AuthnRequestHelper.BuildAuthnRequest(authnRequestContext);
//ACT
var request = await serialiser.Serialize(authnRequest);
//ASSERT
Assert.NotNull(request);
}
public async Task ParseLogoutRequest_post_binding()
{
//ARRANGE
var form = await SamlPostRequestProviderMock.BuildLogoutRequestPostForm();
Func <Type, IMetadataHandler> metadataHandlerFactory = t => new MetadataEntitityDescriptorHandler();
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as IRequestSerialiser;
var certManager = new CertificateManager(logger);
var signatureManager = new XmlSignatureManager();
Func <IEnumerable <RequestValidationRule> > rulesResolver = () => new[] { new SignatureValidRule(logger, certManager, signatureManager) };
var requestValidator = new Federation.Protocols.Request.Validation.RequestValidator(logger, new RuleFactory(rulesResolver));
var configurationRetrieverMock = new ConfigurationRetrieverMock();
var federationPartyContextBuilderMock = new FederationPartyContextBuilderMock();
var configurationManger = new ConfigurationManager <MetadataBase>(federationPartyContextBuilderMock, configurationRetrieverMock);
var requestParser = new RequestParser(metadataHandlerFactory, t => new LogoutRequestParser(serialiser, logger),
configurationManger, logger, requestValidator);
var postBindingDecoder = new PostBindingDecoder(logger);
var message = await postBindingDecoder.Decode(form.HiddenControls.ToDictionary(k => k.Key, v => v.Value));
var context = new SamlInboundContext
{
Message = message,
DescriptorResolver = m => metadataHandlerFactory(typeof(object)).GetIdentityProviderSingleSignOnDescriptor(m).Single().Roles.Single()
};
//ACT
var result = await requestParser.Parse(context);
//ASSERT
Assert.IsTrue(result.IsValidated);
Assert.IsInstanceOf <LogoutRequest>(result.SamlRequest);
}
public void SignDataTest()
{
//ARRANGE
var data = "Data to sign";
var logger = new LogProviderMock();
var manager = new CertificateManager(logger);
var certContext = new X509CertificateContext
{
StoreLocation = StoreLocation.LocalMachine,
ValidOnly = false,
StoreName = "TestCertStore"
};
certContext.SearchCriteria.Add(new CertificateSearchCriteria
{
SearchCriteriaType = X509FindType.FindBySubjectName,
SearchValue = "www.eca-international.com"
});
//ACT
var cert = manager.GetCertificateFromContext(certContext);
var signed = manager.SignData(data, cert);
var signedBytes = Convert.ToBase64String(signed);
var verified = manager.VerifySignatureFromBase64(data, signedBytes, certContext);
//ASSERT
Assert.IsTrue(verified);
}
public async Task VerifySugnature1()
{
var metadataPath = @"D:\Dan\Software\Apira\Temp\sso.flowz.co.uk007.xml";
var path = @"D:\Dan\Software\Apira\Temp\XmlRequest.txt";
var logger = new LogProviderMock();
var xmlReader = XmlReader.Create(metadataPath);
var certificateManager = new CertificateManager(logger);
var read = new MetadataSerializer
{
CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.None
};
var meta = read.ReadMetadata(xmlReader);
var descr = ((EntityDescriptor)meta).RoleDescriptors.First();
var k = descr.Keys.Single(x => x.Use == KeyType.Signing);
var kinfo = k.KeyInfo.First();
var bi = kinfo as BinaryKeyIdentifierClause;
var xr = kinfo as X509RawDataKeyIdentifierClause;
var cert = new X509Certificate2(xr.GetX509RawData());
var raw = bi.GetBuffer();
var cert1 = new X509Certificate2(raw);
//var key = kinfo.CreateKey() as X509AsymmetricSecurityKey;
//var ak = key.GetAsymmetricAlgorithm(SignedXml.XmlDsigRSASHA1Url, false);
var request = File.ReadAllText(path);
var isValid = this.VerifySignature(request, cert);
var isValid1 = this.VerifySignature(request, cert1);
Assert.IsTrue(isValid);
Assert.IsTrue(isValid1);
}
public void SPMetadata_serialise_deserialise_Test()
{
////ARRANGE
var logger = new LogProviderMock();
string metadataXml = String.Empty;
var metadataWriter = new TestMetadatWriter(el => metadataXml = el.OuterXml);
var contextBuilder = new InlineMetadataContextBuilder();
var metadataRequest = new MetadataGenerateRequest(MetadataType.SP, "local");
var metadataContext = contextBuilder.BuildContext(metadataRequest);
var context = new FederationPartyConfiguration(metadataRequest.FederationPartyId, "localhost");
context.MetadataContext = metadataContext;
var configurationProvider = new CertificateValidationConfigurationProvider();
var certificateValidator = new CertificateValidator(configurationProvider);
var ssoCryptoProvider = new CertificateManager(logger);
var metadataSerialiser = new FederationMetadataSerialiser(certificateValidator, logger);
var metadataDispatcher = new FederationMetadataDispatcherMock(() => new[] { metadataWriter });
var sPSSOMetadataProvider = new SPSSOMetadataProvider(metadataDispatcher, ssoCryptoProvider, metadataSerialiser, g => context, logger);
//ACT
sPSSOMetadataProvider.CreateMetadata(metadataRequest);
var xmlReader = XmlReader.Create(new StringReader(metadataXml));
var deserialisedMetadata = metadataSerialiser.ReadMetadata(xmlReader) as EntityDescriptor;
//ASSERT
Assert.IsFalse(String.IsNullOrWhiteSpace(metadataXml));
Assert.AreEqual(1, deserialisedMetadata.RoleDescriptors.Count);
}
public async Task WsFederationConfigurationRetrieverTest()
{
//ARRANGE
var webRequestHandler = new WebRequestHandler();
webRequestHandler.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback((_, __, ___, ____) => true);
var httpClient = new HttpClient(webRequestHandler);
var documentRetrieer = new HttpDocumentRetriever(() => httpClient);
var configurationProvider = new CertificateValidationConfigurationProvider();
var certValidator = new CertificateValidator(configurationProvider);
var logger = new LogProviderMock();
var serialiser = new FederationMetadataSerialiser(certValidator, logger);
var configurationRetriever = new WsFederationConfigurationRetriever(documentRetrieer, serialiser);
//ACT
//var baseMetadata = await WsFederationConfigurationRetriever.GetAsync("https://dg-mfb/idp/shibboleth", documentRetrieer, new CancellationToken());
var context = new FederationPartyConfiguration("local", "https://www.testshib.org/metadata/testshib-providers.xml");
var baseMetadata = await configurationRetriever.GetAsync(context, new CancellationToken());
var metadata = baseMetadata as EntitiesDescriptor;
//ASSERT
Assert.IsTrue(metadata != null);
Assert.AreEqual(2, metadata.ChildEntities.Count);
}
public void SerialiseMetadataTest()
{
//ARRANGE
var logger = new LogProviderMock();
var contextBuilder = new InlineMetadataContextBuilder();
var metadataRequest = new MetadataGenerateRequest(MetadataType.SP, "local");
var context = contextBuilder.BuildContext(metadataRequest);
var configurationProvider = new CertificateValidationConfigurationProvider();
var certificateValidator = new CertificateValidator(configurationProvider, logger);
var metadata = context.EntityDesriptorConfiguration;
var spDescriptorConfigurtion = context.EntityDesriptorConfiguration.RoleDescriptors.First() as SPSSODescriptorConfiguration;
var descriptorBuilder = new ServiceProviderSingleSignOnDescriptorBuilder();
var descriptor = descriptorBuilder.BuildDescriptor(spDescriptorConfigurtion);
var entityDescriptor = new EntityDescriptor(new EntityId("EntityIdTest"));
entityDescriptor.RoleDescriptors.Add(descriptor);
var metadataSerialiser = new FederationMetadataSerialiser(certificateValidator, logger);
//ACT
var sb = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(sb))
{
metadataSerialiser.Serialise(xmlWriter, entityDescriptor);
}
var xmlResult = sb.ToString();
//ASSERT
Assert.IsFalse(String.IsNullOrWhiteSpace(xmlResult));
}
public async Task VerifySugnature()
{
var uri = new Uri("https://sso.flowz.co.uk/sp/metadata");
var path = @"D:\Dan\Software\Apira\Temp\RedirectRequest.txt";
var logger = new LogProviderMock();
var xmlReader = this.GetMetadataUrl(uri);
var certificateManager = new CertificateManager(logger);
var read = new MetadataSerializer
{
CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.ChainTrust
};
var meta = read.ReadMetadata(xmlReader);
var descr = ((EntityDescriptor)meta).RoleDescriptors.First();
var k = descr.Keys.Single(x => x.Use == KeyType.Signing);
var kinfo = k.KeyInfo.First();
var bi = kinfo as BinaryKeyIdentifierClause;
var xr = kinfo as X509RawDataKeyIdentifierClause;
var cert = new X509Certificate2(xr.GetX509RawData());
var raw = bi.GetBuffer();
var cert1 = new X509Certificate2(raw);
//var key = kinfo.CreateKey() as X509AsymmetricSecurityKey;
//var ak = key.GetAsymmetricAlgorithm(SignedXml.XmlDsigRSASHA1Url, false);
var requestUrl = new Uri(File.ReadAllText(path));
var url = requestUrl.GetLeftPart(UriPartial.Path);
var query = requestUrl.Query.TrimStart('?');
var isValid = this.VerifySignature(query, cert, certificateManager);
var isValid1 = this.VerifySignature(query, cert1, certificateManager);
Assert.IsTrue(isValid);
Assert.IsTrue(isValid1);
}
public async Task ParseResponse_success_Test()
{
//ARRANGE
var inResponseTo = "Test_" + Guid.NewGuid().ToString();
var response = ResponseFactoryMock.GetTokenResponseSuccess(inResponseTo, StatusCodes.Success);
var logger = new LogProviderMock();
var serialised = ResponseFactoryMock.Serialize(response);
var parser = new SamlTokenResponseParser(logger);
//ACT
var tokenResponse = await parser.Parse(serialised);
//ASSERT
Assert.AreEqual(StatusCodes.Success, tokenResponse.Status.StatusCode.Value);
Assert.IsNull(tokenResponse.Status.StatusCode.SubStatusCode);
Assert.IsNull(tokenResponse.Status.StatusMessage);
Assert.IsNull(tokenResponse.Status.StatusDetail);
Assert.AreEqual(inResponseTo, tokenResponse.InResponseTo);
Assert.AreEqual(response.ID, tokenResponse.ID);
Assert.AreEqual(response.IssueInstant, tokenResponse.IssueInstant);
Assert.AreEqual(response.Issuer.Format, tokenResponse.Issuer.Format);
Assert.AreEqual(response.Issuer.Value, tokenResponse.Issuer.Value);
Assert.AreEqual(response.Version, tokenResponse.Version);
Assert.AreEqual(response.Destination, tokenResponse.Destination);
}
public async Task ParseTokenResponse_post_binding_sp_initiated()
{
//ARRANGE
var inResponseTo = Guid.NewGuid().ToString();
var response = ResponseFactoryMock.GetTokenResponseSuccess(inResponseTo, StatusCodes.Success);
var logger = new LogProviderMock();
var serialised = ResponseFactoryMock.Serialize(response);
var xmlSignatureManager = new XmlSignatureManager();
var document = new XmlDocument();
document.LoadXml(serialised);
var cert = AssertionFactroryMock.GetMockCertificate();
xmlSignatureManager.SignXml(document, response.ID, cert.PrivateKey, null);
var base64Encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(document.DocumentElement.OuterXml));
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser;
var relayState = await relayStateSerialiser.Serialize(new Dictionary <string, object> {
{ "Key", "Value" }
});
var form = new SAMLForm();
form.SetResponse(base64Encoded);
form.SetRelatState(relayState);
Func <Type, IMetadataHandler> metadataHandlerFactory = t => new MetadataEntitityDescriptorHandler();
var certManager = new CertificateManager(logger);
var signatureManager = new XmlSignatureManager();
Func <IEnumerable <ResponseValidationRule> > rulesResolver = () => new[] { new ResponseSignatureRule(logger, certManager, signatureManager) };
var validator = new Federation.Protocols.Response.Validation.ResponseValidator(logger, new RuleFactory(rulesResolver));
var configurationRetrieverMock = new ConfigurationRetrieverMock();
var federationPartyContextBuilderMock = new FederationPartyContextBuilderMock();
var configurationManger = new ConfigurationManager <MetadataBase>(federationPartyContextBuilderMock, configurationRetrieverMock);
var relayStateHandler = new RelayStateHandler(relayStateSerialiser, logger);
var responseParser = new ResponseParser(metadataHandlerFactory, t => new SamlTokenResponseParser(logger),
configurationManger, relayStateHandler, logger, validator);
var postBindingDecoder = new PostBindingDecoder(logger);
var message = await postBindingDecoder.Decode(form.HiddenControls.ToDictionary(k => k.Key, v => v.Value));
var context = new SamlInboundContext
{
Message = message,
DescriptorResolver = m => metadataHandlerFactory(typeof(object)).GetIdentityProviderSingleSignOnDescriptor(m).Single().Roles.Single()
};
//ACT
var result = await responseParser.Parse(context);
//ASSERT
Assert.IsTrue(result.IsValidated);
}
public void DefaultX509CertificateValidatorTest()
{
//ARRANGE
var logger = new LogProviderMock();
var manager = new CertificateManager(logger);
//ACT
var validator = manager.CertificateValidator;
//ASSERT
Assert.IsInstanceOf <DefaultCertificateValidator>(validator);
}
public void SPMetadataGenerationTest_sql_source()
{
////ARRANGE
var result = false;
var metadataWriter = new TestMetadatWriter(el =>
{
result = true;
});
var cacheProvider = new CacheProviderMock();
var customConfiguration = new DbCustomConfiguration();
var connectionStringProvider = new MetadataConnectionStringProviderMock();
var models = ReflectionHelper.GetAllTypes(new[] { typeof(MetadataContextBuilder).Assembly })
.Where(t => !t.IsAbstract && !t.IsInterface && typeof(BaseModel).IsAssignableFrom(t));
customConfiguration.ModelsFactory = () => models;
var seeders = ReflectionHelper.GetAllTypes(new[] { typeof(MetadataContextBuilder).Assembly })
.Where(t => !t.IsAbstract && !t.IsInterface && typeof(ISeeder).IsAssignableFrom(t))
.Select(x => (ISeeder)Activator.CreateInstance(x));
seeders
.OrderBy(x => x.SeedingOrder)
.Aggregate(customConfiguration.Seeders, (c, next) => { c.Add(next); return(c); });
object dbcontext = new DBContext(connectionStringProvider, customConfiguration);
var metadataContextBuilder = new MetadataContextBuilder((IDbContext)dbcontext, cacheProvider);
var metadataRequest = new MetadataGenerateRequest(MetadataType.SP, "local");
var metadatContext = metadataContextBuilder.BuildContext(metadataRequest);
var context = new FederationPartyConfiguration(metadataRequest.FederationPartyId, "localhost")
{
MetadataContext = metadatContext
};
var logger = new LogProviderMock();
var configurationProvider = new CertificateValidationConfigurationProvider((IDbContext)dbcontext, cacheProvider);
var certificateValidator = new CertificateValidator(configurationProvider, logger);
var ssoCryptoProvider = new CertificateManager(logger);
var metadataSerialiser = new FederationMetadataSerialiser(certificateValidator, logger);
var metadataDispatcher = new FederationMetadataDispatcherMock(() => new[] { metadataWriter });
var sPSSOMetadataProvider = new SPSSOMetadataProvider(metadataDispatcher, ssoCryptoProvider, metadataSerialiser, g => context, logger);
//ACT
sPSSOMetadataProvider.CreateMetadata(metadataRequest).Wait();
//ASSERT
Assert.IsTrue(result);
}
public void X509CertificateValidatorFactory_setterTest()
{
//ARRANGE
var logger = new LogProviderMock();
var manager = new CertificateManager(logger);
CertificateManager.CertificateValidatorFactory = () => new MockX509CertificateValidator();
//ACT
var validator = manager.CertificateValidator;
//ASSERT
Assert.IsInstanceOf <MockX509CertificateValidator>(validator);
}
public void GetX509CertificateStoreTokenResolverTest()
{
//ARRANGE
var logger = new LogProviderMock();
var certContext = new X509CertificateContext {
StoreName = "TestCertStore", StoreLocation = StoreLocation.CurrentUser
};
var manager = new CertificateManager(logger);
//ACT
var resolver = manager.GetX509CertificateStoreTokenResolver(certContext);
//ASSERT
Assert.IsInstanceOf <X509CertificateStoreTokenResolverCustom>(resolver);
}
public async Task ConsumeMessagesTest_many_messages_async_enque_auto_dequeue()
{
//ARRANGE
var messageToEnque = 1000000;
var consumed = 0;
var logger = new LogProviderMock();
var listener = new MessageListener1(m => Interlocked.Increment(ref consumed));
Func <ITransportConfiguration> configuration = () =>
{
var config = new TransportConfiguration
{
ConsumerPeriod = TimeSpan.FromMilliseconds(1)
};
config.Listeners.Add(listener);
return(config);
};
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
await transport.Start();
var enqueTask = Task.Factory.StartNew(() =>
{
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
});
var enqueTask1 = Task.Factory.StartNew(() =>
{
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
});
//ACT
Task.WaitAll(enqueTask, enqueTask1);
while (!transport.IsEmpty)
{
Thread.Sleep(1);
}
//ASSERT
Assert.AreEqual(0, transport.PendingMessages);
Assert.AreEqual(2 * messageToEnque, consumed);
}
public async Task ConsumeMessagesTest_many_messages_two_workers()
{
//ARRANGE
var messageToEnque = 100000;
var consumed = 0;
var logger = new LogProviderMock();
var listener = new MessageListener1(m => Interlocked.Increment(ref consumed));
Func <ITransportConfiguration> configuration = () =>
{
var config = new TransportConfiguration
{
ConsumerPeriod = Timeout.InfiniteTimeSpan
};
config.Listeners.Add(listener);
return(config);
};
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
await transport.Start();
for (var i = 0; i < messageToEnque; i++)
{
transport.Enque(message);
}
//ACT
var task = Task.Factory.StartNew(() =>
{
transport.Consume(configuration());
});
var task1 = Task.Factory.StartNew(() =>
{
transport.Consume(configuration());
});
await Task.WhenAll(task, task1);
while (!transport.IsEmpty)
{
Thread.Sleep(1);
}
//ASSERT
Assert.AreEqual(messageToEnque, consumed);
Assert.AreEqual(0, transport.PendingMessages);
}
public async Task BuildRelayStateTest()
{
//ARRANGE
var logger = new LogProviderMock();
var handler = new RelayStateAppender(logger);
//ACT
var federationPartyContextBuilderMock = new FederationPartyContextBuilderMock();
var configuration = federationPartyContextBuilderMock.BuildContext("local");
var authnRequestContext = new AuthnRequestContext(new Uri("http://localhost"), new Uri("http://localhost"), configuration, new [] { new Uri("http://localhost") });
await handler.BuildRelayState(authnRequestContext);
//ASSERT
Assert.AreEqual(3, authnRequestContext.RelyingState.Count);
Assert.AreEqual("local", authnRequestContext.RelyingState["federationPartyId"]);
Assert.AreEqual(authnRequestContext.RequestId, authnRequestContext.RelyingState.ElementAt(1).Value);
Assert.AreEqual("http://localhost/", authnRequestContext.RelyingState.ElementAt(2).Value.ToString());
}
public void EnqueueMessageTest()
{
//ARRANGE
var logger = new LogProviderMock();
Func <ITransportConfiguration> configuration = () => new TransportConfiguration();
var transport = new InMemoryQueueTransport(logger, configuration);
var message = new byte[] { 0, 1, 2 };
byte[] dequeuedMessage;
//ACT
transport.Start();
transport.Enque(message);
var result = transport.TryDequeue(out dequeuedMessage);
//ASSERT
Assert.IsTrue(result);
Assert.AreEqual(message, dequeuedMessage);
}
public async Task SerialiseDeserialiseTest()
{
//ARRANGE
var relayState = new Dictionary <string, object> {
{ "relayState", "Test state" }
};
var compressor = new DeflateCompressor();
var messageEncoder = new MessageEncoding(compressor);
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var logger = new LogProviderMock();
var serialiser = new RelaystateSerialiser(jsonSerialiser, messageEncoder, logger) as IRelayStateSerialiser;
//ACT
var serialised = await serialiser.Serialize(relayState);
var deserialised = await serialiser.Deserialize(serialised) as Dictionary <string, object>;
//ASSERT
Assert.AreEqual(relayState.Count, deserialised.Count);
Assert.AreEqual(relayState["relayState"], deserialised["relayState"]);
}
public async Task RelayStateBuilder_test()
{
////ARRANGE
var relayState = new Dictionary <string, object> {
{ "relayState", "Test state" }
};
var compressor = new DeflateCompressor();
var messageEncoder = new MessageEncoding(compressor);
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var logger = new LogProviderMock();
var serialiser = new RelaystateSerialiser(jsonSerialiser, messageEncoder, logger) as IRelayStateSerialiser;
var context = new BindingContext(relayState, new Uri("localhost:"));
var builder = new RelayStateBuilder(serialiser);
//ACT
await builder.Build(context);
////ASSERT
Assert.AreEqual(1, context.RequestParts.Count);
Assert.IsTrue(context.RequestParts.ContainsKey(HttpRedirectBindingConstants.RelayState));
}
public void SPMetadataGeneration_create_file()
{
////ARRANGE
var result = false;
var path = @"D:\Dan\Software\Apira\SPMetadata\SPMetadataTest.xml";
var metadataWriter = new TestMetadatWriter(el =>
{
if (File.Exists(path))
{
File.Delete(path);
}
using (var writer = XmlWriter.Create(path))
{
el.WriteTo(writer);
writer.Flush();
}
result = true;
});
var logger = new LogProviderMock();
var contextBuilder = new InlineMetadataContextBuilder();
var metadataRequest = new MetadataGenerateRequest(MetadataType.SP, "local");
var metadatContext = contextBuilder.BuildContext(metadataRequest);
var context = new FederationPartyConfiguration(metadataRequest.FederationPartyId, "localhost");
var configurationProvider = new CertificateValidationConfigurationProvider();
var certificateValidator = new CertificateValidator(configurationProvider);
var ssoCryptoProvider = new CertificateManager(logger);
var metadataSerialiser = new FederationMetadataSerialiser(certificateValidator, logger);
var metadataDispatcher = new FederationMetadataDispatcherMock(() => new[] { metadataWriter });
var sPSSOMetadataProvider = new SPSSOMetadataProvider(metadataDispatcher, ssoCryptoProvider, metadataSerialiser, g => context, logger);
//ACT
sPSSOMetadataProvider.CreateMetadata(metadataRequest);
//ASSERT
Assert.IsTrue(result);
}
