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
457 lines
18 KiB
C#
457 lines
18 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Security
|
|
{
|
|
using System.IO;
|
|
using System.Runtime;
|
|
using System.Security.Cryptography;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Security.Tokens;
|
|
using System.Xml;
|
|
using System.IdentityModel.Tokens;
|
|
using System.Collections.Generic;
|
|
using IPrefixGenerator = System.IdentityModel.IPrefixGenerator;
|
|
using ISecurityElement = System.IdentityModel.ISecurityElement;
|
|
using XmlAttributeHolder = System.IdentityModel.XmlAttributeHolder;
|
|
|
|
sealed class SecurityAppliedMessage : DelegatingMessage
|
|
{
|
|
string bodyId;
|
|
bool bodyIdInserted;
|
|
string bodyPrefix = MessageStrings.Prefix;
|
|
XmlBuffer fullBodyBuffer;
|
|
ISecurityElement encryptedBodyContent;
|
|
XmlAttributeHolder[] bodyAttributes;
|
|
bool delayedApplicationHandled;
|
|
readonly MessagePartProtectionMode bodyProtectionMode;
|
|
BodyState state = BodyState.Created;
|
|
readonly SendSecurityHeader securityHeader;
|
|
MemoryStream startBodyFragment;
|
|
MemoryStream endBodyFragment;
|
|
byte[] fullBodyFragment;
|
|
int fullBodyFragmentLength;
|
|
|
|
public SecurityAppliedMessage(Message messageToProcess, SendSecurityHeader securityHeader, bool signBody, bool encryptBody)
|
|
: base(messageToProcess)
|
|
{
|
|
Fx.Assert(!(messageToProcess is SecurityAppliedMessage), "SecurityAppliedMessage should not be wrapped");
|
|
this.securityHeader = securityHeader;
|
|
this.bodyProtectionMode = MessagePartProtectionModeHelper.GetProtectionMode(signBody, encryptBody, securityHeader.SignThenEncrypt);
|
|
}
|
|
|
|
public string BodyId
|
|
{
|
|
get { return this.bodyId; }
|
|
}
|
|
|
|
public MessagePartProtectionMode BodyProtectionMode
|
|
{
|
|
get { return this.bodyProtectionMode; }
|
|
}
|
|
|
|
internal byte[] PrimarySignatureValue
|
|
{
|
|
get { return this.securityHeader.PrimarySignatureValue; }
|
|
}
|
|
|
|
Exception CreateBadStateException(string operation)
|
|
{
|
|
return new InvalidOperationException(SR.GetString(SR.MessageBodyOperationNotValidInBodyState,
|
|
operation, this.state));
|
|
}
|
|
|
|
void EnsureUniqueSecurityApplication()
|
|
{
|
|
if (this.delayedApplicationHandled)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.DelayedSecurityApplicationAlreadyCompleted)));
|
|
}
|
|
this.delayedApplicationHandled = true;
|
|
}
|
|
|
|
protected override void OnBodyToString(XmlDictionaryWriter writer)
|
|
{
|
|
if (this.state == BodyState.Created || this.fullBodyFragment != null)
|
|
{
|
|
base.OnBodyToString(writer);
|
|
}
|
|
else
|
|
{
|
|
OnWriteBodyContents(writer);
|
|
}
|
|
}
|
|
|
|
protected override void OnClose()
|
|
{
|
|
try
|
|
{
|
|
this.InnerMessage.Close();
|
|
}
|
|
finally
|
|
{
|
|
this.fullBodyBuffer = null;
|
|
this.bodyAttributes = null;
|
|
this.encryptedBodyContent = null;
|
|
this.state = BodyState.Disposed;
|
|
}
|
|
}
|
|
|
|
protected override void OnWriteStartBody(XmlDictionaryWriter writer)
|
|
{
|
|
if (this.startBodyFragment != null || this.fullBodyFragment != null)
|
|
{
|
|
WriteStartInnerMessageWithId(writer);
|
|
return;
|
|
}
|
|
|
|
switch (this.state)
|
|
{
|
|
case BodyState.Created:
|
|
case BodyState.Encrypted:
|
|
this.InnerMessage.WriteStartBody(writer);
|
|
return;
|
|
case BodyState.Signed:
|
|
case BodyState.EncryptedThenSigned:
|
|
XmlDictionaryReader reader = fullBodyBuffer.GetReader(0);
|
|
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
|
|
writer.WriteAttributes(reader, false);
|
|
reader.Close();
|
|
return;
|
|
case BodyState.SignedThenEncrypted:
|
|
writer.WriteStartElement(this.bodyPrefix, XD.MessageDictionary.Body, this.Version.Envelope.DictionaryNamespace);
|
|
if (this.bodyAttributes != null)
|
|
{
|
|
XmlAttributeHolder.WriteAttributes(this.bodyAttributes, writer);
|
|
}
|
|
return;
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBadStateException("OnWriteStartBody"));
|
|
}
|
|
}
|
|
|
|
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
|
|
{
|
|
switch (this.state)
|
|
{
|
|
case BodyState.Created:
|
|
this.InnerMessage.WriteBodyContents(writer);
|
|
return;
|
|
case BodyState.Signed:
|
|
case BodyState.EncryptedThenSigned:
|
|
XmlDictionaryReader reader = fullBodyBuffer.GetReader(0);
|
|
reader.ReadStartElement();
|
|
while (reader.NodeType != XmlNodeType.EndElement)
|
|
writer.WriteNode(reader, false);
|
|
reader.ReadEndElement();
|
|
reader.Close();
|
|
return;
|
|
case BodyState.Encrypted:
|
|
case BodyState.SignedThenEncrypted:
|
|
this.encryptedBodyContent.WriteTo(writer, ServiceModelDictionaryManager.Instance);
|
|
break;
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBadStateException("OnWriteBodyContents"));
|
|
}
|
|
}
|
|
|
|
protected override void OnWriteMessage(XmlDictionaryWriter writer)
|
|
{
|
|
// For Kerb one shot, the channel binding will be need to be fished out of the message, cached and added to the
|
|
// token before calling ISC.
|
|
|
|
AttachChannelBindingTokenIfFound();
|
|
|
|
EnsureUniqueSecurityApplication();
|
|
|
|
MessagePrefixGenerator prefixGenerator = new MessagePrefixGenerator(writer);
|
|
this.securityHeader.StartSecurityApplication();
|
|
|
|
this.Headers.Add(this.securityHeader);
|
|
|
|
this.InnerMessage.WriteStartEnvelope(writer);
|
|
|
|
this.Headers.RemoveAt(this.Headers.Count - 1);
|
|
|
|
this.securityHeader.ApplyBodySecurity(writer, prefixGenerator);
|
|
|
|
this.InnerMessage.WriteStartHeaders(writer);
|
|
this.securityHeader.ApplySecurityAndWriteHeaders(this.Headers, writer, prefixGenerator);
|
|
|
|
this.securityHeader.RemoveSignatureEncryptionIfAppropriate();
|
|
|
|
this.securityHeader.CompleteSecurityApplication();
|
|
this.securityHeader.WriteHeader(writer, this.Version);
|
|
writer.WriteEndElement();
|
|
|
|
if (this.fullBodyFragment != null)
|
|
{
|
|
((IFragmentCapableXmlDictionaryWriter) writer).WriteFragment(this.fullBodyFragment, 0, this.fullBodyFragmentLength);
|
|
}
|
|
else
|
|
{
|
|
if (this.startBodyFragment != null)
|
|
{
|
|
((IFragmentCapableXmlDictionaryWriter) writer).WriteFragment(this.startBodyFragment.GetBuffer(), 0, (int) this.startBodyFragment.Length);
|
|
}
|
|
else
|
|
{
|
|
OnWriteStartBody(writer);
|
|
}
|
|
|
|
OnWriteBodyContents(writer);
|
|
|
|
if (this.endBodyFragment != null)
|
|
{
|
|
((IFragmentCapableXmlDictionaryWriter) writer).WriteFragment(this.endBodyFragment.GetBuffer(), 0, (int) this.endBodyFragment.Length);
|
|
}
|
|
else
|
|
{
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
void AttachChannelBindingTokenIfFound()
|
|
{
|
|
ChannelBindingMessageProperty cbmp = null;
|
|
ChannelBindingMessageProperty.TryGet(this.InnerMessage, out cbmp);
|
|
|
|
if (cbmp != null)
|
|
{
|
|
if (this.securityHeader.ElementContainer != null && this.securityHeader.ElementContainer.EndorsingSupportingTokens != null)
|
|
{
|
|
foreach (SecurityToken token in this.securityHeader.ElementContainer.EndorsingSupportingTokens)
|
|
{
|
|
ProviderBackedSecurityToken pbst = token as ProviderBackedSecurityToken;
|
|
if (pbst != null)
|
|
{
|
|
pbst.ChannelBinding = cbmp.ChannelBinding;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetBodyId()
|
|
{
|
|
this.bodyId = this.InnerMessage.GetBodyAttribute(
|
|
UtilityStrings.IdAttribute,
|
|
this.securityHeader.StandardsManager.IdManager.DefaultIdNamespaceUri);
|
|
if (this.bodyId == null)
|
|
{
|
|
this.bodyId = this.securityHeader.GenerateId();
|
|
this.bodyIdInserted = true;
|
|
}
|
|
}
|
|
|
|
public void WriteBodyToEncrypt(EncryptedData encryptedData, SymmetricAlgorithm algorithm)
|
|
{
|
|
encryptedData.Id = this.securityHeader.GenerateId();
|
|
|
|
BodyContentHelper helper = new BodyContentHelper();
|
|
XmlDictionaryWriter encryptingWriter = helper.CreateWriter();
|
|
this.InnerMessage.WriteBodyContents(encryptingWriter);
|
|
encryptedData.SetUpEncryption(algorithm, helper.ExtractResult());
|
|
this.encryptedBodyContent = encryptedData;
|
|
|
|
this.state = BodyState.Encrypted;
|
|
}
|
|
|
|
public void WriteBodyToEncryptThenSign(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm)
|
|
{
|
|
encryptedData.Id = this.securityHeader.GenerateId();
|
|
SetBodyId();
|
|
|
|
XmlDictionaryWriter encryptingWriter = XmlDictionaryWriter.CreateTextWriter(Stream.Null);
|
|
// The XmlSerializer body formatter would add a
|
|
// document declaration to the body fragment when a fresh writer
|
|
// is provided. Hence, insert a dummy element here and capture
|
|
// the body contents as a fragment.
|
|
encryptingWriter.WriteStartElement("a");
|
|
MemoryStream ms = new MemoryStream();
|
|
((IFragmentCapableXmlDictionaryWriter)encryptingWriter).StartFragment(ms, true);
|
|
|
|
this.InnerMessage.WriteBodyContents(encryptingWriter);
|
|
((IFragmentCapableXmlDictionaryWriter)encryptingWriter).EndFragment();
|
|
encryptingWriter.WriteEndElement();
|
|
ms.Flush();
|
|
encryptedData.SetUpEncryption(algorithm, new ArraySegment<byte>(ms.GetBuffer(), 0, (int) ms.Length));
|
|
|
|
this.fullBodyBuffer = new XmlBuffer(int.MaxValue);
|
|
XmlDictionaryWriter canonicalWriter = this.fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
|
|
|
|
canonicalWriter.StartCanonicalization(canonicalStream, false, null);
|
|
WriteStartInnerMessageWithId(canonicalWriter);
|
|
encryptedData.WriteTo(canonicalWriter, ServiceModelDictionaryManager.Instance);
|
|
canonicalWriter.WriteEndElement();
|
|
canonicalWriter.EndCanonicalization();
|
|
canonicalWriter.Flush();
|
|
|
|
this.fullBodyBuffer.CloseSection();
|
|
this.fullBodyBuffer.Close();
|
|
|
|
this.state = BodyState.EncryptedThenSigned;
|
|
}
|
|
|
|
public void WriteBodyToSign(Stream canonicalStream)
|
|
{
|
|
SetBodyId();
|
|
|
|
this.fullBodyBuffer = new XmlBuffer(int.MaxValue);
|
|
XmlDictionaryWriter canonicalWriter = this.fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
|
|
canonicalWriter.StartCanonicalization(canonicalStream, false, null);
|
|
WriteInnerMessageWithId(canonicalWriter);
|
|
canonicalWriter.EndCanonicalization();
|
|
canonicalWriter.Flush();
|
|
this.fullBodyBuffer.CloseSection();
|
|
this.fullBodyBuffer.Close();
|
|
|
|
this.state = BodyState.Signed;
|
|
}
|
|
|
|
public void WriteBodyToSignThenEncrypt(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm)
|
|
{
|
|
XmlBuffer buffer = new XmlBuffer(int.MaxValue);
|
|
XmlDictionaryWriter fragmentingWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
|
|
WriteBodyToSignThenEncryptWithFragments(canonicalStream, false, null, encryptedData, algorithm, fragmentingWriter);
|
|
((IFragmentCapableXmlDictionaryWriter)fragmentingWriter).WriteFragment(this.startBodyFragment.GetBuffer(), 0, (int)this.startBodyFragment.Length);
|
|
((IFragmentCapableXmlDictionaryWriter)fragmentingWriter).WriteFragment(this.endBodyFragment.GetBuffer(), 0, (int)this.endBodyFragment.Length);
|
|
buffer.CloseSection();
|
|
buffer.Close();
|
|
|
|
this.startBodyFragment = null;
|
|
this.endBodyFragment = null;
|
|
|
|
XmlDictionaryReader reader = buffer.GetReader(0);
|
|
reader.MoveToContent();
|
|
this.bodyPrefix = reader.Prefix;
|
|
if (reader.HasAttributes)
|
|
{
|
|
this.bodyAttributes = XmlAttributeHolder.ReadAttributes(reader);
|
|
}
|
|
reader.Close();
|
|
}
|
|
|
|
public void WriteBodyToSignThenEncryptWithFragments(
|
|
Stream stream, bool includeComments, string[] inclusivePrefixes,
|
|
EncryptedData encryptedData, SymmetricAlgorithm algorithm, XmlDictionaryWriter writer)
|
|
{
|
|
IFragmentCapableXmlDictionaryWriter fragmentingWriter = (IFragmentCapableXmlDictionaryWriter) writer;
|
|
|
|
SetBodyId();
|
|
encryptedData.Id = this.securityHeader.GenerateId();
|
|
|
|
this.startBodyFragment = new MemoryStream();
|
|
BufferedOutputStream bodyContentFragment = new BufferManagerOutputStream(SR.XmlBufferQuotaExceeded, 1024, int.MaxValue, this.securityHeader.StreamBufferManager);
|
|
this.endBodyFragment = new MemoryStream();
|
|
|
|
writer.StartCanonicalization(stream, includeComments, inclusivePrefixes);
|
|
|
|
fragmentingWriter.StartFragment(this.startBodyFragment, false);
|
|
WriteStartInnerMessageWithId(writer);
|
|
fragmentingWriter.EndFragment();
|
|
|
|
fragmentingWriter.StartFragment(bodyContentFragment, true);
|
|
this.InnerMessage.WriteBodyContents(writer);
|
|
fragmentingWriter.EndFragment();
|
|
|
|
fragmentingWriter.StartFragment(this.endBodyFragment, false);
|
|
writer.WriteEndElement();
|
|
fragmentingWriter.EndFragment();
|
|
|
|
writer.EndCanonicalization();
|
|
|
|
int bodyLength;
|
|
byte[] bodyBuffer = bodyContentFragment.ToArray(out bodyLength);
|
|
|
|
encryptedData.SetUpEncryption(algorithm, new ArraySegment<byte>(bodyBuffer, 0, bodyLength));
|
|
this.encryptedBodyContent = encryptedData;
|
|
|
|
this.state = BodyState.SignedThenEncrypted;
|
|
}
|
|
|
|
public void WriteBodyToSignWithFragments(Stream stream, bool includeComments, string[] inclusivePrefixes, XmlDictionaryWriter writer)
|
|
{
|
|
IFragmentCapableXmlDictionaryWriter fragmentingWriter = (IFragmentCapableXmlDictionaryWriter) writer;
|
|
|
|
SetBodyId();
|
|
BufferedOutputStream fullBodyFragment = new BufferManagerOutputStream(SR.XmlBufferQuotaExceeded, 1024, int.MaxValue, this.securityHeader.StreamBufferManager);
|
|
writer.StartCanonicalization(stream, includeComments, inclusivePrefixes);
|
|
fragmentingWriter.StartFragment(fullBodyFragment, false);
|
|
WriteStartInnerMessageWithId(writer);
|
|
this.InnerMessage.WriteBodyContents(writer);
|
|
writer.WriteEndElement();
|
|
fragmentingWriter.EndFragment();
|
|
writer.EndCanonicalization();
|
|
|
|
this.fullBodyFragment = fullBodyFragment.ToArray(out this.fullBodyFragmentLength);
|
|
|
|
this.state = BodyState.Signed;
|
|
}
|
|
|
|
void WriteInnerMessageWithId(XmlDictionaryWriter writer)
|
|
{
|
|
WriteStartInnerMessageWithId(writer);
|
|
this.InnerMessage.WriteBodyContents(writer);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
void WriteStartInnerMessageWithId(XmlDictionaryWriter writer)
|
|
{
|
|
this.InnerMessage.WriteStartBody(writer);
|
|
if (this.bodyIdInserted)
|
|
{
|
|
this.securityHeader.StandardsManager.IdManager.WriteIdAttribute(writer, this.bodyId);
|
|
}
|
|
}
|
|
|
|
enum BodyState
|
|
{
|
|
Created,
|
|
Signed,
|
|
SignedThenEncrypted,
|
|
EncryptedThenSigned,
|
|
Encrypted,
|
|
Disposed,
|
|
}
|
|
|
|
struct BodyContentHelper
|
|
{
|
|
MemoryStream stream;
|
|
XmlDictionaryWriter writer;
|
|
|
|
public XmlDictionaryWriter CreateWriter()
|
|
{
|
|
this.stream = new MemoryStream();
|
|
this.writer = XmlDictionaryWriter.CreateTextWriter(stream);
|
|
return this.writer;
|
|
}
|
|
|
|
public ArraySegment<byte> ExtractResult()
|
|
{
|
|
this.writer.Flush();
|
|
return new ArraySegment<byte>(this.stream.GetBuffer(), 0, (int) this.stream.Length);
|
|
}
|
|
}
|
|
|
|
sealed class MessagePrefixGenerator : IPrefixGenerator
|
|
{
|
|
XmlWriter writer;
|
|
|
|
public MessagePrefixGenerator(XmlWriter writer)
|
|
{
|
|
this.writer = writer;
|
|
}
|
|
|
|
public string GetPrefix(string namespaceUri, int depth, bool isForAttribute)
|
|
{
|
|
return this.writer.LookupPrefix(namespaceUri);
|
|
}
|
|
}
|
|
}
|
|
}
|