public void WriteTo(Stream canonicalStream) { if (this.reader != null) { XmlDictionaryReader dicReader = this.reader as XmlDictionaryReader; if ((dicReader != null) && (dicReader.CanCanonicalize)) { dicReader.MoveToContent(); dicReader.StartCanonicalization(canonicalStream, this.includeComments, this.inclusivePrefixes); dicReader.Skip(); dicReader.EndCanonicalization(); } else { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(Stream.Null); if (this.inclusivePrefixes != null) { // Add a dummy element at the top and populate the namespace // declaration of all the inclusive prefixes. writer.WriteStartElement("a", reader.LookupNamespace(String.Empty)); for (int i = 0; i < this.inclusivePrefixes.Length; ++i) { string ns = reader.LookupNamespace(this.inclusivePrefixes[i]); if (ns != null) { writer.WriteXmlnsAttribute(this.inclusivePrefixes[i], ns); } } } writer.StartCanonicalization(canonicalStream, this.includeComments, this.inclusivePrefixes); if (reader is WrappedReader) { ((WrappedReader)reader).XmlTokens.GetWriter().WriteTo(writer, new DictionaryManager()); } else { writer.WriteNode(reader, false); } writer.Flush(); writer.EndCanonicalization(); if (this.inclusivePrefixes != null) { writer.WriteEndElement(); } writer.Close(); } if (this.closeReadersAfterProcessing) { this.reader.Close(); } this.reader = null; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.NoInputIsSetForCanonicalization))); } }
public byte[] CanonicalizeUsingDictionaryReader(XmlReader reader) { _canonicalWriterStream.Seek(0, SeekOrigin.Begin); _canonicalWriterStream.SetLength(0); XmlDictionaryReader dicReader = XmlDictionaryReader.CreateDictionaryReader(reader); dicReader.MoveToContent(); dicReader.StartCanonicalization(_canonicalWriterStream, _includeComments, _tokenizedInclusivePrefixes); dicReader.Skip(); dicReader.EndCanonicalization(); return(_canonicalWriterStream.ToArray()); }
internal override SecurityTimestamp ReadTimestamp(XmlDictionaryReader reader, string digestAlgorithm, SignatureResourcePool resourcePool) { bool canonicalize = digestAlgorithm != null && reader.CanCanonicalize; HashStream hashStream = null; reader.MoveToStartElement(XD.UtilityDictionary.Timestamp, XD.UtilityDictionary.Namespace); if (canonicalize) { hashStream = resourcePool.TakeHashStream(digestAlgorithm); reader.StartCanonicalization(hashStream, false, null); } string id = reader.GetAttribute(XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace); reader.ReadStartElement(); reader.ReadStartElement(XD.UtilityDictionary.CreatedElement, XD.UtilityDictionary.Namespace); DateTime creationTimeUtc = reader.ReadContentAsDateTime().ToUniversalTime(); reader.ReadEndElement(); DateTime expiryTimeUtc; if (reader.IsStartElement(XD.UtilityDictionary.ExpiresElement, XD.UtilityDictionary.Namespace)) { reader.ReadStartElement(); expiryTimeUtc = reader.ReadContentAsDateTime().ToUniversalTime(); reader.ReadEndElement(); } else { expiryTimeUtc = SecurityUtils.MaxUtcDateTime; } reader.ReadEndElement(); byte[] digest; if (canonicalize) { reader.EndCanonicalization(); digest = hashStream.FlushHashAndGetValue(); } else { digest = null; } return(new SecurityTimestamp(creationTimeUtc, expiryTimeUtc, id, digestAlgorithm, digest)); }
public void WriteTo(Stream canonicalStream) { if (this.reader == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.IdentityModel.SR.GetString("NoInputIsSetForCanonicalization"))); } XmlDictionaryReader reader = this.reader as XmlDictionaryReader; if ((reader != null) && reader.CanCanonicalize) { reader.MoveToContent(); reader.StartCanonicalization(canonicalStream, this.includeComments, this.inclusivePrefixes); reader.Skip(); reader.EndCanonicalization(); } else { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(Stream.Null); if (this.inclusivePrefixes != null) { writer.WriteStartElement("a", this.reader.LookupNamespace(string.Empty)); for (int i = 0; i < this.inclusivePrefixes.Length; i++) { string namespaceUri = this.reader.LookupNamespace(this.inclusivePrefixes[i]); if (namespaceUri != null) { writer.WriteXmlnsAttribute(this.inclusivePrefixes[i], namespaceUri); } } } writer.StartCanonicalization(canonicalStream, this.includeComments, this.inclusivePrefixes); writer.WriteNode(this.reader, false); writer.Flush(); writer.EndCanonicalization(); if (this.inclusivePrefixes != null) { writer.WriteEndElement(); } writer.Close(); } if (this.closeReadersAfterProcessing) { this.reader.Close(); } this.reader = null; }
private void ProcessReaderInput(XmlReader reader, SignatureResourcePool resourcePool, HashStream hashStream) { reader.MoveToContent(); XmlDictionaryReader reader2 = reader as XmlDictionaryReader; if ((reader2 != null) && reader2.CanCanonicalize) { reader2.StartCanonicalization(hashStream, this.IncludeComments, this.GetInclusivePrefixes()); reader2.Skip(); reader2.EndCanonicalization(); } else { CanonicalizationDriver configuredDriver = this.GetConfiguredDriver(resourcePool); configuredDriver.SetInput(reader); configuredDriver.WriteTo(hashStream); } }
internal override SecurityTimestamp ReadTimestamp(XmlDictionaryReader reader, string digestAlgorithm, SignatureResourcePool resourcePool) { DateTime maxUtcDateTime; byte[] buffer; bool flag = (digestAlgorithm != null) && reader.CanCanonicalize; HashStream stream = null; reader.MoveToStartElement(System.ServiceModel.XD.UtilityDictionary.Timestamp, System.ServiceModel.XD.UtilityDictionary.Namespace); if (flag) { stream = resourcePool.TakeHashStream(digestAlgorithm); reader.StartCanonicalization(stream, false, null); } string attribute = reader.GetAttribute(System.ServiceModel.XD.UtilityDictionary.IdAttribute, System.ServiceModel.XD.UtilityDictionary.Namespace); reader.ReadStartElement(); reader.ReadStartElement(System.ServiceModel.XD.UtilityDictionary.CreatedElement, System.ServiceModel.XD.UtilityDictionary.Namespace); DateTime creationTimeUtc = reader.ReadContentAsDateTime().ToUniversalTime(); reader.ReadEndElement(); if (reader.IsStartElement(System.ServiceModel.XD.UtilityDictionary.ExpiresElement, System.ServiceModel.XD.UtilityDictionary.Namespace)) { reader.ReadStartElement(); maxUtcDateTime = reader.ReadContentAsDateTime().ToUniversalTime(); reader.ReadEndElement(); } else { maxUtcDateTime = System.ServiceModel.Security.SecurityUtils.MaxUtcDateTime; } reader.ReadEndElement(); if (flag) { reader.EndCanonicalization(); buffer = stream.FlushHashAndGetValue(); } else { buffer = null; } return(new SecurityTimestamp(creationTimeUtc, maxUtcDateTime, attribute, digestAlgorithm, buffer)); }
public override void ReadFrom(XmlDictionaryReader reader, TransformFactory transformFactory, DictionaryManager dictionaryManager) { base.SendSide = false; if (reader.CanCanonicalize) { base.CanonicalStream = new MemoryStream(); reader.StartCanonicalization(base.CanonicalStream, false, null); } reader.MoveToStartElement(dictionaryManager.XmlSignatureDictionary.SignedInfo, dictionaryManager.XmlSignatureDictionary.Namespace); this.prefix = reader.Prefix; base.Id = reader.GetAttribute(dictionaryManager.UtilityDictionary.IdAttribute, null); reader.Read(); base.ReadCanonicalizationMethod(reader, dictionaryManager); base.ReadSignatureMethod(reader, dictionaryManager); while (reader.IsStartElement(dictionaryManager.XmlSignatureDictionary.Reference, dictionaryManager.XmlSignatureDictionary.Namespace)) { Reference reference = new Reference(dictionaryManager); reference.ReadFrom(reader, transformFactory, dictionaryManager); this.AddReference(reference); } reader.ReadEndElement(); if (reader.CanCanonicalize) { reader.EndCanonicalization(); } string[] inclusivePrefixes = base.GetInclusivePrefixes(); if (inclusivePrefixes != null) { base.CanonicalStream = null; this.context = new Dictionary <string, string>(inclusivePrefixes.Length); for (int i = 0; i < inclusivePrefixes.Length; i++) { this.context.Add(inclusivePrefixes[i], reader.LookupNamespace(inclusivePrefixes[i])); } } }
public static void ReaderWriter_C14N_DifferentReadersWriters() { int count = 0; var params1 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup1"); var params2 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup2"); var params3 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup3"); var params4 = TestConfigHelper.GetTest("ReaderWriter_C14N_DifferentReadersWriters_ParamGroup4"); Transform transform; MemoryStream canonicalStream; MemoryStream ms; Stream transformedOutput; byte[] outputFromSecurity; byte[] outputFromIndigo; //TestC14NInMultipleWriters foreach (var input in params1.Inputs) { foreach (var input2 in params2.Inputs) { foreach (var input3 in params3.Inputs) { count++; string rwTypeStr = input.Arguments[0].Value; ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true); Encoding encoding = Encoding.GetEncoding((string)input.Arguments[1].Value); string sampleXmlFileName = input2.Arguments[0].Value; bool mustSupportV14N = input.Arguments[2].Value == "true"; string baselineFileName = input2.Arguments[1].Value; bool testWithComments = input3.Arguments[0].Value == "true"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.PreserveWhitespace = true; if (testWithComments) { transform = new XmlDsigExcC14NWithCommentsTransform(); } else { transform = new XmlDsigExcC14NTransform(); } xmlDoc.Load(baselineFileName); transform.LoadInput(xmlDoc); transformedOutput = transform.GetOutput(typeof(Stream)) as Stream; outputFromSecurity = StreamToByteArray(transformedOutput); byte[] sampleXmlFileBytes = File.ReadAllBytes(sampleXmlFileName); ms = new MemoryStream(); XmlWriter w = ReaderWriterFactory.CreateXmlWriter(rwType, ms, encoding); canonicalStream = new MemoryStream(); XmlDictionaryWriter dicWriter = w as XmlDictionaryWriter; if (dicWriter == null) { dicWriter = XmlDictionaryWriter.CreateDictionaryWriter(w); } if (!dicWriter.CanCanonicalize) { Assert.False(mustSupportV14N, "Error, writer should support C14N, but it doesn't!"); continue; } dicWriter.WriteStartElement("MyRoot"); dicWriter.StartCanonicalization(canonicalStream, testWithComments, null); FileStream fs = File.OpenRead(sampleXmlFileName); XmlReader webdataReader = XmlReader.Create(fs); CopyXmlToWriter(webdataReader, dicWriter); dicWriter.EndCanonicalization(); dicWriter.WriteEndElement(); dicWriter.Flush(); webdataReader.Close(); fs.Close(); outputFromIndigo = canonicalStream.ToArray(); Helper.DumpToFile(outputFromSecurity); Helper.DumpToFile(outputFromIndigo); Assert.True(Enumerable.SequenceEqual(outputFromSecurity, outputFromIndigo), $"ReaderWriter_C14N_DifferentReadersWriters test variation #{count} failed"); } } } //TestC14NInReader foreach (var input in params4.Inputs) { count++; string sampleXmlFileName = input.Arguments[3].Value; string rwTypeStr = input.Arguments[0].Value; ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true); Encoding encoding = Encoding.GetEncoding((string)input.Arguments[1].Value); bool mustSupportV14N = input.Arguments[2].Value == "true"; string baselineFileName = "ReaderWriter_C14N_BaselineXML_OnlyLF.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.PreserveWhitespace = true; transform = new XmlDsigExcC14NTransform(); xmlDoc.Load(baselineFileName); transform.LoadInput(xmlDoc); transformedOutput = transform.GetOutput(typeof(Stream)) as Stream; outputFromSecurity = StreamToByteArray(transformedOutput); byte[] sampleXmlFileBytes = File.ReadAllBytes(sampleXmlFileName); XmlReader r = ReaderWriterFactory.CreateXmlReader(rwType, sampleXmlFileBytes, encoding); XmlDictionaryReader dicReader = r as XmlDictionaryReader; if (dicReader == null) { dicReader = XmlDictionaryReader.CreateDictionaryReader(r); } canonicalStream = new MemoryStream(); if (!dicReader.CanCanonicalize) { Assert.False(mustSupportV14N, "Error, reader should support C14N, but it doesn't!"); continue; } dicReader.StartCanonicalization(canonicalStream, false, null); canonicalStream.Position = 0; string str = new StreamReader(canonicalStream).ReadToEnd(); canonicalStream.Position = 0; while (dicReader.Read()) { ; // simply read it all into the C14N writer } dicReader.EndCanonicalization(); dicReader.Close(); outputFromIndigo = canonicalStream.ToArray(); Helper.DumpToFile(outputFromSecurity); Helper.DumpToFile(outputFromIndigo); Assert.True(Enumerable.SequenceEqual(outputFromSecurity, outputFromIndigo), $"ReaderWriter_C14N_DifferentReadersWriters test variation #{count} failed"); } //TestC14NWriterWithManyAttributes int numberOfAttributes = 1000; int seed = (int)DateTime.Now.Ticks; Random rndGen = new Random(seed); StringBuilder sb = new StringBuilder(); sb.Append("<Root><Element"); int prefixIndex = 0; for (int i = 0; i < numberOfAttributes; i++) { string namespaceUri = null; string prefix = null; if ((rndGen.Next() % 5) == 0) { prefix = "p" + (prefixIndex++); namespaceUri = "http://namespace_" + i; } string localName = "attr" + i; string value = "attrValue" + i; if (prefix == null) { sb.Append($" {localName}=\"{value}\""); } else { sb.Append($" {prefix}:{localName}=\"{2}\" xmlns:{value}=\"{namespaceUri}\""); } } sb.Append(">Hello world</Element></Root>"); string xmlString = sb.ToString(); XmlDocument doc = new XmlDocument(); doc.LoadXml(xmlString); ms = new MemoryStream(); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms); canonicalStream = new MemoryStream(); writer.StartCanonicalization(canonicalStream, false, null); doc.WriteTo(writer); writer.Flush(); writer.EndCanonicalization(); outputFromIndigo = canonicalStream.ToArray(); byte[] nonCanonicalOutput = ms.ToArray(); XmlDsigExcC14NTransform transform2 = new XmlDsigExcC14NTransform(); transform2.LoadInput(doc); transformedOutput = transform2.GetOutput(typeof(Stream)) as Stream; outputFromSecurity = StreamToByteArray(transformedOutput); Helper.DumpToFile(outputFromSecurity); Helper.DumpToFile(outputFromIndigo); Helper.DumpToFile(nonCanonicalOutput); Assert.True(Enumerable.SequenceEqual(outputFromSecurity, outputFromIndigo), $"ReaderWriter_C14N_DifferentReadersWriters test variation #{count} failed"); count++; Assert.Equal(params1.Inputs.Count * params2.Inputs.Count * params3.Inputs.Count + params4.Inputs.Count + 1, count); }
protected virtual void ComputeHash(HashStream hashStream) { if (this.sendSide) { XmlDictionaryWriter writer = this.ResourcePool.TakeUtf8Writer(); writer.StartCanonicalization(hashStream, false, null); this.WriteTo(writer, this.dictionaryManager); writer.EndCanonicalization(); } else if (this.canonicalStream != null) { this.canonicalStream.WriteTo(hashStream); } else { if (this.readerProvider == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CryptographicException(System.IdentityModel.SR.GetString("InclusiveNamespacePrefixRequiresSignatureReader"))); } XmlDictionaryReader reader = this.readerProvider.GetReader(this.signatureReaderProviderCallbackContext); if (!reader.CanCanonicalize) { MemoryStream stream = new MemoryStream(); XmlDictionaryWriter writer2 = XmlDictionaryWriter.CreateBinaryWriter(stream, this.DictionaryManager.ParentDictionary); string[] inclusivePrefixes = this.GetInclusivePrefixes(); if (inclusivePrefixes != null) { writer2.WriteStartElement("a"); for (int i = 0; i < inclusivePrefixes.Length; i++) { string namespaceForInclusivePrefix = this.GetNamespaceForInclusivePrefix(inclusivePrefixes[i]); if (namespaceForInclusivePrefix != null) { writer2.WriteXmlnsAttribute(inclusivePrefixes[i], namespaceForInclusivePrefix); } } } reader.MoveToContent(); writer2.WriteNode(reader, false); if (inclusivePrefixes != null) { writer2.WriteEndElement(); } writer2.Flush(); byte[] buffer = stream.ToArray(); int length = (int)stream.Length; writer2.Close(); reader.Close(); reader = XmlDictionaryReader.CreateBinaryReader(buffer, 0, length, this.DictionaryManager.ParentDictionary, XmlDictionaryReaderQuotas.Max); if (inclusivePrefixes != null) { reader.ReadStartElement("a"); } } reader.ReadStartElement(this.dictionaryManager.XmlSignatureDictionary.Signature, this.dictionaryManager.XmlSignatureDictionary.Namespace); reader.MoveToStartElement(this.dictionaryManager.XmlSignatureDictionary.SignedInfo, this.dictionaryManager.XmlSignatureDictionary.Namespace); reader.StartCanonicalization(hashStream, false, this.GetInclusivePrefixes()); reader.Skip(); reader.EndCanonicalization(); reader.Close(); } }