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);
        }
예제 #2
0
        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));
        }
예제 #3
0
        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);
        }
예제 #4
0
        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);
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
        }
예제 #9
0
        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);
        }
예제 #10
0
        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);
        }
예제 #13
0
        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);
        }
예제 #14
0
        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);
        }
예제 #15
0
        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);
        }
예제 #19
0
        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));
        }
예제 #30
0
        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);
        }