public static void XmlBaseWriter_WriteStartEndElementAsync()
{
string actual;
int byteSize = 1024;
byte[] bytes = GetByteArray(byteSize);
string expect = GetExpectString(bytes, byteSize);
using (var ms = new AsyncMemoryStream())
{
var writer = XmlDictionaryWriter.CreateTextWriter(ms);
writer.WriteStartDocument();
// NOTE: the async method has only one overload that takes 3 params
var t1 = writer.WriteStartElementAsync(null, "data", null);
t1.Wait();
writer.WriteBase64(bytes, 0, byteSize);
var t2 = writer.WriteEndElementAsync();
t2.Wait();
writer.WriteEndDocument();
writer.Flush();
ms.Position = 0;
var sr = new StreamReader(ms);
actual = sr.ReadToEnd();
}
Assert.StrictEqual(expect, actual);
}
public static void XmlBaseWriter_FlushAsync()
{
string actual;
int byteSize = 1024;
byte[] bytes = GetByteArray(byteSize);
string expect = GetExpectString(bytes, byteSize);
using (var ms = new AsyncMemoryStream())
{
var writer = XmlDictionaryWriter.CreateTextWriter(ms);
writer.WriteStartDocument();
writer.WriteStartElement("data");
writer.WriteBase64(bytes, 0, byteSize);
writer.WriteEndElement();
writer.WriteEndDocument();
var task = writer.FlushAsync();
task.Wait();
ms.Position = 0;
var sr = new StreamReader(ms);
actual = sr.ReadToEnd();
}
Assert.StrictEqual(expect, actual);
}
public static void CreateTextReaderWriterTest()
{
string expected = "<localName>the value</localName>";
using (MemoryStream stream = new MemoryStream())
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false))
{
writer.WriteElementString("localName", "the value");
writer.Flush();
byte[] bytes = stream.ToArray();
StreamReader reader = new StreamReader(stream);
stream.Position = 0;
string content = reader.ReadToEnd();
Assert.Equal(expected, content);
reader.Close();
using (XmlDictionaryReader xreader = XmlDictionaryReader.CreateTextReader(bytes, new XmlDictionaryReaderQuotas()))
{
xreader.Read();
string xml = xreader.ReadOuterXml();
Assert.Equal(expected, xml);
}
}
}
}
private static Stream ToStream <T>(T item)
{
var ds = new DataContractSerializer(typeof(T));
MemoryStream stream = null;
try
{
stream = new MemoryStream();
using (WrapperStream wrapperStream = new WrapperStream(stream, true))
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateTextWriter(wrapperStream, new UTF8Encoding(false)))
{
ds.WriteObject(xmlDictionaryWriter, item);
}
}
catch (Exception)
{
if (stream != null)
{
stream.Dispose();
}
}
return(stream);
}
private void Serialize(string path)
{
FileStream someStream = new FileStream(path, FileMode.Open);
//<snippet8>
Person p = new Person();
DataContractSerializer dcs =
new DataContractSerializer(typeof(Person));
XmlDictionaryWriter xdw =
XmlDictionaryWriter.CreateTextWriter(someStream, Encoding.UTF8);
dcs.WriteObject(xdw, p);
//</snippet8>
//<snippet9>
dcs.WriteStartObject(xdw, p);
xdw.WriteAttributeString("serializedBy", "myCode");
dcs.WriteObjectContent(xdw, p);
dcs.WriteEndObject(xdw);
//</snippet9>
//<snippet10>
xdw.WriteStartElement("MyCustomWrapper");
dcs.WriteObjectContent(xdw, p);
xdw.WriteEndElement();
//</snippet10>
}
public virtual Task WriteMessageAsync(Message message, Stream stream)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
ThrowIfMismatchedMessageVersion(message);
XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, _writeEncoding, false);
if (_optimizeWriteForUtf8)
{
message.WriteMessage(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
message.WriteMessage(xmlWriter);
xmlWriter.WriteEndDocument();
}
xmlWriter.Flush();
xmlWriter.Dispose();
return(Task.CompletedTask);
}
private static void WriteTraceData(TraceEventType eventType, int id, string traceIdentifier, string description, string methodName, Exception exception)
{
if (source.Switch.ShouldTrace(eventType))
{
MemoryStream strm = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(strm);
writer.WriteStartElement(TraceRecordName);
writer.WriteAttributeString("xmlns", TraceRecordNs);
writer.WriteElementString("TraceIdentifier", traceIdentifier);
writer.WriteElementString("Description", description);
writer.WriteElementString("AppDomain", AppDomain.CurrentDomain.FriendlyName);
writer.WriteElementString("MethodName", methodName);
writer.WriteElementString("Source", TraceHelper.TraceSourceName);
if (exception != null)
{
WriteException(writer, exception);
}
writer.WriteEndElement();
writer.Flush();
strm.Position = 0;
XPathDocument doc = new XPathDocument(strm);
source.TraceData(eventType, id, doc.CreateNavigator());
writer.Close();
strm.Close();
}
}
XmlElement CreateXmlTokenElement(SecurityToken token, string prefix, string name, string ns, string usage)
{
Stream stream = new MemoryStream();
using (XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false))
{
xmlWriter.WriteStartElement(prefix, name, ns);
WriteToken(xmlWriter, token, usage);
xmlWriter.WriteEndElement();
xmlWriter.Flush();
}
stream.Seek(0, SeekOrigin.Begin);
XmlDocument dom = new XmlDocument();
dom.PreserveWhitespace = true;
dom.Load(new XmlTextReader(stream)
{
DtdProcessing = DtdProcessing.Prohibit
});
stream.Close();
return(dom.DocumentElement);
}
/// <summary>
/// Makes a WSTrust call to the STS to obtain a <see cref="SecurityToken"/> first checking if the token is available in the cache.
/// </summary>
/// <returns>A <see cref="GenericXmlSecurityToken"/>.</returns>
protected override SecurityToken GetTokenCore(TimeSpan timeout)
{
_communicationObject.ThrowIfClosedOrNotOpen();
WsTrustRequest request = CreateWsTrustRequest();
WsTrustResponse trustResponse = GetCachedResponse(request);
if (trustResponse is null)
{
using (var memeoryStream = new MemoryStream())
{
var writer = XmlDictionaryWriter.CreateTextWriter(memeoryStream, Encoding.UTF8);
var serializer = new WsTrustSerializer();
serializer.WriteRequest(writer, _requestSerializationContext.TrustVersion, request);
writer.Flush();
var reader = XmlDictionaryReader.CreateTextReader(memeoryStream.ToArray(), XmlDictionaryReaderQuotas.Max);
IRequestChannel channel = ChannelFactory.CreateChannel();
try
{
channel.Open();
Message reply = channel.Request(Message.CreateMessage(MessageVersion.Soap12WSAddressing10, _requestSerializationContext.TrustActions.IssueRequest, reader));
SecurityUtils.ThrowIfNegotiationFault(reply, channel.RemoteAddress);
trustResponse = serializer.ReadResponse(reply.GetReaderAtBodyContents());
CacheSecurityTokenResponse(request, trustResponse);
}
finally
{
channel.Close();
}
}
}
return(CreateGenericXmlSecurityToken(request, trustResponse));
}
public static XmlWriter CreateXmlWriter(ReaderWriterType rwType, Stream stream, Encoding encoding, IXmlDictionary dictionary)
{
XmlWriter result = null;
switch (rwType)
{
case ReaderWriterType.Binary:
result = XmlDictionaryWriter.CreateBinaryWriter(stream, dictionary);
break;
case ReaderWriterType.Text:
result = XmlDictionaryWriter.CreateTextWriter(stream, encoding);
break;
case ReaderWriterType.WebData:
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = encoding;
result = XmlWriter.Create(stream, settings);
break;
case ReaderWriterType.WrappedWebData:
XmlWriterSettings settings2 = new XmlWriterSettings();
settings2.Encoding = encoding;
result = XmlWriter.Create(stream, settings2);
result = XmlDictionaryWriter.CreateDictionaryWriter(result);
break;
default:
throw new ArgumentOutOfRangeException(nameof(rwType));
}
return(result);
}
/// <summary>
/// Adds the specified facts into the internal collection by serializing these using DataContractSerializer.
/// </summary>
/// <param name="facts">A collection of facts.</param>
public void AddFacts(IEnumerable <object> facts)
{
Guard.ArgumentNotNull(facts, "facts");
foreach (object fact in facts)
{
var dcAttribute = FrameworkUtility.GetDeclarativeAttribute <DataContractAttribute>(fact);
if (dcAttribute != null)
{
DataContractSerializer serializer = !String.IsNullOrEmpty(dcAttribute.Name) && !String.IsNullOrEmpty(dcAttribute.Namespace) ? new DataContractSerializer(fact.GetType(), dcAttribute.Name, dcAttribute.Namespace) : new DataContractSerializer(fact.GetType());
using (MemoryStream serializationBuffer = new MemoryStream())
{
using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(serializationBuffer, Encoding.UTF8, false))
{
serializer.WriteObject(xmlWriter, fact);
}
serializationBuffer.Seek(0, SeekOrigin.Begin);
using (StreamReader dataReader = new StreamReader(serializationBuffer))
{
this.facts[fact.GetType().AssemblyQualifiedName] = dataReader.ReadToEnd();
}
}
}
else
{
throw new InvalidDataContractException(String.Format(CultureInfo.InvariantCulture, ExceptionMessages.MustSupplyDataContractAttribute, fact.GetType().FullName));
}
}
}
public void WriteBodyToEncryptThenSign(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm)
{
encryptedData.Id = this.securityHeader.GenerateId();
this.SetBodyId();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(Stream.Null);
writer.WriteStartElement("a");
MemoryStream stream = new MemoryStream();
((IFragmentCapableXmlDictionaryWriter)writer).StartFragment(stream, true);
base.InnerMessage.WriteBodyContents(writer);
((IFragmentCapableXmlDictionaryWriter)writer).EndFragment();
writer.WriteEndElement();
stream.Flush();
encryptedData.SetUpEncryption(algorithm, new ArraySegment <byte>(stream.GetBuffer(), 0, (int)stream.Length));
this.fullBodyBuffer = new XmlBuffer(0x7fffffff);
XmlDictionaryWriter writer2 = this.fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
writer2.StartCanonicalization(canonicalStream, false, null);
this.WriteStartInnerMessageWithId(writer2);
encryptedData.WriteTo(writer2, ServiceModelDictionaryManager.Instance);
writer2.WriteEndElement();
writer2.EndCanonicalization();
writer2.Flush();
this.fullBodyBuffer.CloseSection();
this.fullBodyBuffer.Close();
this.state = BodyState.EncryptedThenSigned;
}
public static void WriteObjectData(string path)
{
// Create the object to serialize.
Person p = new Person("Lynn", "Tsoflias", 9876);
// Create the writer.
FileStream fs = new FileStream(path, FileMode.Create);
XmlDictionaryWriter writer =
XmlDictionaryWriter.CreateTextWriter(fs);
NetDataContractSerializer ser =
new NetDataContractSerializer();
// Use the writer to start a document.
writer.WriteStartDocument(true);
// Use the serializer to write the start of the
// object data. Use it again to write the object
// data.
ser.WriteStartObject(writer, p);
ser.WriteObjectContent(writer, p);
// Use the serializer to write the end of the
// object data. Then use the writer to write the end
// of the document.
ser.WriteEndObject(writer);
writer.WriteEndDocument();
Console.WriteLine("Done");
// Close and release the writer resources.
writer.Flush();
fs.Flush();
fs.Close();
}
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 void save(Stream s)
{
XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateTextWriter(s, Encoding.UTF8);
xdw.WriteStartDocument();
dcs.WriteObject(xdw, this);
xdw.Close();
}
public SqlValueSerializerCsvWithXmlDictionaryWriter(Encoding p_Encoding) : base(p_Encoding)
{
_StreamXml = new MemoryStream();
_XmlDictionaryWriter = XmlDictionaryWriter.CreateTextWriter(_StreamXml, p_Encoding, false);
_EndLineBuffer = Encoding.UTF8.GetBytes(RowSplitter.ToString());
_SplitterBuffer = Encoding.UTF8.GetBytes(ColumnSplitter.ToString());
_Buffer = new byte[0];
}
private static void SerializeDataContractXml <T>(T instance, Stream stream)
{
using (var writer = XmlDictionaryWriter.CreateTextWriter(stream, new UTF8Encoding(), false))
{
var serializer = new DataContractSerializer(typeof(T));
serializer.WriteObject(writer, instance);
}
}
public virtual void WriteObject(Stream stream, object graph)
{
CheckNull(stream, "stream");
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false /*ownsStream*/);
WriteObject(writer, graph);
writer.Flush();
}
public virtual void WriteObject(Stream stream, object graph)
{
stream = stream ?? throw new ArgumentNullException(nameof(stream));
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream: stream, encoding: Encoding.UTF8, ownsStream: false);
WriteObject(writer, graph);
writer.Flush();
}
private static void AddToDigest(SspiNegotiationTokenAuthenticatorState sspiState, RequestSecurityToken rst)
{
MemoryStream stream = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream);
rst.RequestSecurityTokenXml.WriteTo(writer);
writer.Flush();
AddToDigest(sspiState.NegotiationDigest, stream);
}
public static void C14NWriterNegativeTests()
{
const string TestTypeNullStream = "Null Stream";
const string TestTypeNullElementInIncludePrefixes = "Null element in IncludePrefixes";
TestCase tc = TestConfigHelper.GetTest("C14NWriterNegativeTests");
foreach (var input in tc.Inputs)
{
string testType = input.Arguments[0].Value;
if (testType == TestTypeNullStream)
{
try
{
//creating XmlC14NWriter with a null stream;
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(Stream.Null);
writer.StartCanonicalization(null, true, new string[] { "p1", "p2" });
Assert.False(true, "Error, creating XmlC14NWriter with a null stream should have thrown!");
}
catch (Exception ex)
{
//System.ArgumentNullException: {{ResLookup:;Value cannot be null.;ManagedString;mscorlib.dll;mscorlib;ArgumentNull_Generic}}
Assert.Equal(input.Arguments[1].Value, ex.GetType().FullName);
}
}
else if (testType == TestTypeNullElementInIncludePrefixes)
{
MemoryStream ms1 = new MemoryStream();
MemoryStream ms2 = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms1);
try
{
//Creating the C14N writer with null elements in the IncludePrefixes array;
writer.WriteStartElement("p2", "Root", "http://namespace");
//Starting the canonicalization;
writer.StartCanonicalization(ms2, true, new string[] { "p1", null, "p2" });
//Writing the first element in the C14N writer;
writer.WriteStartElement("Wee");
//Writing some content to finish the start element. Last chance for it to throw
writer.WriteQualifiedName("foo", "http://namespace");
writer.WriteEndElement();
writer.EndCanonicalization();
writer.WriteEndElement();
Assert.False(true, "Error, creating XmlC14NWriter with null elements in include prefixes should have thrown!");
}
catch (Exception ex)
{
//System.ArgumentException: {{ResLookup:;The inclusive namespace prefix collection cannot contain null as one of the items.;ManagedString;System.Runtime.Serialization.dll;System.Runtime.Serialization;InvalidInclusivePrefixListCollection}}
Assert.Equal(input.Arguments[1].Value, ex.GetType().FullName);
}
}
else
{
throw new ArgumentException("Don't know how to run test " + testType);
}
}
}
private void WriteJwts(SecurityTokenDescriptor tokenDescriptor, SignatureProvider signatureProvider)
{
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
JwtSecurityToken jwt = new JwtSecurityToken(tokenDescriptor.TokenIssuerName, tokenDescriptor.AppliesToAddress, tokenDescriptor.Subject.Claims, tokenDescriptor.Lifetime, tokenDescriptor.SigningCredentials);
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms);
tokenHandler.WriteToken(writer, jwt);
}
private void CreateSamlTokens(SecurityTokenDescriptor tokenDescriptor)
{
SamlSecurityTokenHandler samlTokenHandler = new SamlSecurityTokenHandler();
SamlSecurityToken token = samlTokenHandler.CreateToken(tokenDescriptor) as SamlSecurityToken;
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(ms);
samlTokenHandler.WriteToken(writer, token);
}
public void PutData(Message m)
{
FileStream stream = new FileStream("myfile.xml", FileMode.Create);
XmlDictionaryWriter xdw =
XmlDictionaryWriter.CreateTextWriter(stream);
m.WriteBodyContents(xdw);
xdw.Flush();
}
public System.IO.MemoryStream ToXml(object o)
{
var result = new System.IO.MemoryStream();
if (o == null)
{
return(result);
}
using (var writer = XmlDictionaryWriter.CreateTextWriter(result, Encoding.UTF8, false))
{
var serializer = serializers[o.GetType()];
serializer.WriteObject(writer, o);
}
result.Seek(0, System.IO.SeekOrigin.Begin);
if (oldMonoSerializer)
{
var xml = new XmlDocument
{
PreserveWhitespace = true
};
xml.Load(result);
result.Close();
//remove incorrect ns
foreach (XmlNode entry in xml.SelectNodes("//entry"))
{
var nsattr = entry.Attributes.Cast <XmlAttribute>().FirstOrDefault(a => a.Value == typeof(FileEntry <>).Name);
if (nsattr != null)
{
foreach (XmlAttribute a in entry.Attributes)
{
if (a.Value.StartsWith(nsattr.LocalName + ":"))
{
a.Value = a.Value.Substring(nsattr.LocalName.Length + 1);
}
}
entry.Attributes.Remove(nsattr);
}
}
//http://stackoverflow.com/questions/13483138/mono-does-not-honor-system-runtime-serialization-datamemberattribute-emitdefault
var nsmanager = new XmlNamespaceManager(xml.NameTable);
nsmanager.AddNamespace("i", "http://www.w3.org/2001/XMLSchema-instance");
foreach (XmlNode nil in xml.SelectNodes("//*[@i:nil='true']", nsmanager))
{
nil.ParentNode.RemoveChild(nil);
}
result = new System.IO.MemoryStream();
xml.Save(result);
result.Seek(0, System.IO.SeekOrigin.Begin);
}
return(result);
}
public virtual void WriteObject(Stream stream, object?graph)
{
ArgumentNullException.ThrowIfNull(stream);
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8, false /*ownsStream*/);
WriteObject(writer, graph);
writer.Flush();
}
private void WriteObjectWithInstance(XmlObjectSerializer xm, Company graph, string fileName)
{
Console.WriteLine(xm.GetType());
FileStream fs = new FileStream(fileName, FileMode.Create);
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
xm.WriteObject(writer, graph);
Console.WriteLine("Done writing {0}", fileName);
}
public static string BuildWaSignInMessage(SecurityToken securityToken, SecurityTokenHandler tokenHandler, string tokenType)
{
using (var memoryStream = new MemoryStream())
{
using (var writer = XmlDictionaryWriter.CreateTextWriter(memoryStream, Encoding.UTF8, false))
{
// <RequestSecurityTokenResponse>
writer.WriteStartElement(WsTrustConstants_1_3.PreferredPrefix, WsTrustConstants.Elements.RequestSecurityTokenResponse, WsTrustConstants_1_3.Namespace);
// <Lifetime>
writer.WriteStartElement(WsTrustConstants_1_3.PreferredPrefix, WsTrustConstants.Elements.Lifetime, WsTrustConstants.Namespaces.WsTrust1_3);
writer.WriteElementString(WsUtility.PreferredPrefix, WsUtility.Elements.Created, WsUtility.Namespace, Default.IssueInstantString);
writer.WriteElementString(WsUtility.PreferredPrefix, WsUtility.Elements.Expires, WsUtility.Namespace, Default.ExpiresString);
// </Lifetime>
writer.WriteEndElement();
// <AppliesTo>
writer.WriteStartElement(WsPolicy.PreferredPrefix, WsPolicy.Elements.AppliesTo, WsPolicy.Namespace);
// <EndpointReference>
writer.WriteStartElement(WsAddressing.PreferredPrefix, WsAddressing.Elements.EndpointReference, WsAddressing.Namespace);
writer.WriteElementString(WsAddressing.PreferredPrefix, WsAddressing.Elements.Address, WsAddressing.Namespace, Default.Audience);
// </EndpointReference>
writer.WriteEndElement();
// </AppliesTo>
writer.WriteEndElement();
// <RequestedSecurityToken>token</RequestedSecurityToken>
writer.WriteStartElement(WsTrustConstants_1_3.PreferredPrefix, WsTrustConstants.Elements.RequestedSecurityToken, WsTrustConstants_1_3.Namespace);
tokenHandler.WriteToken(writer, securityToken);
writer.WriteEndElement();
// <TokenType>tokenType</TokenType>
writer.WriteElementString(WsTrustConstants_1_3.PreferredPrefix, WsTrustConstants.Elements.TokenType, WsTrustConstants_1_3.Namespace, tokenType);
//<RequestType>http://schemas.xmlsoap.org/ws/2005/02/trust/Issue</RequestType>
writer.WriteElementString(WsTrustConstants_1_3.PreferredPrefix, WsTrustConstants.Elements.RequestType, WsTrustConstants_1_3.Namespace, WsTrustConstants_1_3.Actions.Issue);
//<KeyType>http://schemas.xmlsoap.org/ws/2005/05/identity/NoProofKey</KeyType>
writer.WriteElementString(WsTrustConstants_1_3.PreferredPrefix, WsTrustConstants.Elements.KeyType, WsTrustConstants_1_3.Namespace, "http://schemas.xmlsoap.org/ws/2005/05/identity/NoProofKey");
// </RequestSecurityTokenResponse>
writer.WriteEndElement();
writer.Flush();
var rstr = Encoding.UTF8.GetString(memoryStream.ToArray());
return("wa=wsignin1.0&wresult=" + Uri.EscapeDataString(rstr));
}
}
}
/// <summary>
/// Makes a WSTrust call to the STS to obtain a <see cref="SecurityToken"/> first checking if the token is available in the cache.
/// </summary>
/// <returns>A <see cref="GenericXmlSecurityToken"/>.</returns>
protected override SecurityToken GetTokenCore(TimeSpan timeout)
{
WsTrustRequest request = CreateWsTrustRequest();
WsTrustResponse trustResponse = GetCachedResponse(request);
if (trustResponse is null)
{
using (var memeoryStream = new MemoryStream())
{
var writer = XmlDictionaryWriter.CreateTextWriter(memeoryStream, Encoding.UTF8);
var serializer = new WsTrustSerializer();
serializer.WriteRequest(writer, _requestSerializationContext.TrustVersion, request);
writer.Flush();
var reader = XmlDictionaryReader.CreateTextReader(memeoryStream.ToArray(), XmlDictionaryReaderQuotas.Max);
IRequestChannel channel = ChannelFactory.CreateChannel();
Message reply = channel.Request(Message.CreateMessage(MessageVersion.Soap12WSAddressing10, _requestSerializationContext.TrustActions.IssueRequest, reader));
SecurityUtils.ThrowIfNegotiationFault(reply, channel.RemoteAddress);
trustResponse = serializer.ReadResponse(reply.GetReaderAtBodyContents());
CacheSecurityTokenResponse(request, trustResponse);
}
}
// Create GenericXmlSecurityToken
// Assumes that token is first and Saml2SecurityToken.
using (var stream = new MemoryStream())
{
RequestSecurityTokenResponse response = trustResponse.RequestSecurityTokenResponseCollection[0];
// Get attached and unattached references
GenericXmlSecurityKeyIdentifierClause internalSecurityKeyIdentifierClause = null;
if (response.AttachedReference != null)
{
internalSecurityKeyIdentifierClause = GetSecurityKeyIdentifierForTokenReference(response.AttachedReference);
}
GenericXmlSecurityKeyIdentifierClause externalSecurityKeyIdentifierClause = null;
if (response.UnattachedReference != null)
{
externalSecurityKeyIdentifierClause = GetSecurityKeyIdentifierForTokenReference(response.UnattachedReference);
}
// Get proof token
IdentityModel.Tokens.SecurityToken proofToken = GetProofToken(request, response);
// Get lifetime
DateTime created = response.Lifetime?.Created ?? DateTime.UtcNow;
DateTime expires = response.Lifetime?.Expires ?? created.AddDays(1);
return(new GenericXmlSecurityToken(response.RequestedSecurityToken.TokenElement,
proofToken,
created,
expires,
internalSecurityKeyIdentifierClause,
externalSecurityKeyIdentifierClause,
null));
}
}
private void WriteMapToFile(SerializableMapData map, string path)
{
using (var fileStream = new FileStream(path, FileMode.Create)) {
using (var xmlWriter = XmlDictionaryWriter.CreateTextWriter(fileStream)) {
var serializer = new DataContractSerializer(typeof(SerializableMapData), KnownSerializableTypes);
serializer.WriteObject(fileStream, map);
}
}
}