private void buttonGet_Click(object sender, EventArgs e)
{
try
{
this.Cursor = Cursors.WaitCursor;
this.xmlNotepadPanelControl1.XmlNotepadForm.ClearXmlDocument();
MetadataSet metadata = null;
if (this.checkBoxAssembly.Checked)
{
this.FromAssembly(this.textBoxUrl.Text);
}
else
{
metadata = MetadataHelper.GetMetadataSet(this.textBoxUrl.Text);
}
if (metadata != null)
{
StringBuilder sb = new StringBuilder();
metadata.WriteTo(XmlWriter.Create(sb));
this.xmlNotepadPanelControl1.XmlNotepadForm.LoadXmlDocument(sb.ToString());
}
this.buttonGet.Enabled = false;
}
catch (Exception ex)
{
MessageBox.Show(MetadataHelper.ErrorMessage(ex), "Loading metadata", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
this.Cursor = Cursors.Default;
}
}
internal static string SaveMetadataToString(MetadataSet metadata)
{
using (var ms = new MemoryStream()) {
var writer = new XmlTextWriter(new StreamWriter(ms));
writer.Formatting = Formatting.Indented;
metadata.WriteTo(writer);
writer.Flush();
return(Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Position));
}
}
static void Main(string[] args)
{
Uri address = new Uri("http://127.0.0.1:9999/calculatorservice/metadata");
MetadataExchangeClient metadataExchangeClient = new MetadataExchangeClient(address, MetadataExchangeClientMode.HttpGet);
metadataExchangeClient.ResolveMetadataReferences = false;
MetadataSet metadata = metadataExchangeClient.GetMetadata();
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
public static void SaveMetadataToFile(string filename, MetadataSet metadata)
{
if (File.Exists(filename))
{
return;
}
using (var file = new StreamWriter(filename, false)) {
var writer = new XmlTextWriter(file);
writer.Formatting = Formatting.Indented;
metadata.WriteTo(writer);
}
Console.WriteLine("Exported {0}.", filename);
}
static void Main(string[] args)
{
using (ChannelFactory<IMetadataProvisionService> channelFactory = new ChannelFactory<IMetadataProvisionService>("mex"))
{
IMetadataProvisionService proxy = channelFactory.CreateChannel();
string action = "http://schemas.xmlsoap.org/ws/2004/09/transfer/Get";
Message request = Message.CreateMessage(MessageVersion.Default, action);
Message reply = proxy.Get(request);
MetadataSet metadata = reply.GetBody<MetadataSet>();
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
}
private static void Test1()
{
Uri address = new Uri("http://127.0.0.1:9999/calculatorservice/metadata");
MetadataExchangeClient client = new MetadataExchangeClient(address, MetadataExchangeClientMode.HttpGet);
client.ResolveMetadataReferences = false;
MetadataSet metadata = client.GetMetadata();
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
WsdlImporter importer = new WsdlImporter(metadata);
importer.ImportAllEndpoints();
importer.ImportAllContracts();
}
static void Main(string[] args)
{
ContractDescription contract = ContractDescription.GetContract(typeof(IOrderService));
EndpointAddress address1 = new EndpointAddress("http://127.0.0.1/orderservice");
EndpointAddress address2 = new EndpointAddress("net.tcp://127.0.0.1/orderservice");
ServiceEndpoint endpoint1 = new ServiceEndpoint(contract, new WS2007HttpBinding(), address1);
ServiceEndpoint endpoint2 = new ServiceEndpoint(contract, new NetTcpBinding(), address2);
XmlQualifiedName serviceName = new XmlQualifiedName("OrderService", "http://www.artech.com/services/");
WsdlExporter exporter = new WsdlExporter();
exporter.ExportEndpoints(new ServiceEndpoint[] { endpoint1, endpoint2 }, serviceName);
MetadataSet metadata = exporter.GetGeneratedMetadata();
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
private string SerializeMetadataSetToString(MetadataSet metadataSet)
{
if (metadataSet == null)
{
throw new ArgumentNullException("metadataSet");
}
var stringBuilder = new StringBuilder();
using (var textWriter = new StringWriter(stringBuilder))
{
using (var writer = new XmlTextWriter(textWriter))
{
metadataSet.WriteTo(writer);
}
}
return(stringBuilder.ToString());
}
static void Main(string[] args)
{
MetadataSet metadata = null;
using (ChannelFactory <IMetadataExchange> channelFactory = new ChannelFactory <IMetadataExchange>(MetadataExchangeBindings.CreateMexHttpBinding(), new EndpointAddress("http://127.0.0.1:9999/calculatorservice/mex")))
{
IMetadataExchange proxy = channelFactory.CreateChannel();
using (proxy as IDisposable)
{
string action = "http://schemas.xmlsoap.org/ws/2004/09/transfer/Get";
Message request = Message.CreateMessage(MessageVersion.Default, action);
metadata = proxy.Get(request).GetBody <MetadataSet>();
}
}
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
static void Main(string[] args)
{
//MetadataSection metadataSection = new MetadataSection();
//MetadataLocation metadataLocation = new MetadataLocation();
//WsdlExporter wsdlExporter = new WsdlExporter();
ContractDescription contract = ContractDescription.GetContract(typeof(IOrderService));
EndpointAddress endpointAddress1 = new EndpointAddress("http://127.0.0.1/orderservice");
EndpointAddress endpointAddress2 = new EndpointAddress("net.tcp://127.0.0.1/orderservice");
ServiceEndpoint endpoint1 = new ServiceEndpoint(contract, new WSHttpBinding(), endpointAddress1);
ServiceEndpoint endpoint2 = new ServiceEndpoint(contract, new NetTcpBinding(), endpointAddress2);
XmlQualifiedName serviceName = new XmlQualifiedName("OrderService", "http://www.lhl.com");
WsdlExporter wsdlExporter = new WsdlExporter();
wsdlExporter.ExportEndpoints(new ServiceEndpoint[] { endpoint1, endpoint2 }, serviceName);
MetadataSet metadata = wsdlExporter.GetGeneratedMetadata();
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8)) {
metadata.WriteTo(writer);
}
}
static void Main(string[] args)
{
MetadataSet metadata = new MetadataSet();
string address = "http://127.0.0.1:3721/calculatorservice/metadata";
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(address);
request.Method = "Get";
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (XmlReader reader = XmlDictionaryReader.CreateTextReader(response.GetResponseStream(), new XmlDictionaryReaderQuotas()))
{
System.Web.Services.Description.ServiceDescription serviceDesc = System.Web.Services.Description.ServiceDescription.Read(reader);
metadata.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDesc));
}
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
private XmlDictionaryReader CreateMetadataReader(Uri mexAddress)
{
var metadataSet = new MetadataSet();
var metadataReference = new MetadataReference(new EndpointAddress(mexAddress), AddressingVersion.WSAddressing10);
var metadataSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadataReference);
metadataSet.MetadataSections.Add(metadataSection);
var sb = new StringBuilder();
var w = new StringWriter(sb, CultureInfo.InvariantCulture);
var writer = XmlWriter.Create(w);
metadataSet.WriteTo(writer);
writer.Flush();
w.Flush();
var input = new StringReader(sb.ToString());
var reader = new XmlTextReader(input);
return(XmlDictionaryReader.CreateDictionaryReader(reader));
}
/// <summary>
/// Create a reader to provide simulated Metadata endpoint configuration element
/// </summary>
/// <param name="activeSTSUrl">The active endpoint URL.</param>
static XmlDictionaryReader GetMetadataReader(string activeSTSUrl)
{
MetadataSet metadata = new MetadataSet();
MetadataReference mexReferece = new MetadataReference(new EndpointAddress(activeSTSUrl + "/mex"), AddressingVersion.WSAddressing10);
MetadataSection refSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, mexReferece);
metadata.MetadataSections.Add(refSection);
byte[] metadataSectionBytes;
StringBuilder stringBuilder = new StringBuilder();
using (StringWriter stringWriter = new StringWriter(stringBuilder))
{
using (XmlTextWriter textWriter = new XmlTextWriter(stringWriter))
{
metadata.WriteTo(textWriter);
textWriter.Flush();
stringWriter.Flush();
metadataSectionBytes = stringWriter.Encoding.GetBytes(stringBuilder.ToString());
}
}
return(XmlDictionaryReader.CreateTextReader(metadataSectionBytes, XmlDictionaryReaderQuotas.Max));
}
private void comboBoxContracts_TextChanged(object sender, EventArgs e)
{
try
{
if (sender is ComboBox && (sender as ComboBox).Tag != null && !string.IsNullOrEmpty(this.comboBoxContracts.Text))
{
Assembly asm = (sender as ComboBox).Tag as Assembly;
WsdlExporter exporter = new WsdlExporter();
// generate contract from the clr type
ContractDescription contract = ContractDescription.GetContract(asm.GetType(this.comboBoxContracts.Text));
// dummy endpoint
exporter.ExportEndpoint(new ServiceEndpoint(contract, new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost")));
// generate metadata
MetadataSet set = exporter.GetGeneratedMetadata();
if (set != null)
{
// show in the notepad
StringBuilder sb = new StringBuilder();
set.WriteTo(XmlWriter.Create(sb));
this.xmlNotepadPanelControl1.XmlNotepadForm.LoadXmlDocument(sb.ToString());
}
}
else
{
this.xmlNotepadPanelControl1.XmlNotepadForm.ClearXmlDocument();
}
}
catch (Exception ex)
{
MessageBox.Show(MetadataHelper.ErrorMessage(ex), "Loading resource", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void SerializeAndSign(string filename, X509Certificate2 cert)
{
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream);
writer.WriteStartElement(XmlNames.WSIdentity.InfoCardElement, XmlNames.WSIdentity.Namespace);
//
// write the InformationCardReference element
//
writer.WriteAttributeString(XmlNames.Xml.Language, XmlNames.Xml.Namespace, m_language);
writer.WriteStartElement(XmlNames.WSIdentity.InfoCardRefElement, XmlNames.WSIdentity.Namespace);
writer.WriteElementString(XmlNames.WSIdentity.CardIdElement, XmlNames.WSIdentity.Namespace, m_cardId);
writer.WriteElementString(XmlNames.WSIdentity.CardVersionElement, XmlNames.WSIdentity.Namespace, m_cardVersion);
writer.WriteEndElement();
//
// card name
//
if (!String.IsNullOrEmpty(m_cardName))
{
writer.WriteStartElement(XmlNames.WSIdentity.CardNameElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(m_cardName);
writer.WriteEndElement();
}
//
// card image
//
if (null != m_logo && 0 != m_logo.Length)
{
writer.WriteStartElement(XmlNames.WSIdentity.CardImageElement, XmlNames.WSIdentity.Namespace);
if (!String.IsNullOrEmpty(m_mimeType))
{
writer.WriteAttributeString(XmlNames.WSIdentity.MimeTypeAttribute, m_mimeType);
}
string val = Convert.ToBase64String(m_logo);
writer.WriteString(val);
writer.WriteEndElement();
}
//
// card issuer uri
//
writer.WriteStartElement(XmlNames.WSIdentity.IssuerElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(m_issuerId);
writer.WriteEndElement();
//
// issue time
//
writer.WriteStartElement(XmlNames.WSIdentity.TimeIssuedElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(XmlConvert.ToString(m_issuedOn, XmlDateTimeSerializationMode.Utc));
writer.WriteEndElement();
//
// expiry time
//
writer.WriteStartElement(XmlNames.WSIdentity.TimeExpiresElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(XmlConvert.ToString(m_expiresOn, XmlDateTimeSerializationMode.Utc));
writer.WriteEndElement();
//
// Start the tokenservice list
//
writer.WriteStartElement(XmlNames.WSIdentity.TokenServiceListElement, XmlNames.WSIdentity.Namespace);
EndpointAddressBuilder eprBuilder = new EndpointAddressBuilder();
eprBuilder.Uri = new Uri(m_issuerId);
eprBuilder.Identity = new X509CertificateEndpointIdentity(cert);
if (null != m_mexUri)
{
MetadataReference mexRef = new MetadataReference();
mexRef.Address = new EndpointAddress(m_mexUri);
mexRef.AddressVersion = AddressingVersion.WSAddressing10;
MetadataSection mexSection = new MetadataSection();
mexSection.Metadata = mexRef;
MetadataSet mexSet = new MetadataSet();
mexSet.MetadataSections.Add(mexSection);
MemoryStream memStream = new MemoryStream();
XmlTextWriter writer1 = new XmlTextWriter(memStream, System.Text.Encoding.UTF8);
mexSet.WriteTo(writer1);
writer1.Flush();
memStream.Seek(0, SeekOrigin.Begin);
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(memStream, XmlDictionaryReaderQuotas.Max);
eprBuilder.SetMetadataReader(reader);
}
m_epr = eprBuilder.ToEndpointAddress();
writer.WriteStartElement(XmlNames.WSIdentity.TokenServiceElement, XmlNames.WSIdentity.Namespace);
//
// Write the EndPointReference
//
m_epr.WriteTo(AddressingVersion.WSAddressing10, writer);
//
// Write the UserCredential Element
//
writer.WriteStartElement(XmlNames.WSIdentity.UserCredentialElement, XmlNames.WSIdentity.Namespace);
//
// Write the hint
//
if (!String.IsNullOrEmpty(m_hint))
{
writer.WriteStartElement(XmlNames.WSIdentity.DisplayCredentialHintElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(m_hint);
writer.WriteEndElement();
}
switch (m_cardType)
{
case DefaultValues.CardType.UserNamePassword:
writer.WriteStartElement(XmlNames.WSIdentity.UserNamePasswordCredentialElement, XmlNames.WSIdentity.Namespace);
if (!string.IsNullOrEmpty(m_credentialIdentifier))
{
writer.WriteStartElement(XmlNames.WSIdentity.UserNameElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(m_credentialIdentifier);
writer.WriteEndElement();
}
writer.WriteEndElement();
break;
case DefaultValues.CardType.KerberosAuth:
writer.WriteStartElement(XmlNames.WSIdentity.KerberosV5CredentialElement, XmlNames.WSIdentity.Namespace);
writer.WriteEndElement();
break;
case DefaultValues.CardType.SelfIssuedAuth:
writer.WriteStartElement(XmlNames.WSIdentity.SelfIssuedCredentialElement, XmlNames.WSIdentity.Namespace);
if (!string.IsNullOrEmpty(m_credentialIdentifier))
{
writer.WriteStartElement(XmlNames.WSIdentity.PrivatePersonalIdentifierElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(m_credentialIdentifier);
writer.WriteEndElement();
}
else
{
throw new InvalidDataException("No PPID was specified");
}
writer.WriteEndElement();
break;
case DefaultValues.CardType.SmartCard:
writer.WriteStartElement(XmlNames.WSIdentity.X509V3CredentialElement, XmlNames.WSIdentity.Namespace);
writer.WriteStartElement(XmlNames.XmlDSig.X509DataElement, XmlNames.XmlDSig.Namespace);
if (!string.IsNullOrEmpty(m_credentialIdentifier))
{
writer.WriteStartElement(XmlNames.WSSecurityExt.KeyIdentifierElement, XmlNames.WSSecurityExt.Namespace);
writer.WriteAttributeString(XmlNames.WSSecurityExt.ValueTypeAttribute,
null,
XmlNames.WSSecurityExt.Sha1ThumbrpintKeyTypeValue);
writer.WriteString(m_credentialIdentifier);
writer.WriteEndElement();
}
else
{
throw new InvalidDataException("No thumbprint was specified");
}
writer.WriteEndElement();
writer.WriteEndElement();
break;
default:
break;
}
writer.WriteEndElement(); //end of user credential
writer.WriteEndElement(); // end of tokenservice
writer.WriteEndElement(); //end of tokenservice list
//
// tokentypes
//
writer.WriteStartElement(XmlNames.WSIdentity.SupportedTokenTypeListElement, XmlNames.WSIdentity.Namespace);
foreach (string type in m_tokenTypes)
{
writer.WriteElementString(XmlNames.WSTrust.TokenType,
XmlNames.WSTrust.Namespace,
type);
}
writer.WriteEndElement();
//
// claims
//
writer.WriteStartElement(XmlNames.WSIdentity.SupportedClaimTypeListElement, XmlNames.WSIdentity.Namespace);
foreach (ClaimInfo clm in m_supportedClaims)
{
writer.WriteStartElement(XmlNames.WSIdentity.SupportedClaimTypeElement, XmlNames.WSIdentity.Namespace);
writer.WriteAttributeString(XmlNames.WSIdentity.UriAttribute, clm.Id);
if (!String.IsNullOrEmpty(clm.DisplayTag))
{
writer.WriteElementString(XmlNames.WSIdentity.DisplayTagElement,
XmlNames.WSIdentity.Namespace,
clm.DisplayTag);
}
if (!String.IsNullOrEmpty(clm.Description))
{
writer.WriteElementString(XmlNames.WSIdentity.DescriptionElement,
XmlNames.WSIdentity.Namespace,
clm.Description);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
//
// RequireAppliesTo
//
if (m_requireAppliesTo)
{
writer.WriteElementString(XmlNames.WSIdentity.RequireAppliesToElement, XmlNames.WSIdentity.Namespace, null);
}
//
// Privacy Notice
//
if (!String.IsNullOrEmpty(m_privacyNoticeAt))
{
writer.WriteStartElement(XmlNames.WSIdentity.PrivacyNoticeAtElement, XmlNames.WSIdentity.Namespace);
writer.WriteString(m_privacyNoticeAt);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.Close();
//
// Sign the xml content
//
stream.Position = 0;
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = false;
doc.Load(stream);
SignedXml signed = new SignedXml();
signed.SigningKey = cert.PrivateKey;
signed.Signature.SignedInfo.CanonicalizationMethod
= SignedXml.XmlDsigExcC14NTransformUrl;
Reference reference = new Reference();
reference.Uri = "#_Object_InfoCard";
reference.AddTransform(
new XmlDsigExcC14NTransform());
signed.AddReference(reference);
KeyInfo info = new KeyInfo();
KeyInfoX509Data data = new KeyInfoX509Data(cert,
X509IncludeOption.WholeChain);
info.AddClause(data);
signed.KeyInfo = info;
DataObject cardData = new DataObject("_Object_InfoCard", null, null, doc.DocumentElement);
signed.AddObject(cardData);
signed.ComputeSignature();
XmlElement e = signed.GetXml();
XmlTextWriter fileWriter = new XmlTextWriter(filename, Encoding.UTF8);
e.WriteTo(fileWriter);
fileWriter.Flush();
fileWriter.Close();
}
public XmlDocument CreateInformationCardXML(InformationCard card)
{
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream);
writer.WriteStartElement("InformationCard", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteAttributeString("lang", "http://www.w3.org/XML/1998/namespace", "en-US");
writer.WriteStartElement("InformationCardReference", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteElementString("CardId", "http://schemas.xmlsoap.org/ws/2005/05/identity", card.CardReference.CardID);
writer.WriteElementString("CardVersion", "http://schemas.xmlsoap.org/ws/2005/05/identity", card.CardReference.CardVersion.ToString());
writer.WriteEndElement();
if (card.CardName != null && card.CardName.Length > 0)
{
writer.WriteStartElement("CardName", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(card.CardName);
writer.WriteEndElement();
}
if (card.CardImage != null && card.CardImage.ImageName.Length > 0)
{
writer.WriteStartElement("CardImage", "http://schemas.xmlsoap.org/ws/2005/05/identity");
if (card.CardImage != null && card.CardImage.ImageMimeType != null && card.CardImage.ImageMimeType.Length > 0)
{
writer.WriteAttributeString("MimeType", card.CardImage.ImageMimeType);
}
FileInfo cardImage = new FileInfo(card.CardImage.ImageName);
if (cardImage.Exists)
{
byte[] cardImageBytes = new byte[cardImage.Length];
using (FileStream imageFS = cardImage.OpenRead())
{
imageFS.Read(cardImageBytes, 0, cardImageBytes.Length);
}
string imageBase64 = Convert.ToBase64String(cardImageBytes);
writer.WriteString(imageBase64);
writer.WriteEndElement();
}
}
writer.WriteStartElement("Issuer", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(card.Issuer);
writer.WriteEndElement();
//writer.WriteStartElement("IssuerName", "http://schemas.xmlsoap.org/ws/2005/05/identity");
//writer.WriteString(card.IssuerName);
//writer.WriteEndElement();
writer.WriteStartElement("TimeIssued", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(XmlConvert.ToString(card.TimeIssued, XmlDateTimeSerializationMode.Utc));
writer.WriteEndElement();
writer.WriteStartElement("TimeExpires", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(XmlConvert.ToString(card.TimeExpires, XmlDateTimeSerializationMode.Utc));
writer.WriteEndElement();
writer.WriteStartElement("TokenServiceList", "http://schemas.xmlsoap.org/ws/2005/05/identity");
foreach (TokenService ts in card.TokenServiceList)
{
EndpointAddressBuilder endpointBuilder = new EndpointAddressBuilder();
endpointBuilder.Uri = new Uri(ts.EndpointReference.Address);
endpointBuilder.Identity = new X509CertificateEndpointIdentity(RetrieveCertificate(ts.EndpointReference.Identity));
if (null != ts.EndpointReference.Mex)
{
MetadataReference mexReference = new MetadataReference();
mexReference.Address = new EndpointAddress(ts.EndpointReference.Mex);
mexReference.AddressVersion = AddressingVersion.WSAddressing10;
MetadataSection mexSection = new MetadataSection();
mexSection.Metadata = mexReference;
MetadataSet mexSet = new MetadataSet();
mexSet.MetadataSections.Add(mexSection);
MemoryStream mexMemoryStream = new MemoryStream();
XmlTextWriter mexWriter = new XmlTextWriter(mexMemoryStream, System.Text.Encoding.UTF8);
mexSet.WriteTo(mexWriter);
mexWriter.Flush();
mexMemoryStream.Seek(0, SeekOrigin.Begin);
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(mexMemoryStream, XmlDictionaryReaderQuotas.Max);
endpointBuilder.SetMetadataReader(reader);
writer.WriteStartElement("TokenService", "http://schemas.xmlsoap.org/ws/2005/05/identity");
EndpointAddress endpoint = endpointBuilder.ToEndpointAddress();
endpoint.WriteTo(AddressingVersion.WSAddressing10, writer);
writer.WriteStartElement("UserCredential", "http://schemas.xmlsoap.org/ws/2005/05/identity");
if (ts.UserCredential.DisplayCredentialHint != null && ts.UserCredential.DisplayCredentialHint.Length > 0)
{
writer.WriteStartElement("DisplayCredentialHint", "http://schemas.xmlsoap.org/ws/2005/05/identity");
if (ts.UserCredential.UserCredentialType == CredentialType.SelfIssued)
{
//Override the user value as this should be false for types of SelfIssued
ts.UserCredential.DisplayCredentialHint = "false";
}
writer.WriteString(ts.UserCredential.DisplayCredentialHint);
writer.WriteEndElement();
}
switch (ts.UserCredential.UserCredentialType)
{
case CredentialType.SelfIssued:
writer.WriteStartElement("SelfIssuedCredential", "http://schemas.xmlsoap.org/ws/2005/05/identity");
if (!string.IsNullOrEmpty(ts.UserCredential.Value))
{
writer.WriteStartElement("PrivatePersonalIdentifier", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(ts.UserCredential.Value);
writer.WriteEndElement();
}
writer.WriteEndElement();
break;
case CredentialType.UsernameAndPassword:
writer.WriteStartElement("UsernamePasswordCredential", "http://schemas.xmlsoap.org/ws/2005/05/identity");
if (!string.IsNullOrEmpty(ts.UserCredential.Value))
{
writer.WriteStartElement("Username", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(ts.UserCredential.Value);
writer.WriteEndElement();
}
writer.WriteEndElement();
break;
case CredentialType.Kerberos:
writer.WriteStartElement("KerberosV5Credential", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteEndElement();
break;
case CredentialType.SmartCard:
writer.WriteStartElement("X509V3Credential", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteStartElement("X509Data", "http://www.w3.org/2000/09/xmldsig#");
if (!string.IsNullOrEmpty(ts.UserCredential.Value))
{
writer.WriteStartElement("KeyIdentifier", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
writer.WriteAttributeString("ValueType",
null,
"http://docs.oasis-open.org/wss/2004/xx/oasis-2004xx-wss-soap-message-security-1.1#ThumbprintSHA1");
writer.WriteString(RetrieveCertificate(ts.UserCredential.Value).Thumbprint);
writer.WriteEndElement();
}
else
{
throw new InvalidDataException("No thumbprint was specified");
}
writer.WriteEndElement();
writer.WriteEndElement();
break;
default:
break;
}
writer.WriteEndElement();
writer.WriteEndElement();
}
}
writer.WriteEndElement(); //end of tokenservice list
//
// tokentypes
//
writer.WriteStartElement("SupportedTokenTypeList", "http://schemas.xmlsoap.org/ws/2005/05/identity");
foreach (TokenType tokenType in card.AcceptedTokenTypes)
{
writer.WriteElementString("TokenType",
"http://schemas.xmlsoap.org/ws/2005/02/trust",
tokenType.Uri);
}
writer.WriteEndElement();
//
// claims
//
writer.WriteStartElement("SupportedClaimTypeList", "http://schemas.xmlsoap.org/ws/2005/05/identity");
foreach (CardClaim claim in card.SupportedClaimTypeList)
{
writer.WriteStartElement("SupportedClaimType", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteAttributeString("Uri", claim.Uri);
if (!String.IsNullOrEmpty(claim.DisplayTag))
{
writer.WriteElementString("DisplayTag", "http://schemas.xmlsoap.org/ws/2005/05/identity",
claim.DisplayTag);
}
if (!String.IsNullOrEmpty(claim.Description))
{
writer.WriteElementString("Description", "http://schemas.xmlsoap.org/ws/2005/05/identity",
claim.Description);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
if (card.RequireRPIdentification)
{
writer.WriteElementString("RequireAppliesTo", "http://schemas.xmlsoap.org/ws/2005/05/identity", card.RequireRPIdentification.ToString());
}
if (!String.IsNullOrEmpty(card.PrivacyNotice))
{
writer.WriteStartElement("PrivacyNotice", "http://schemas.xmlsoap.org/ws/2005/05/identity");
writer.WriteString(card.PrivacyNotice);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.Close();
stream.Position = 0;
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = false;
doc.Load(stream);
return(doc);
}
