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 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 void DeflateStream_Decompressor_2() { byte[] input = new byte[] { 0x73, 0x74, 0x72, 0x76, 0x71, 0x75, 0x03, 0x00 }; byte[] plaintext = Encoding.UTF8.GetBytes("ABCDEF"); byte[] decompBytes = DeflateCompressor.Decompress(input); Assert.IsTrue(decompBytes.SequenceEqual(plaintext)); }
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 void Compress() { var TestObject = new DeflateCompressor(); string Data = "This is a bit of data that I want to compress"; Assert.Equal("CsnILFYAokSFpMwShfw0hZTEkkSFkozEEgVPhfLEvBKFknyF5PzcgqLU4mIAAAAA//8=", Convert.ToBase64String(TestObject.Compress(Data.ToByteArray()))); }
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 override ScenarioInstance <ICompressor> CreateInstance() { var compressor = new DeflateCompressor(); var instance = new ScenarioInstance <ICompressor>(compressor); return(instance); }
public void Decompress() { var TestObject = new DeflateCompressor(); string Data = "This is a bit of data that I want to compress"; Assert.Equal("This is a bit of data that I want to compress", TestObject.Decompress(TestObject.Compress(Data.ToByteArray())).ToString(null)); }
/// <summary> /// Gets the compression mechanism using the service context and the depending on the request and response. /// </summary> /// <param name="serviceContext">The service context object.</param> /// <param name="isRequest">Specifies whether to return compression mechanism for reqeust or response.</param> /// <returns>The Compression mechanism.</returns> public static ICompressor GetCompressor(ServiceContext serviceContext, bool isRequest) { ICompressor compressor = null; if (isRequest) { switch (serviceContext.IppConfiguration.Message.Request.CompressionFormat) { case Configuration.CompressionFormat.GZip: compressor = new GZipCompressor(); break; case Configuration.CompressionFormat.Deflate: compressor = new DeflateCompressor(); break; } } else { switch (serviceContext.IppConfiguration.Message.Response.CompressionFormat) { case Configuration.CompressionFormat.GZip: compressor = new GZipCompressor(); break; case Configuration.CompressionFormat.Deflate: compressor = new DeflateCompressor(); break; } } return(compressor); }
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 CompressDecompressString() { //ARRANGE var str = "String to compress"; var compressor = new DeflateCompressor(); //ACT var strArr = Encoding.UTF8.GetBytes(str); var source = new MemoryStream(strArr); source.Position = 0; var compressed = new MemoryStream(); await compressor.Compress(source, compressed); compressed.Position = 0; var decompressed = new MemoryStream(); await compressor.Decompress(compressed, decompressed); decompressed.Position = 0; var result = new StreamReader(decompressed).ReadToEnd(); //ASSERT Assert.AreEqual(str, result); }
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 IsSameOrSubclassOrImplementOf_Test() { var deflate = new DeflateCompressor(); Assert.IsTrue(TypeTool.IsSameOrSubclassOrImplementedOf(deflate, typeof(ICompressor))); Assert.IsTrue(TypeTool.IsSameOrSubclassOrImplementedOf(typeof(GZipCompressor), typeof(ICompressor))); Assert.IsFalse(TypeTool.IsSameOrSubclassOrImplementedOf(typeof(Compressor), typeof(ICompressor))); }
public void DecompressTest() { DeflateCompressor target = new DeflateCompressor(); using (Stream responseStream = new MemoryStream()) { Stream actual = target.Decompress(responseStream); Assert.IsNotNull(actual); } }
public void CompressTest() { DeflateCompressor target = new DeflateCompressor(); // TODO: Initialize to an appropriate value byte[] content = Encoding.ASCII.GetBytes("Hello World"); using (Stream requestStream = new MemoryStream()) { target.Compress(content, requestStream); } Assert.Inconclusive("A method that does not return a value cannot be verified."); }
public void DeflateCompressorStringExtesionWorks() { var compressor = new DeflateCompressor(); var compressed = compressor.Compress("test"); Assert.IsNotNull(compressed); var decompressor = new DeflateDecompressor(); var decompressed = decompressor.Decompress(compressed); Assert.IsNotNull(decompressed); Assert.AreEqual("test", Encoding.UTF8.GetString(decompressed)); }
public void DeflateCompressorStringExtesionWorks() { var compressor = new DeflateCompressor(); var compressed = compressor.Compress("test"); compressed.Should().NotBeNull(); var decompressor = new DeflateDecompressor(); var decompressed = decompressor.Decompress(compressed); decompressed.Should().NotBeNull(); Encoding.UTF8.GetString(decompressed).Should().Be("test"); }
public async Task MessageEncoding_test() { //ARRANGE var source = "Text to encode"; var compressor = new DeflateCompressor(); var encoder = new MessageEncoding(compressor); var expected = await Helper.DeflateEncode(source.ToString(), compressor); //ACT var encoded = await encoder.EncodeMessage(source); //ASSERT Assert.AreEqual(expected, encoded); }
public async Task CompressDecompressString() { //ARRANGE var str = "String to compress."; var compression = new DeflateCompressor(); //ACT var compressed = await Helper.DeflateEncode(str, compression); var decompressed = await Helper.DeflateDecompress(compressed, compression); //ASSERT Assert.AreEqual(str, decompressed); }
public async Task MessageEncodingDecodingTest_test() { //ARRANGE var source = "Text to encode"; var compressor = new DeflateCompressor(); var encoder = new MessageEncoding(compressor); //ACT var encoded = await encoder.EncodeMessage(source); var decoded = await encoder.DecodeMessage(encoded); //ASSERT Assert.AreEqual(decoded, source); }
public async Task CompressDecompressString() { //ARRANGE var str = "String to compress."; var compression = new DeflateCompressor(); //ACT var buffer = System.Text.Encoding.UTF8.GetBytes(str); var compressed = await Helper.DeflateCompress(buffer, compression); var decompressed = await Helper.DeflateDecompress(compressed, compression); //ASSERT Assert.AreEqual(str, decompressed); }
public async Task MessageDecoding_test() { //ARRANGE var source = "Text to encode"; var compressor = new DeflateCompressor(); var encoder = new MessageEncoding(compressor); var encoded = await Helper.DeflateCompress(System.Text.Encoding.UTF8.GetBytes(source), compressor); var toString64 = Convert.ToBase64String(encoded); //ACT var decoded = await encoder.DecodeMessage(toString64); //ASSERT Assert.AreEqual(decoded, source); }
public static async Task <SAMLForm> BuildRequestBindingContext(RequestContext requestContext) { string url = String.Empty; var builders = new List <IPostClauseBuilder>(); requestContext.RelyingState.Add("relayState", "Test state"); var xmlSerialiser = new XMLSerialiser(); var compressor = new DeflateCompressor(); var encoder = new MessageEncoding(compressor); var logger = new LogProviderMock(); var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger); var xmlSinatureManager = new XmlSignatureManager(); RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory(); var authnBuilder = new SamlRequestBuilder(serialiser); builders.Add(authnBuilder); //relay state builder var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider()); var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser; var relayStateBuilder = new RelayStateBuilder(relayStateSerialiser); builders.Add(relayStateBuilder); //signature builder var certificateManager = new CertificateManager(logger); var signatureBuilder = new SignatureBuilder(certificateManager, logger, xmlSinatureManager); builders.Add(signatureBuilder); var bindingContext = new RequestPostBindingContext(requestContext); foreach (var b in builders) { await b.Build(bindingContext); } var form = new SAMLForm(); var request = bindingContext.RequestParts[HttpRedirectBindingConstants.SamlRequest]; var base64Encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(request)); var relyingStateSerialised = bindingContext.RequestParts[HttpRedirectBindingConstants.RelayState]; form.ActionURL = bindingContext.DestinationUri.AbsoluteUri; form.SetRequest(base64Encoded); form.SetRelatState(relyingStateSerialised); return(form); }
public void DeflateStream_Compressor_2() { byte[] input = Encoding.UTF8.GetBytes("ABCDEF"); // Compress first, // 73-74-72-76-71-75-03-00 byte[] compBytes = DeflateCompressor.Compress(input); // then Decompress. byte[] decompBytes = DeflateCompressor.Decompress(compBytes); // Comprare SHA256 Digest byte[] inputDigest = TestSetup.SHA256Digest(input); byte[] decompDigest = TestSetup.SHA256Digest(decompBytes); Assert.IsTrue(decompDigest.SequenceEqual(inputDigest)); }
public void CompressDecompressTest() { DeflateCompressor target = new DeflateCompressor(); string strContent = "Hello World"; byte[] content = Encoding.ASCII.GetBytes(strContent); using (Stream requestStream = new MemoryStream()) { var compressedStream = new DeflateStream(requestStream, CompressionMode.Compress); compressedStream.Write(content, 0, content.Length); Stream actual = target.Decompress(requestStream); Assert.IsNotNull(actual); actual.Read(content, 0, content.Length); string dString = Encoding.ASCII.GetString(content); Assert.IsTrue(string.Compare(strContent, dString, false) == 0); } }
public static async Task <RequestBindingContext> BuildRequestBindingContext(RequestContext requestContext) { string url = String.Empty; var builders = new List <IRedirectClauseBuilder>(); requestContext.RelyingState.Add("relayState", "Test state"); var xmlSerialiser = new XMLSerialiser(); var compressor = new DeflateCompressor(); var encoder = new MessageEncoding(compressor); var logger = new LogProviderMock(); var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger); RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory(); var authnBuilder = new SamlRequestBuilder(serialiser); builders.Add(authnBuilder); //request compression builder var encodingBuilder = new RequestEncoderBuilder(encoder); builders.Add(encodingBuilder); //relay state builder var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider()); var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser; var relayStateBuilder = new RelayStateBuilder(relayStateSerialiser); builders.Add(relayStateBuilder); //signature builder var certificateManager = new CertificateManager(logger); var signatureBuilder = new SignatureBuilder(certificateManager, logger); builders.Add(signatureBuilder); var bindingContext = new RequestBindingContext(requestContext); foreach (var b in builders) { await b.Build(bindingContext); } return(bindingContext); }
static async Task Main(string[] args) { var messageDispatched = 0; //var resolver = new UnityDependencyResolver(); //using (new InformationLogEventWriter()) //{ // ApplicationConfiguration.RegisterDependencyResolver(() => resolver); // ApplicationConfiguration.RegisterServerInitialiserFactory(() => new ServerInitialiser()); // Program.InitializeServer(); //} var compressor = new DeflateCompressor(); var serialaser = new InMemorySerializer(compressor); var logger = new MockLogProvider(); var transport = new InMemoryQueueTransport(logger, () => new TransportConfiguration()); await transport.Start(); var transportManager = new TransportManager(transport, null); var dispatcher = new TransportDispatcher(transportManager ,serialaser);//resolver.Resolve<ITranspontDispatcher>(); var internalListener = new MessageListener(); await dispatcher.TransportManager.RegisterListener(internalListener); var tasks = new List<Task>(); for (var i = 0; i < 1; i++) { var batch = i; var task = Task.Factory.StartNew(async () => { for (var j = 0; j < 1; j++) { var command = new LogErrorCommand(Guid.NewGuid(), Guid.NewGuid()); Interlocked.Increment(ref messageDispatched); Console.WriteLine(String.Format("Dispatched message No: {0}, batch: {1}. Total number messages: {2}", j, batch, messageDispatched)); //Thread.Sleep(10); await dispatcher.SendMessage(command); } }); tasks.Add(task); } Console.ReadLine(); }
public void Compress(CompressionType compressionType) { if (IsSet) { throw new InvalidOperationException("Explicitly setting compression type must be performed before headers get sent"); } Compression = compressionType; switch (compressionType) { case CompressionType.None: ContentTransform = new RawUnifiedDuplex(); IsCompressionSet = false; break; case CompressionType.Gzip: ContentTransform = new GzipCompressor(CompressionLevel); IsCompressionSet = true; break; case CompressionType.Deflate: ContentTransform = new DeflateCompressor(CompressionLevel); IsCompressionSet = true; break; case CompressionType.Compress: throw new NotImplementedException("Got Compress, an unimplemented compression, as compression type"); default: throw new ArgumentException("Got Unknown as compression type"); } }
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 bool TrySetFor(MessageHead head) { ThrowIfEnded(); BodyType?bodyType = BodyType.TryDetectFor(head); if (bodyType == null) { return(false); } CompressionType compression = bodyType.Value.CompressionType; TransferEncoding transfer = bodyType.Value.TransferEncoding; int contentLength = bodyType.Value.ContentLength; if (IsSet) { Finish(); } IsSet = true; TransferEncoding = transfer; ContentLength = contentLength; if (Compression != CompressionType.Unknown) { return(true); } Compression = compression; switch (compression) { case CompressionType.None: ContentTransform = new RawUnifiedDuplex(); IsCompressionSet = false; break; case CompressionType.Gzip: ContentTransform = new GzipCompressor(CompressionLevel); IsCompressionSet = true; break; case CompressionType.Deflate: ContentTransform = new DeflateCompressor(CompressionLevel); IsCompressionSet = true; break; case CompressionType.Compress: return(false); default: return(false); } return(true); }