mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
908 lines
40 KiB
C#
908 lines
40 KiB
C#
//----------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Security
|
|
{
|
|
using System.IdentityModel.Tokens;
|
|
using System.IO;
|
|
using System.Runtime;
|
|
using System.Security.Cryptography;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Xml;
|
|
using ExclusiveCanonicalizationTransform = System.IdentityModel.ExclusiveCanonicalizationTransform;
|
|
using HashStream = System.IdentityModel.HashStream;
|
|
using IPrefixGenerator = System.IdentityModel.IPrefixGenerator;
|
|
using ISecurityElement = System.IdentityModel.ISecurityElement;
|
|
using ISignatureValueSecurityElement = System.IdentityModel.ISignatureValueSecurityElement;
|
|
using PreDigestedSignedInfo = System.IdentityModel.PreDigestedSignedInfo;
|
|
using Reference = System.IdentityModel.Reference;
|
|
using SignedInfo = System.IdentityModel.SignedInfo;
|
|
using SignedXml = System.IdentityModel.SignedXml;
|
|
using StandardSignedInfo = System.IdentityModel.StandardSignedInfo;
|
|
using System.ServiceModel.Security.Tokens;
|
|
|
|
class WSSecurityOneDotZeroSendSecurityHeader : SendSecurityHeader
|
|
{
|
|
HashStream hashStream;
|
|
PreDigestedSignedInfo signedInfo;
|
|
SignedXml signedXml;
|
|
SecurityKey signatureKey;
|
|
MessagePartSpecification effectiveSignatureParts;
|
|
|
|
SymmetricAlgorithm encryptingSymmetricAlgorithm;
|
|
ReferenceList referenceList;
|
|
SecurityKeyIdentifier encryptionKeyIdentifier;
|
|
|
|
bool hasSignedEncryptedMessagePart;
|
|
|
|
// For Transport Secrity we have to sign the 'To' header with the
|
|
// supporting tokens.
|
|
byte[] toHeaderHash = null;
|
|
string toHeaderId = null;
|
|
|
|
public WSSecurityOneDotZeroSendSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
|
|
SecurityStandardsManager standardsManager,
|
|
SecurityAlgorithmSuite algorithmSuite,
|
|
MessageDirection direction)
|
|
: base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, direction)
|
|
{
|
|
}
|
|
|
|
protected string EncryptionAlgorithm
|
|
{
|
|
get { return this.AlgorithmSuite.DefaultEncryptionAlgorithm; }
|
|
}
|
|
|
|
protected XmlDictionaryString EncryptionAlgorithmDictionaryString
|
|
{
|
|
get { return this.AlgorithmSuite.DefaultEncryptionAlgorithmDictionaryString; }
|
|
}
|
|
|
|
protected override bool HasSignedEncryptedMessagePart
|
|
{
|
|
get
|
|
{
|
|
return this.hasSignedEncryptedMessagePart;
|
|
}
|
|
}
|
|
|
|
void AddEncryptionReference(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, bool sign,
|
|
out MemoryStream plainTextStream, out string encryptedDataId)
|
|
{
|
|
plainTextStream = new MemoryStream();
|
|
XmlDictionaryWriter encryptingWriter = XmlDictionaryWriter.CreateTextWriter(plainTextStream);
|
|
if (sign)
|
|
{
|
|
AddSignatureReference(header, headerId, prefixGenerator, encryptingWriter);
|
|
}
|
|
else
|
|
{
|
|
header.WriteHeader(encryptingWriter, this.Version);
|
|
encryptingWriter.Flush();
|
|
}
|
|
encryptedDataId = this.GenerateId();
|
|
referenceList.AddReferredId(encryptedDataId);
|
|
}
|
|
|
|
void AddSignatureReference(SecurityToken token, int position, SecurityTokenAttachmentMode mode)
|
|
{
|
|
SecurityKeyIdentifierClause keyIdentifierClause = null;
|
|
bool strTransformEnabled = this.ShouldUseStrTransformForToken(token, position, mode, out keyIdentifierClause);
|
|
AddTokenSignatureReference(token, keyIdentifierClause, strTransformEnabled);
|
|
}
|
|
|
|
void AddPrimaryTokenSignatureReference(SecurityToken token, SecurityTokenParameters securityTokenParameters)
|
|
{
|
|
// Currently we only support signing the primary token if the primary token is an issued token and protectTokens knob is set to true.
|
|
// We will get rid of the below check when we support all token types.
|
|
IssuedSecurityTokenParameters istp = securityTokenParameters as IssuedSecurityTokenParameters;
|
|
if (istp == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool strTransformEnabled = istp != null && istp.UseStrTransform;
|
|
SecurityKeyIdentifierClause keyIdentifierClause = null;
|
|
// Only if the primary token is included in the message that we sign it because WCF at present does not resolve externally referenced tokens.
|
|
// This means in the server's response
|
|
if (ShouldSerializeToken(securityTokenParameters, this.MessageDirection))
|
|
{
|
|
if (strTransformEnabled)
|
|
{
|
|
keyIdentifierClause = securityTokenParameters.CreateKeyIdentifierClause(token, GetTokenReferenceStyle(securityTokenParameters));
|
|
}
|
|
AddTokenSignatureReference(token, keyIdentifierClause, strTransformEnabled);
|
|
}
|
|
}
|
|
|
|
// Given a token and useStarTransform value this method adds apporopriate reference accordingly.
|
|
// 1. If strTransform is disabled, it adds a reference to the token's id.
|
|
// 2. Else if strtransform is enabled it adds a reference the security token's keyIdentifier's id.
|
|
void AddTokenSignatureReference(SecurityToken token, SecurityKeyIdentifierClause keyIdentifierClause, bool strTransformEnabled)
|
|
{
|
|
if (!strTransformEnabled && token.Id == null)
|
|
{
|
|
throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.ElementToSignMustHaveId)), this.Message);
|
|
}
|
|
|
|
HashStream hashStream = TakeHashStream();
|
|
XmlDictionaryWriter utf8Writer = TakeUtf8Writer();
|
|
utf8Writer.StartCanonicalization(hashStream, false, null);
|
|
this.StandardsManager.SecurityTokenSerializer.WriteToken(utf8Writer, token);
|
|
utf8Writer.EndCanonicalization();
|
|
|
|
if (strTransformEnabled)
|
|
{
|
|
if (keyIdentifierClause != null)
|
|
{
|
|
if (String.IsNullOrEmpty(keyIdentifierClause.Id))
|
|
keyIdentifierClause.Id = SecurityUniqueId.Create().Value;
|
|
this.ElementContainer.MapSecurityTokenToStrClause(token, keyIdentifierClause);
|
|
this.signedInfo.AddReference(keyIdentifierClause.Id, hashStream.FlushHashAndGetValue(), true);
|
|
}
|
|
else
|
|
throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.TokenManagerCannotCreateTokenReference)), this.Message);
|
|
}
|
|
else
|
|
this.signedInfo.AddReference(token.Id, hashStream.FlushHashAndGetValue());
|
|
}
|
|
|
|
void AddSignatureReference(SendSecurityHeaderElement[] elements)
|
|
{
|
|
if (elements != null)
|
|
{
|
|
for (int i = 0; i < elements.Length; ++i)
|
|
{
|
|
SecurityKeyIdentifierClause keyIdentifierClause = null;
|
|
TokenElement signedEncryptedTokenElement = elements[i].Item as TokenElement;
|
|
|
|
// signedEncryptedTokenElement can either be a TokenElement ( in SignThenEncrypt case) or EncryptedData ( in !SignThenEncryptCase)
|
|
// STR-Transform does not make sense in !SignThenEncrypt case .
|
|
// note: signedEncryptedTokenElement can also be SignatureConfirmation but we do not care about it here.
|
|
bool useStrTransform = signedEncryptedTokenElement != null
|
|
&& SignThenEncrypt
|
|
&& this.ShouldUseStrTransformForToken(signedEncryptedTokenElement.Token,
|
|
i,
|
|
SecurityTokenAttachmentMode.SignedEncrypted,
|
|
out keyIdentifierClause);
|
|
|
|
if (!useStrTransform && elements[i].Id == null)
|
|
{
|
|
throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.ElementToSignMustHaveId)), this.Message);
|
|
}
|
|
|
|
HashStream hashStream = TakeHashStream();
|
|
XmlDictionaryWriter utf8Writer = TakeUtf8Writer();
|
|
utf8Writer.StartCanonicalization(hashStream, false, null);
|
|
elements[i].Item.WriteTo(utf8Writer, ServiceModelDictionaryManager.Instance);
|
|
utf8Writer.EndCanonicalization();
|
|
|
|
if (useStrTransform)
|
|
{
|
|
if (keyIdentifierClause != null)
|
|
{
|
|
if (String.IsNullOrEmpty(keyIdentifierClause.Id))
|
|
keyIdentifierClause.Id = SecurityUniqueId.Create().Value;
|
|
|
|
this.ElementContainer.MapSecurityTokenToStrClause(signedEncryptedTokenElement.Token, keyIdentifierClause);
|
|
this.signedInfo.AddReference(keyIdentifierClause.Id, hashStream.FlushHashAndGetValue(), true);
|
|
}
|
|
else
|
|
throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.TokenManagerCannotCreateTokenReference)), this.Message);
|
|
}
|
|
else
|
|
this.signedInfo.AddReference(elements[i].Id, hashStream.FlushHashAndGetValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
void AddSignatureReference(SecurityToken[] tokens, SecurityTokenAttachmentMode mode)
|
|
{
|
|
if (tokens != null)
|
|
{
|
|
for (int i = 0; i < tokens.Length; ++i)
|
|
{
|
|
AddSignatureReference(tokens[i], i, mode);
|
|
}
|
|
}
|
|
}
|
|
|
|
string GetSignatureHash(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, XmlDictionaryWriter writer, out byte[] hash)
|
|
{
|
|
HashStream hashStream = TakeHashStream();
|
|
XmlDictionaryWriter effectiveWriter;
|
|
XmlBuffer canonicalBuffer = null;
|
|
|
|
if (writer.CanCanonicalize)
|
|
{
|
|
effectiveWriter = writer;
|
|
}
|
|
else
|
|
{
|
|
canonicalBuffer = new XmlBuffer(int.MaxValue);
|
|
effectiveWriter = canonicalBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
|
|
}
|
|
|
|
effectiveWriter.StartCanonicalization(hashStream, false, null);
|
|
|
|
header.WriteStartHeader(effectiveWriter, this.Version);
|
|
if (headerId == null)
|
|
{
|
|
headerId = GenerateId();
|
|
this.StandardsManager.IdManager.WriteIdAttribute(effectiveWriter, headerId);
|
|
}
|
|
header.WriteHeaderContents(effectiveWriter, this.Version);
|
|
effectiveWriter.WriteEndElement();
|
|
effectiveWriter.EndCanonicalization();
|
|
effectiveWriter.Flush();
|
|
|
|
if (!ReferenceEquals(effectiveWriter, writer))
|
|
{
|
|
Fx.Assert(canonicalBuffer != null, "Canonical buffer cannot be null.");
|
|
canonicalBuffer.CloseSection();
|
|
canonicalBuffer.Close();
|
|
XmlDictionaryReader dicReader = canonicalBuffer.GetReader(0);
|
|
writer.WriteNode(dicReader, false);
|
|
dicReader.Close();
|
|
}
|
|
|
|
hash = hashStream.FlushHashAndGetValue();
|
|
|
|
return headerId;
|
|
}
|
|
|
|
void AddSignatureReference(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, XmlDictionaryWriter writer)
|
|
{
|
|
byte[] hashValue;
|
|
headerId = GetSignatureHash(header, headerId, prefixGenerator, writer, out hashValue);
|
|
this.signedInfo.AddReference(headerId, hashValue);
|
|
}
|
|
|
|
void ApplySecurityAndWriteHeader(MessageHeader header, string headerId, XmlDictionaryWriter writer, IPrefixGenerator prefixGenerator)
|
|
{
|
|
if (!this.RequireMessageProtection && this.ShouldSignToHeader)
|
|
{
|
|
if ((header.Name == XD.AddressingDictionary.To.Value) &&
|
|
(header.Namespace == this.Message.Version.Addressing.Namespace))
|
|
{
|
|
if (this.toHeaderHash == null)
|
|
{
|
|
byte[] headerHash;
|
|
headerId = GetSignatureHash(header, headerId, prefixGenerator, writer, out headerHash);
|
|
this.toHeaderHash = headerHash;
|
|
this.toHeaderId = headerId;
|
|
}
|
|
else
|
|
// More than one 'To' header is specified in the message.
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.TransportSecuredMessageHasMoreThanOneToHeader)));
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
MessagePartProtectionMode protectionMode = GetProtectionMode(header);
|
|
MemoryStream plainTextStream;
|
|
string encryptedDataId;
|
|
switch (protectionMode)
|
|
{
|
|
case MessagePartProtectionMode.None:
|
|
header.WriteHeader(writer, this.Version);
|
|
return;
|
|
case MessagePartProtectionMode.Sign:
|
|
AddSignatureReference(header, headerId, prefixGenerator, writer);
|
|
return;
|
|
case MessagePartProtectionMode.SignThenEncrypt:
|
|
AddEncryptionReference(header, headerId, prefixGenerator, true, out plainTextStream, out encryptedDataId);
|
|
EncryptAndWriteHeader(header, encryptedDataId, plainTextStream, writer);
|
|
this.hasSignedEncryptedMessagePart = true;
|
|
return;
|
|
case MessagePartProtectionMode.Encrypt:
|
|
AddEncryptionReference(header, headerId, prefixGenerator, false, out plainTextStream, out encryptedDataId);
|
|
EncryptAndWriteHeader(header, encryptedDataId, plainTextStream, writer);
|
|
return;
|
|
case MessagePartProtectionMode.EncryptThenSign:
|
|
AddEncryptionReference(header, headerId, prefixGenerator, false, out plainTextStream, out encryptedDataId);
|
|
EncryptedHeader encryptedHeader = EncryptHeader(
|
|
header, this.encryptingSymmetricAlgorithm, this.encryptionKeyIdentifier, this.Version, encryptedDataId, plainTextStream);
|
|
AddSignatureReference(encryptedHeader, encryptedDataId, prefixGenerator, writer);
|
|
return;
|
|
default:
|
|
Fx.Assert("Invalid MessagePartProtectionMode");
|
|
return;
|
|
}
|
|
}
|
|
|
|
public override void ApplySecurityAndWriteHeaders(MessageHeaders headers, XmlDictionaryWriter writer, IPrefixGenerator prefixGenerator)
|
|
{
|
|
string[] headerIds;
|
|
if (this.RequireMessageProtection || this.ShouldSignToHeader)
|
|
{
|
|
headerIds = headers.GetHeaderAttributes(UtilityStrings.IdAttribute,
|
|
this.StandardsManager.IdManager.DefaultIdNamespaceUri);
|
|
}
|
|
else
|
|
{
|
|
headerIds = null;
|
|
}
|
|
for (int i = 0; i < headers.Count; i++)
|
|
{
|
|
MessageHeader header = headers.GetMessageHeader(i);
|
|
if (this.Version.Addressing == AddressingVersion.None && header.Namespace == AddressingVersion.None.Namespace)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (header != this)
|
|
{
|
|
ApplySecurityAndWriteHeader(header, headerIds == null ? null : headerIds[i], writer, prefixGenerator);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool CanCanonicalizeAndFragment(XmlDictionaryWriter writer)
|
|
{
|
|
if (!writer.CanCanonicalize)
|
|
{
|
|
return false;
|
|
}
|
|
IFragmentCapableXmlDictionaryWriter fragmentingWriter = writer as IFragmentCapableXmlDictionaryWriter;
|
|
return fragmentingWriter != null && fragmentingWriter.CanFragment;
|
|
}
|
|
|
|
public override void ApplyBodySecurity(XmlDictionaryWriter writer, IPrefixGenerator prefixGenerator)
|
|
{
|
|
SecurityAppliedMessage message = this.SecurityAppliedMessage;
|
|
EncryptedData encryptedData;
|
|
HashStream hashStream;
|
|
switch (message.BodyProtectionMode)
|
|
{
|
|
case MessagePartProtectionMode.None:
|
|
return;
|
|
case MessagePartProtectionMode.Sign:
|
|
hashStream = TakeHashStream();
|
|
if (CanCanonicalizeAndFragment(writer))
|
|
{
|
|
message.WriteBodyToSignWithFragments(hashStream, false, null, writer);
|
|
}
|
|
else
|
|
{
|
|
message.WriteBodyToSign(hashStream);
|
|
}
|
|
this.signedInfo.AddReference(message.BodyId, hashStream.FlushHashAndGetValue());
|
|
return;
|
|
case MessagePartProtectionMode.SignThenEncrypt:
|
|
hashStream = TakeHashStream();
|
|
encryptedData = CreateEncryptedDataForBody();
|
|
if (CanCanonicalizeAndFragment(writer))
|
|
{
|
|
message.WriteBodyToSignThenEncryptWithFragments(hashStream, false, null, encryptedData, this.encryptingSymmetricAlgorithm, writer);
|
|
}
|
|
else
|
|
{
|
|
message.WriteBodyToSignThenEncrypt(hashStream, encryptedData, this.encryptingSymmetricAlgorithm);
|
|
}
|
|
this.signedInfo.AddReference(message.BodyId, hashStream.FlushHashAndGetValue());
|
|
this.referenceList.AddReferredId(encryptedData.Id);
|
|
this.hasSignedEncryptedMessagePart = true;
|
|
return;
|
|
case MessagePartProtectionMode.Encrypt:
|
|
encryptedData = CreateEncryptedDataForBody();
|
|
message.WriteBodyToEncrypt(encryptedData, this.encryptingSymmetricAlgorithm);
|
|
this.referenceList.AddReferredId(encryptedData.Id);
|
|
return;
|
|
case MessagePartProtectionMode.EncryptThenSign:
|
|
hashStream = TakeHashStream();
|
|
encryptedData = CreateEncryptedDataForBody();
|
|
message.WriteBodyToEncryptThenSign(hashStream, encryptedData, this.encryptingSymmetricAlgorithm);
|
|
this.signedInfo.AddReference(message.BodyId, hashStream.FlushHashAndGetValue());
|
|
this.referenceList.AddReferredId(encryptedData.Id);
|
|
return;
|
|
default:
|
|
Fx.Assert("Invalid MessagePartProtectionMode");
|
|
return;
|
|
}
|
|
}
|
|
|
|
protected static MemoryStream CaptureToken(SecurityToken token, SecurityStandardsManager serializer)
|
|
{
|
|
MemoryStream stream = new MemoryStream();
|
|
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream);
|
|
serializer.SecurityTokenSerializer.WriteToken(writer, token);
|
|
writer.Flush();
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return stream;
|
|
}
|
|
|
|
protected static MemoryStream CaptureSecurityElement(ISecurityElement element)
|
|
{
|
|
MemoryStream stream = new MemoryStream();
|
|
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream);
|
|
element.WriteTo(writer, ServiceModelDictionaryManager.Instance);
|
|
writer.Flush();
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
return stream;
|
|
}
|
|
|
|
protected override ISecurityElement CompleteEncryptionCore(
|
|
SendSecurityHeaderElement primarySignature,
|
|
SendSecurityHeaderElement[] basicTokens,
|
|
SendSecurityHeaderElement[] signatureConfirmations,
|
|
SendSecurityHeaderElement[] endorsingSignatures)
|
|
{
|
|
if (this.referenceList == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (primarySignature != null && primarySignature.Item != null && primarySignature.MarkedForEncryption)
|
|
{
|
|
EncryptElement(primarySignature);
|
|
}
|
|
|
|
if (basicTokens != null)
|
|
{
|
|
for (int i = 0; i < basicTokens.Length; ++i)
|
|
{
|
|
if (basicTokens[i].MarkedForEncryption)
|
|
EncryptElement(basicTokens[i]);
|
|
}
|
|
}
|
|
|
|
if (signatureConfirmations != null)
|
|
{
|
|
for (int i = 0; i < signatureConfirmations.Length; ++i)
|
|
{
|
|
if (signatureConfirmations[i].MarkedForEncryption)
|
|
EncryptElement(signatureConfirmations[i]);
|
|
}
|
|
}
|
|
|
|
if (endorsingSignatures != null)
|
|
{
|
|
for (int i = 0; i < endorsingSignatures.Length; ++i)
|
|
{
|
|
if (endorsingSignatures[i].MarkedForEncryption)
|
|
EncryptElement(endorsingSignatures[i]);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
return this.referenceList.DataReferenceCount > 0 ? this.referenceList : null;
|
|
}
|
|
finally
|
|
{
|
|
this.referenceList = null;
|
|
this.encryptingSymmetricAlgorithm = null;
|
|
this.encryptionKeyIdentifier = null;
|
|
}
|
|
}
|
|
|
|
protected override ISignatureValueSecurityElement CompletePrimarySignatureCore(
|
|
SendSecurityHeaderElement[] signatureConfirmations,
|
|
SecurityToken[] signedEndorsingTokens,
|
|
SecurityToken[] signedTokens,
|
|
SendSecurityHeaderElement[] basicTokens, bool isPrimarySignature)
|
|
{
|
|
if (this.signedXml == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
SecurityTimestamp timestamp = this.Timestamp;
|
|
if (timestamp != null)
|
|
{
|
|
if (timestamp.Id == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.TimestampToSignHasNoId)));
|
|
}
|
|
HashStream hashStream = TakeHashStream();
|
|
this.StandardsManager.WSUtilitySpecificationVersion.WriteTimestampCanonicalForm(
|
|
hashStream, timestamp, this.signedInfo.ResourcePool.TakeEncodingBuffer());
|
|
signedInfo.AddReference(timestamp.Id, hashStream.FlushHashAndGetValue());
|
|
}
|
|
|
|
if ((this.ShouldSignToHeader) && (this.signatureKey is AsymmetricSecurityKey) && (this.Version.Addressing != AddressingVersion.None))
|
|
{
|
|
if (this.toHeaderHash != null)
|
|
signedInfo.AddReference(this.toHeaderId, this.toHeaderHash);
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.TransportSecurityRequireToHeader)));
|
|
}
|
|
|
|
AddSignatureReference(signatureConfirmations);
|
|
if (isPrimarySignature && this.ShouldProtectTokens)
|
|
{
|
|
AddPrimaryTokenSignatureReference(this.ElementContainer.SourceSigningToken, this.SigningTokenParameters);
|
|
}
|
|
|
|
if (this.RequireMessageProtection)
|
|
{
|
|
AddSignatureReference(signedEndorsingTokens, SecurityTokenAttachmentMode.SignedEndorsing);
|
|
AddSignatureReference(signedTokens, SecurityTokenAttachmentMode.Signed);
|
|
AddSignatureReference(basicTokens);
|
|
}
|
|
|
|
if (this.signedInfo.ReferenceCount == 0)
|
|
{
|
|
throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.NoPartsOfMessageMatchedPartsToSign)), this.Message);
|
|
}
|
|
try
|
|
{
|
|
this.signedXml.ComputeSignature(this.signatureKey);
|
|
return this.signedXml;
|
|
}
|
|
finally
|
|
{
|
|
this.hashStream = null;
|
|
this.signedInfo = null;
|
|
this.signedXml = null;
|
|
this.signatureKey = null;
|
|
this.effectiveSignatureParts = null;
|
|
}
|
|
}
|
|
|
|
EncryptedData CreateEncryptedData()
|
|
{
|
|
EncryptedData encryptedData = new EncryptedData();
|
|
encryptedData.SecurityTokenSerializer = this.StandardsManager.SecurityTokenSerializer;
|
|
encryptedData.KeyIdentifier = this.encryptionKeyIdentifier;
|
|
encryptedData.EncryptionMethod = this.EncryptionAlgorithm;
|
|
encryptedData.EncryptionMethodDictionaryString = this.EncryptionAlgorithmDictionaryString;
|
|
return encryptedData;
|
|
}
|
|
|
|
EncryptedData CreateEncryptedData(MemoryStream stream, string id, bool typeElement)
|
|
{
|
|
EncryptedData encryptedData = CreateEncryptedData();
|
|
encryptedData.Id = id;
|
|
encryptedData.SetUpEncryption(this.encryptingSymmetricAlgorithm, new ArraySegment<byte>(stream.GetBuffer(), 0, (int) stream.Length));
|
|
if (typeElement)
|
|
{
|
|
encryptedData.Type = EncryptedData.ElementType;
|
|
}
|
|
return encryptedData;
|
|
}
|
|
|
|
EncryptedData CreateEncryptedDataForBody()
|
|
{
|
|
EncryptedData encryptedData = CreateEncryptedData();
|
|
encryptedData.Type = EncryptedData.ContentType;
|
|
return encryptedData;
|
|
}
|
|
|
|
void EncryptAndWriteHeader(MessageHeader plainTextHeader, string id, MemoryStream stream, XmlDictionaryWriter writer)
|
|
{
|
|
EncryptedHeader encryptedHeader = EncryptHeader(
|
|
plainTextHeader,
|
|
this.encryptingSymmetricAlgorithm, this.encryptionKeyIdentifier, this.Version,
|
|
id, stream);
|
|
encryptedHeader.WriteHeader(writer, this.Version);
|
|
}
|
|
|
|
void EncryptElement(SendSecurityHeaderElement element)
|
|
{
|
|
string id = GenerateId();
|
|
ISecurityElement encryptedElement = CreateEncryptedData(CaptureSecurityElement(element.Item), id, true);
|
|
this.referenceList.AddReferredId(id);
|
|
element.Replace(id, encryptedElement);
|
|
}
|
|
|
|
protected virtual EncryptedHeader EncryptHeader(MessageHeader plainTextHeader, SymmetricAlgorithm algorithm,
|
|
SecurityKeyIdentifier keyIdentifier, MessageVersion version, string id, MemoryStream stream)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR.GetString(SR.HeaderEncryptionNotSupportedInWsSecurityJan2004, plainTextHeader.Name, plainTextHeader.Namespace)));
|
|
}
|
|
|
|
HashStream TakeHashStream()
|
|
{
|
|
HashStream hashStream = null;
|
|
if (this.hashStream == null)
|
|
{
|
|
this.hashStream = hashStream = new HashStream(CryptoHelper.CreateHashAlgorithm(this.AlgorithmSuite.DefaultDigestAlgorithm));
|
|
}
|
|
else
|
|
{
|
|
hashStream = this.hashStream;;
|
|
hashStream.Reset();
|
|
}
|
|
return hashStream;
|
|
}
|
|
|
|
XmlDictionaryWriter TakeUtf8Writer()
|
|
{
|
|
return this.signedInfo.ResourcePool.TakeUtf8Writer();
|
|
}
|
|
|
|
MessagePartProtectionMode GetProtectionMode(MessageHeader header)
|
|
{
|
|
if (!this.RequireMessageProtection)
|
|
{
|
|
return MessagePartProtectionMode.None;
|
|
}
|
|
bool sign = this.signedInfo != null && this.effectiveSignatureParts.IsHeaderIncluded(header);
|
|
bool encrypt = this.referenceList != null && this.EncryptionParts.IsHeaderIncluded(header);
|
|
return MessagePartProtectionModeHelper.GetProtectionMode(sign, encrypt, this.SignThenEncrypt);
|
|
}
|
|
|
|
protected override void StartEncryptionCore(SecurityToken token, SecurityKeyIdentifier keyIdentifier)
|
|
{
|
|
this.encryptingSymmetricAlgorithm = SecurityUtils.GetSymmetricAlgorithm(this.EncryptionAlgorithm, token);
|
|
if (this.encryptingSymmetricAlgorithm == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(
|
|
SR.GetString(SR.UnableToCreateSymmetricAlgorithmFromToken, this.EncryptionAlgorithm)));
|
|
}
|
|
this.encryptionKeyIdentifier = keyIdentifier;
|
|
this.referenceList = new ReferenceList();
|
|
}
|
|
|
|
protected override void StartPrimarySignatureCore(SecurityToken token,
|
|
SecurityKeyIdentifier keyIdentifier,
|
|
MessagePartSpecification signatureParts,
|
|
bool generateTargettableSignature)
|
|
{
|
|
SecurityAlgorithmSuite suite = this.AlgorithmSuite;
|
|
string canonicalizationAlgorithm = suite.DefaultCanonicalizationAlgorithm;
|
|
XmlDictionaryString canonicalizationAlgorithmDictionaryString = suite.DefaultCanonicalizationAlgorithmDictionaryString;
|
|
if (canonicalizationAlgorithm != SecurityAlgorithms.ExclusiveC14n)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new MessageSecurityException(SR.GetString(SR.UnsupportedCanonicalizationAlgorithm, suite.DefaultCanonicalizationAlgorithm)));
|
|
}
|
|
string signatureAlgorithm;
|
|
XmlDictionaryString signatureAlgorithmDictionaryString;
|
|
suite.GetSignatureAlgorithmAndKey(token, out signatureAlgorithm, out this.signatureKey, out signatureAlgorithmDictionaryString);
|
|
string digestAlgorithm = suite.DefaultDigestAlgorithm;
|
|
XmlDictionaryString digestAlgorithmDictionaryString = suite.DefaultDigestAlgorithmDictionaryString;
|
|
this.signedInfo = new PreDigestedSignedInfo(ServiceModelDictionaryManager.Instance, canonicalizationAlgorithm, canonicalizationAlgorithmDictionaryString, digestAlgorithm, digestAlgorithmDictionaryString, signatureAlgorithm, signatureAlgorithmDictionaryString);
|
|
this.signedXml = new SignedXml(this.signedInfo, ServiceModelDictionaryManager.Instance, this.StandardsManager.SecurityTokenSerializer);
|
|
if (keyIdentifier != null)
|
|
{
|
|
this.signedXml.Signature.KeyIdentifier = keyIdentifier;
|
|
}
|
|
if (generateTargettableSignature)
|
|
{
|
|
this.signedXml.Id = GenerateId();
|
|
}
|
|
this.effectiveSignatureParts = signatureParts;
|
|
this.hashStream = this.signedInfo.ResourcePool.TakeHashStream(digestAlgorithm);
|
|
}
|
|
|
|
protected override ISignatureValueSecurityElement CreateSupportingSignature(SecurityToken token, SecurityKeyIdentifier identifier)
|
|
{
|
|
StartPrimarySignatureCore(token, identifier, MessagePartSpecification.NoParts, false);
|
|
return CompletePrimarySignatureCore(null, null, null, null, false);
|
|
}
|
|
|
|
protected override ISignatureValueSecurityElement CreateSupportingSignature(SecurityToken token, SecurityKeyIdentifier identifier, ISecurityElement elementToSign)
|
|
{
|
|
SecurityAlgorithmSuite algorithmSuite = this.AlgorithmSuite;
|
|
string signatureAlgorithm;
|
|
XmlDictionaryString signatureAlgorithmDictionaryString;
|
|
SecurityKey signatureKey;
|
|
algorithmSuite.GetSignatureAlgorithmAndKey(token, out signatureAlgorithm, out signatureKey, out signatureAlgorithmDictionaryString);
|
|
SignedXml signedXml = new SignedXml(ServiceModelDictionaryManager.Instance, this.StandardsManager.SecurityTokenSerializer);
|
|
SignedInfo signedInfo = signedXml.Signature.SignedInfo;
|
|
signedInfo.CanonicalizationMethod = algorithmSuite.DefaultCanonicalizationAlgorithm;
|
|
signedInfo.CanonicalizationMethodDictionaryString = algorithmSuite.DefaultCanonicalizationAlgorithmDictionaryString;
|
|
signedInfo.SignatureMethod = signatureAlgorithm;
|
|
signedInfo.SignatureMethodDictionaryString = signatureAlgorithmDictionaryString;
|
|
|
|
if (elementToSign.Id == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ElementToSignMustHaveId)));
|
|
}
|
|
Reference reference = new Reference(ServiceModelDictionaryManager.Instance, "#" + elementToSign.Id, elementToSign);
|
|
reference.DigestMethod = algorithmSuite.DefaultDigestAlgorithm;
|
|
reference.DigestMethodDictionaryString = algorithmSuite.DefaultDigestAlgorithmDictionaryString;
|
|
reference.AddTransform(new ExclusiveCanonicalizationTransform());
|
|
((StandardSignedInfo)signedInfo).AddReference(reference);
|
|
|
|
signedXml.ComputeSignature(signatureKey);
|
|
if (identifier != null)
|
|
{
|
|
signedXml.Signature.KeyIdentifier = identifier;
|
|
}
|
|
return signedXml;
|
|
}
|
|
|
|
protected override void WriteSecurityTokenReferencyEntry(XmlDictionaryWriter writer, SecurityToken securityToken, SecurityTokenParameters securityTokenParameters)
|
|
{
|
|
SecurityKeyIdentifierClause keyIdentifierClause = null;
|
|
|
|
// Given a token this method writes its corresponding security token reference entry in the security header
|
|
// 1. If the token parameters is an issuedSecurityTokenParamter
|
|
// 2. If UseStrTransform is enabled on it.
|
|
|
|
IssuedSecurityTokenParameters issuedSecurityTokenParameters = securityTokenParameters as IssuedSecurityTokenParameters;
|
|
if (issuedSecurityTokenParameters == null || !issuedSecurityTokenParameters.UseStrTransform)
|
|
return;
|
|
|
|
if (this.ElementContainer.TryGetIdentifierClauseFromSecurityToken(securityToken, out keyIdentifierClause))
|
|
{
|
|
if (keyIdentifierClause != null && !String.IsNullOrEmpty(keyIdentifierClause.Id))
|
|
{
|
|
WrappedXmlDictionaryWriter wrappedLocalWriter = new WrappedXmlDictionaryWriter(writer, keyIdentifierClause.Id);
|
|
this.StandardsManager.SecurityTokenSerializer.WriteKeyIdentifierClause(wrappedLocalWriter, keyIdentifierClause);
|
|
}
|
|
else
|
|
throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.TokenManagerCannotCreateTokenReference)), this.Message);
|
|
}
|
|
}
|
|
}
|
|
|
|
class WrappedXmlDictionaryWriter : XmlDictionaryWriter
|
|
{
|
|
XmlDictionaryWriter innerWriter;
|
|
int index;
|
|
bool insertId;
|
|
bool isStrReferenceElement;
|
|
string id;
|
|
|
|
public WrappedXmlDictionaryWriter(XmlDictionaryWriter writer, string id)
|
|
{
|
|
this.innerWriter = writer;
|
|
this.index = 0;
|
|
this.insertId = false;
|
|
this.isStrReferenceElement = false;
|
|
this.id = id;
|
|
}
|
|
|
|
public override void WriteStartAttribute(string prefix, string localName, string namespaceUri)
|
|
{
|
|
if (isStrReferenceElement && this.insertId && localName == XD.UtilityDictionary.IdAttribute.Value)
|
|
{
|
|
// This means the serializer is already writing the Id out, so we don't write it again.
|
|
this.insertId = false;
|
|
}
|
|
this.innerWriter.WriteStartAttribute(prefix, localName, namespaceUri);
|
|
}
|
|
|
|
public override void WriteStartElement(string prefix, string localName, string namespaceUri)
|
|
{
|
|
if (isStrReferenceElement && this.insertId)
|
|
{
|
|
if (id != null)
|
|
{
|
|
this.innerWriter.WriteAttributeString(XD.UtilityDictionary.Prefix.Value, XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace, id);
|
|
}
|
|
|
|
isStrReferenceElement = false;
|
|
this.insertId = false;
|
|
}
|
|
|
|
index++;
|
|
|
|
if (index == 1 && localName == XD.SecurityJan2004Dictionary.SecurityTokenReference.Value)
|
|
{
|
|
this.insertId = true;
|
|
isStrReferenceElement = true;
|
|
}
|
|
|
|
this.innerWriter.WriteStartElement(prefix, localName, namespaceUri);
|
|
}
|
|
|
|
// Below methods simply call into innerWritter
|
|
public override void Close()
|
|
{
|
|
this.innerWriter.Close();
|
|
}
|
|
|
|
public override void Flush()
|
|
{
|
|
this.innerWriter.Flush();
|
|
}
|
|
|
|
public override string LookupPrefix(string ns)
|
|
{
|
|
return this.innerWriter.LookupPrefix(ns);
|
|
}
|
|
|
|
public override void WriteBase64(byte[] buffer, int index, int count)
|
|
{
|
|
this.innerWriter.WriteBase64(buffer, index, count);
|
|
}
|
|
|
|
public override void WriteCData(string text)
|
|
{
|
|
this.innerWriter.WriteCData(text);
|
|
}
|
|
|
|
public override void WriteCharEntity(char ch)
|
|
{
|
|
this.innerWriter.WriteCharEntity(ch);
|
|
}
|
|
|
|
public override void WriteChars(char[] buffer, int index, int count)
|
|
{
|
|
this.innerWriter.WriteChars(buffer, index, count);
|
|
}
|
|
|
|
public override void WriteComment(string text)
|
|
{
|
|
this.innerWriter.WriteComment(text);
|
|
}
|
|
|
|
public override void WriteDocType(string name, string pubid, string sysid, string subset)
|
|
{
|
|
this.innerWriter.WriteDocType(name, pubid, sysid, subset);
|
|
}
|
|
|
|
public override void WriteEndAttribute()
|
|
{
|
|
this.innerWriter.WriteEndAttribute();
|
|
}
|
|
|
|
public override void WriteEndDocument()
|
|
{
|
|
this.innerWriter.WriteEndDocument();
|
|
}
|
|
|
|
public override void WriteEndElement()
|
|
{
|
|
this.innerWriter.WriteEndElement();
|
|
}
|
|
|
|
public override void WriteEntityRef(string name)
|
|
{
|
|
this.innerWriter.WriteEntityRef(name);
|
|
}
|
|
|
|
public override void WriteFullEndElement()
|
|
{
|
|
this.innerWriter.WriteFullEndElement();
|
|
}
|
|
|
|
public override void WriteProcessingInstruction(string name, string text)
|
|
{
|
|
this.innerWriter.WriteProcessingInstruction(name, text);
|
|
}
|
|
|
|
public override void WriteRaw(string data)
|
|
{
|
|
this.innerWriter.WriteRaw(data);
|
|
}
|
|
|
|
public override void WriteRaw(char[] buffer, int index, int count)
|
|
{
|
|
this.innerWriter.WriteRaw(buffer, index, count);
|
|
}
|
|
|
|
public override void WriteStartDocument(bool standalone)
|
|
{
|
|
this.innerWriter.WriteStartDocument(standalone);
|
|
}
|
|
|
|
public override void WriteStartDocument()
|
|
{
|
|
this.innerWriter.WriteStartDocument();
|
|
}
|
|
|
|
public override WriteState WriteState
|
|
{
|
|
get { return this.innerWriter.WriteState; }
|
|
}
|
|
|
|
public override void WriteString(string text)
|
|
{
|
|
this.innerWriter.WriteString(text);
|
|
}
|
|
|
|
public override void WriteSurrogateCharEntity(char lowChar, char highChar)
|
|
{
|
|
this.innerWriter.WriteSurrogateCharEntity(lowChar, highChar);
|
|
}
|
|
|
|
public override void WriteWhitespace(string ws)
|
|
{
|
|
this.innerWriter.WriteWhitespace(ws);
|
|
}
|
|
}
|
|
}
|