static void Main(string[] args) { using (ChannelFactory<IMessage> channelFactory = new ChannelFactory<IMessage>("messageservice")) { IMessage proxy = channelFactory.CreateChannel(); using (OperationContextScope contextScope = new OperationContextScope(proxy as IContextChannel)) { MessageHeader<CultureInfo> header = new MessageHeader<CultureInfo>(Thread.CurrentThread.CurrentUICulture); OperationContext.Current.OutgoingMessageHeaders.Add(header.GetUntypedHeader(CultureInfoHeadLocalName, CultureInfoHeaderNamespace)); Console.WriteLine("The UI culture of current thread is {0}", Thread.CurrentThread.CurrentUICulture); Console.WriteLine(proxy.GetMessage()); } Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); using (OperationContextScope contextScope = new OperationContextScope(proxy as IContextChannel)) { MessageHeader<CultureInfo> header = new MessageHeader<CultureInfo>(Thread.CurrentThread.CurrentUICulture); OperationContext.Current.OutgoingMessageHeaders.Add(header.GetUntypedHeader(CultureInfoHeadLocalName, CultureInfoHeaderNamespace)); Console.WriteLine("The UI culture of current thread is {0}", Thread.CurrentThread.CurrentUICulture); Console.WriteLine(proxy.GetMessage()); } } Console.Read(); }
/// <summary> /// 注入上下文:操作用户系统编号 /// </summary> /// <param name="request"></param> /// <param name="channel"></param> /// <returns></returns> public object BeforeSendRequest(ref Message request, IClientChannel channel) { System.ServiceModel.Channels.MessageHeader header = System.ServiceModel.Channels .MessageHeader.CreateHeader("X-User-SysNo", string.Empty, ServiceContext.Current.UserSysNo); request.Headers.Add(header); return(null); }
public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { var requestHeader = correlationState as MiniProfilerRequestHeader; MiniProfiler.Stop(); var miniProfiler = MiniProfiler.Current; if (miniProfiler != null && requestHeader != null) { if (requestHeader.ExcludeTrivialMethods) { miniProfiler.Root.RemoveTrivialTimings(); } var untypedHeader = new MessageHeader<MiniProfilerResultsHeader>(new MiniProfilerResultsHeader { ProfilerResults = miniProfiler }) .GetUntypedHeader(MiniProfilerResultsHeader.HeaderName, MiniProfilerResultsHeader.HeaderNamespace); reply.Headers.Add(untypedHeader); } //try //{ // var arrayOfIds = Settings.Storage.GetUnviewedIds(current.User).ToJson(); // // allow profiling of ajax requests // response.AppendHeader("X-MiniProfiler-Ids", arrayOfIds); //} //catch { } // headers blew up }
/// <summary> /// 请求发送前事件 /// </summary> /// <param name="request">请求消息</param> /// <param name="channel">信道</param> public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel) { if (OperationContext.Current != null) { //WCF客户端获取公钥处理 MessageHeaders incomingHeaders = OperationContext.Current.IncomingMessageHeaders; #region # 验证消息头 if (!incomingHeaders.Any(x => x.Name == CommonConstants.WCFAuthenticationHeader && x.Namespace == GlobalSetting.ApplicationId)) { string message = "身份认证消息头不存在,请检查程序!"; NoPermissionException innerException = new NoPermissionException(message); FaultReason faultReason = new FaultReason(message); FaultCode faultCode = new FaultCode(HttpStatusCode.Unauthorized.ToString()); throw new FaultException <NoPermissionException>(innerException, faultReason, faultCode); } #endregion //读取消息头中的公钥 Guid publicKey = incomingHeaders.GetHeader <Guid>(CommonConstants.WCFAuthenticationHeader, GlobalSetting.ApplicationId); //添加消息头 System.ServiceModel.Channels.MessageHeader outgoingheader = System.ServiceModel.Channels.MessageHeader.CreateHeader(CommonConstants.WCFAuthenticationHeader, GlobalSetting.ApplicationId, publicKey); request.Headers.Add(outgoingheader); } return(null); }
static void Main(string[] args) { string action = "http://www.artech.com/crm/AddCustomer"; using (Message message = Message.CreateMessage(MessageVersion.Soap12WSAddressing10, action)) { string ns = "http://www.artech.com/crm"; EndpointAddress address = new EndpointAddress("http://www.artech.com/crm/client"); message.Headers.To = new Uri("http://www.artech.com/crm/customerservice"); message.Headers.From = address; message.Headers.ReplyTo = address; message.Headers.FaultTo = address; message.Headers.MessageId = new UniqueId(Guid.NewGuid()); message.Headers.RelatesTo = new UniqueId(Guid.NewGuid()); MessageHeader<string> foo = new MessageHeader<string>("ABC", false, "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver",false); MessageHeader<string> bar = new MessageHeader<string>("abc", true, "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver", false); MessageHeader<string> baz = new MessageHeader<string>("123", false, "http://www.w3.org/2003/05/soap-envelope/role/next", true); message.Headers.Add(foo.GetUntypedHeader("Foo", ns)); message.Headers.Add(bar.GetUntypedHeader("Bar", ns)); message.Headers.Add(baz.GetUntypedHeader("Baz", ns)); WriteMessage(message, "message.xml"); } }
/// <summary> /// Add token message at header to using NHibernate cache /// </summary> /// <param name="request"></param> /// <param name="channel"></param> /// <returns></returns> public object BeforeSendRequest(ref Message request, IClientChannel channel) { // add trace log for debug and performance tuning if (null != (request.Headers).MessageId && (request.Headers).MessageId.IsGuid) { ServiceStopWatch = Stopwatch.StartNew(); Guid messageId; (request.Headers).MessageId.TryGetGuid(out messageId); CurrentTraceInfo = new TraceInfo() { SessionId = (HttpContext.Current != null && HttpContext.Current.Session != null) ? HttpContext.Current.Session.SessionID : "", TraceType = TraceType.WcfActionClientCall, TraceName = request.Headers.Action, TraceUniqueId = messageId.ToString() }; TraceLogger.Instance.TraceServiceStart(CurrentTraceInfo, true); // Add a message header with sessionid MessageHeader<string> messageHeader = new MessageHeader<string>(CurrentTraceInfo.SessionId); MessageHeader untyped = messageHeader.GetUntypedHeader("sessionid", "ns"); request.Headers.Add(untyped); } return null; }
internal bool IsHeaderIncluded(MessageHeader header) { if (header == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("header"); } return this.IsHeaderIncluded(header.Name, header.Namespace); }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { MessageHeader<ApplicationContext> contextHeader = new MessageHeader<ApplicationContext>(ApplicationContext.Current); request.Headers.Add(contextHeader.GetUntypedHeader(ApplicationContext.ContextHeaderLocalName, ApplicationContext.ContextHeaderNameSpace)); return null; }
protected DelegatingHeader(MessageHeader innerHeader) { if (innerHeader == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("innerHeader"); } this.innerHeader = innerHeader; }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { //Instantiate new HeaderObject with values from ClientContext; if (eCollabroRequest.ActiveUser != null) { var typedHeader = new MessageHeader<UserContextDC>(eCollabroRequest.ActiveUser); var untypedHeader = typedHeader.GetUntypedHeader("ActiveUser", "s"); request.Headers.Add(untypedHeader); } return null; }
public static void AddHeadersTo(Message message, MessageHeader header) { if (message.Headers.FindHeader("PacketRoutable", "http://schemas.microsoft.com/ws/2005/05/routing") == -1) { if (header == null) { header = Create(); } message.Headers.Add(header); } }
public EncryptedHeader(MessageHeader plainTextHeader, EncryptedHeaderXml headerXml, string name, string namespaceUri, MessageVersion version) : base(plainTextHeader) { if (!headerXml.HasId || headerXml.Id == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.EncryptedHeaderXmlMustHaveId))); } this.headerXml = headerXml; this.name = name; this.namespaceUri = namespaceUri; this.version = version; }
public void BeforeSendReply( ref Message reply, object correlationState) { var correlationId = correlationState as Guid?; if (correlationId != null) { var messageHeader = new MessageHeader<Guid>(correlationId.Value); var untypedHeader = messageHeader.GetUntypedHeader(Constants.CorrelationIdHeader, Constants.ErniChNamespace); reply.Headers.Add(untypedHeader); } EtwSampleServerEventSource.Log.RequestStop(); }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { var dataToSend = new ExternalApiConnectionHeader { ClientCulture = Thread.CurrentThread.CurrentCulture.Name, ClientUiCulture = Thread.CurrentThread.CurrentUICulture.Name }; var typedHeader = new MessageHeader<ExternalApiConnectionHeader>(dataToSend); var untypedHeader = typedHeader.GetUntypedHeader("ExternalApiConnectionHeader", NS.ExternalApiNamespaceV1); request.Headers.Add(untypedHeader); return null; }
public void GenerateMpr(MprGenerationRequestV1 request) { var responseContext = OperationContext.Current.IncomingMessageHeaders.GetHeader<ResponseContext>( "ResponseContext", "ServiceModelEx"); System.Diagnostics.Trace.Assert(responseContext.MethodId.CompareTo(Guid.Empty.ToString()) != 0); LocalImageResourceManagerClient lirm = new LocalImageResourceManagerClient(); lirm.Open(); UniformImageVolumeDataContract ivdc = null; ivdc = lirm.GetImageVolume(request.ImageVolumeId); int[] size = CalculateSize(ivdc, request.Orientation); ImageDataContract idc = null; _cacheResultImages.TryGetValue(responseContext.MethodId, out idc); if (idc == null || idc.Width != size[0] || idc.Height != size[1]) { idc = new ImageDataContract(); idc.Width = size[0]; idc.Height = size[1]; idc = lirm.AddImage(idc); _cacheResultImages.TryAdd(responseContext.MethodId, idc); } lirm.Close(); UpdatePixelsFromVolumeResampled(ivdc, request.Orientation, request.SlicePosition, request.WindowCenter, request.WindowWidth, idc); MessageHeader<ResponseContext> responseHeader = new MessageHeader<ResponseContext>(responseContext); NetMsmqBinding binding = new NetMsmqBinding("NoMsmqSecurity"); MprGenerationResponseProxy proxy = new MprGenerationResponseProxy(binding, new EndpointAddress(responseContext.ResponseAddress)); using (OperationContextScope scope = new OperationContextScope(proxy.InnerChannel)) { OperationContext.Current.OutgoingMessageHeaders.Add( responseHeader.GetUntypedHeader("ResponseContext", "ServiceModelEx")); proxy.OnMprDone(idc, request.RequestTime); } proxy.Close(); }
/// <summary> /// Add token message at header to using NHibernate cache /// </summary> /// <param name="request"></param> /// <param name="channel"></param> /// <returns></returns> public object BeforeSendRequest(ref Message request, IClientChannel channel) { //get the extension item that the client may have put in the channel var item = channel.Extensions.Find<NHibernate2ndLevelCacheBehaviorExtensionItem>(); bool clientWantsToBypass = (item != null && item.BypassNHibernate2ndLevelCache); if (clientWantsToBypass || IsDefaultBypassNHibernateCache) { MessageHeader<bool> mhg = new MessageHeader<bool>(true); MessageHeader untyped = mhg.GetUntypedHeader("token", "ns"); request.Headers.Add(untyped); } return null; }
private void AddEncryptionReference(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, bool sign, out MemoryStream plainTextStream, out string encryptedDataId) { plainTextStream = new MemoryStream(); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(plainTextStream); if (sign) { this.AddSignatureReference(header, headerId, prefixGenerator, writer); } else { header.WriteHeader(writer, base.Version); writer.Flush(); } encryptedDataId = base.GenerateId(); this.referenceList.AddReferredId(encryptedDataId); }
public void AfterInvoke(object correlationState) { if (!this.IsBidirectional) { return; } ApplicationContext context = correlationState as ApplicationContext; if (context == null) { return; } MessageHeader<ApplicationContext> contextHeader = new MessageHeader<ApplicationContext>(context); OperationContext.Current.OutgoingMessageHeaders.Add(contextHeader.GetUntypedHeader(ApplicationContext.ContextHeaderLocalName, ApplicationContext.ContextHeaderNameSpace)); ApplicationContext.Current = null; }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { //Instantiate new HeaderObject with values from ClientContext; var dataToSend = new CustomHeader { WebNodeId = ClientCustomHeaderContext.HeaderInformation.WebNodeId, WebSessionId = ClientCustomHeaderContext.HeaderInformation.WebSessionId, WebUserId = ClientCustomHeaderContext.HeaderInformation.WebUserId }; var typedHeader = new MessageHeader<CustomHeader>(dataToSend); var untypedHeader = typedHeader.GetUntypedHeader("custom-header", "s"); request.Headers.Add(untypedHeader); return null; }
public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { var requestHeader = correlationState as MiniProfilerRequestHeader; MiniProfiler.Stop(); var miniProfiler = MiniProfiler.Current; if (miniProfiler != null && requestHeader != null) { if (requestHeader.ExcludeTrivialMethods) { miniProfiler.Root.RemoveTrivialTimings(); } var header = new MiniProfilerResultsHeader { ProfilerResults = miniProfiler }; if (reply.Headers.MessageVersion != MessageVersion.None) { var untypedHeader = new MessageHeader<MiniProfilerResultsHeader>(header) .GetUntypedHeader(MiniProfilerResultsHeader.HeaderName, MiniProfilerResultsHeader.HeaderNamespace); reply.Headers.Add(untypedHeader); } else if (reply.Properties.ContainsKey(HttpResponseMessageProperty.Name)) { HttpResponseMessageProperty property = (HttpResponseMessageProperty)reply.Properties[HttpResponseMessageProperty.Name]; property.Headers.Add(MiniProfilerResultsHeader.HeaderName, header.ToHeaderText()); } } else { throw new InvalidOperationException("MVC Mini Profiler does not support EnvelopeNone unless HTTP is the transport mechanism"); } //try //{ // var arrayOfIds = Settings.Storage.GetUnviewedIds(current.User).ToJson(); // // allow profiling of ajax requests // response.AppendHeader("X-MiniProfiler-Ids", arrayOfIds); //} //catch { } // headers blew up }
object IClientMessageInspector.BeforeSendRequest(ref Message request, IClientChannel channel) { string headerText = "<wsse:UsernameToken xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">" + "<wsse:Username>{0}</wsse:Username>" + "<wsse:Password Type=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText\">{1}</wsse:Password>" + "</wsse:UsernameToken>"; // + headerText = string.Format(headerText, _username, _password); XmlDocument MyDoc = new XmlDocument(); MyDoc.LoadXml(headerText); XmlElement myElement = MyDoc.DocumentElement; System.ServiceModel.Channels.MessageHeader myHeader = MessageHeader.CreateHeader("Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", myElement, false); request.Headers.Add(myHeader); return(Convert.DBNull); }
public static void SetSessionData(string userName, string password, ref Message request) { var userHeader = new MessageHeader <string> { Actor = HnForUserName, Content = userName }; //Creating an untyped header to add to the WCF context System.ServiceModel.Channels.MessageHeader unTypedHeaderForUser = userHeader.GetUntypedHeader(HnForUserName, HNamespaceForUserName); //Add the header to the current request request.Headers.Add(unTypedHeaderForUser); var passwordHeader = new MessageHeader <string> { Actor = HnForPassword, Content = password }; //Creating an untyped header to add to the WCF context System.ServiceModel.Channels.MessageHeader unTypedHeaderForPassword = passwordHeader.GetUntypedHeader(HnForPassword, HNamespaceForPassword); //Add the header to the current request request.Headers.Add(unTypedHeaderForPassword); }
private void SetStartMessageHeaders(Message message, Message chunk) { this.messageId = Guid.NewGuid(); //create messageId header this.messageIdHeader = MessageHeader.CreateHeader( ChunkingUtils.MessageIdHeader, ChunkingUtils.ChunkNs, this.messageId.ToString(), true); chunk.Headers.Add(this.messageIdHeader); //create chunkStart header MessageHeader chunkStartHeader = MessageHeader.CreateHeader( ChunkingUtils.ChunkingStartHeader, ChunkingUtils.ChunkNs, null, true); chunk.Headers.Add(chunkStartHeader); //write out original headers as new message's headers MessageHeaders headers = message.Headers; string addressingNs = ChunkingUtils.GetAddressingNamespace(message.Version); for (int i = 0; i < headers.Count; i++) { //look for Action header and write it out as OriginalAction if (headers[i].Name == "Action" && headers[i].Namespace == addressingNs) { //write out original action string originalAction = message.Headers.Action; //headers.GetHeader<string>(i); MessageHeader originalActionHeader = MessageHeader.CreateHeader(ChunkingUtils.OriginalAction, ChunkingUtils.ChunkNs, originalAction); chunk.Headers.Add(originalActionHeader); } else { //copying a header chunk.Headers.CopyHeaderFrom(headers, i); } } }
protected override EncryptedHeader EncryptHeader(MessageHeader plainTextHeader, SymmetricAlgorithm algorithm, SecurityKeyIdentifier keyIdentifier, MessageVersion version, string id, MemoryStream stream) { // We are not reading EncryptedData from the wire here, hence pass false. EncryptedHeaderXml encryptedHeaderXml = new EncryptedHeaderXml(version, false); encryptedHeaderXml.SecurityTokenSerializer = this.StandardsManager.SecurityTokenSerializer; encryptedHeaderXml.EncryptionMethod = this.EncryptionAlgorithm; encryptedHeaderXml.EncryptionMethodDictionaryString = this.EncryptionAlgorithmDictionaryString; encryptedHeaderXml.KeyIdentifier = keyIdentifier; encryptedHeaderXml.Id = id; // The Encrypted Headers MustUnderstand, Relay and Actor attributes will always match the // Security Headers value. The values for these on the Encrypted Header and its decrypted // form can be different. encryptedHeaderXml.MustUnderstand = this.MustUnderstand; encryptedHeaderXml.Relay = this.Relay; encryptedHeaderXml.Actor = this.Actor; encryptedHeaderXml.SetUpEncryption(algorithm, stream); return new EncryptedHeader(plainTextHeader, encryptedHeaderXml, EncryptedHeaderXml.ElementName.Value, EncryptedHeaderXml.NamespaceUri.Value, version); }
/// <summary> /// before the send request. /// </summary> /// <param name="request">The request.</param> /// <param name="channel">The channel.</param> /// <returns>the mini profiler start</returns> public object BeforeSendRequest(ref Message request, IClientChannel channel) { // If we currently are running inside a MiniProfiler context, then add a request onto this request var miniProfiler = GetCurrentProfiler(); if (miniProfiler != null) { var header = new MiniProfilerRequestHeader { User = miniProfiler.User, ParentProfilerId = miniProfiler.Id }; // ReSharper disable PossibleUnintendedReferenceComparison if (request.Headers.MessageVersion != MessageVersion.None) // ReSharper restore PossibleUnintendedReferenceComparison { var untypedHeader = new MessageHeader<MiniProfilerRequestHeader>(header) .GetUntypedHeader(MiniProfilerRequestHeader.HeaderName, MiniProfilerRequestHeader.HeaderNamespace); request.Headers.Add(untypedHeader); } else if (_http || WebOperationContext.Current != null || channel.Via.Scheme == "http" | channel.Via.Scheme == "https") { _http = true; if (!request.Properties.ContainsKey(HttpRequestMessageProperty.Name)) { request.Properties.Add(HttpRequestMessageProperty.Name, new HttpRequestMessageProperty()); } HttpRequestMessageProperty property = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name]; property.Headers.Add(MiniProfilerRequestHeader.HeaderName, header.ToHeaderText()); } else throw new InvalidOperationException("MVC Mini Profiler does not support EnvelopeNone unless HTTP is the transport mechanism"); return new MiniProfilerStart { StartTime = miniProfiler.DurationMilliseconds }; } return null; }
static void Main(string[] args) { try { TestProxy.Service1Client client = new TestProxy.Service1Client(); using (OperationContextScope scope = new OperationContextScope(client.InnerChannel)) { MessageHeader<string> cultureHeader = new MessageHeader<string>("en-US"); // Add the culture header into request OperationContext.Current.OutgoingMessageHeaders.Add( cultureHeader.GetUntypedHeader("culture", "urn:wcf:extension") ); client.GetData(11); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
internal static void AddHeader(MessageHeaders headers, MessageHeader hContext) { headers.Add(hContext); }
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 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))); }
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 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; } }
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); }
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 IPeerNodeMessageHandling.HandleIncomingMessage(MessageBuffer messageBuffer, PeerMessagePropagation propagateFlags, int index, MessageHeader hopHeader, Uri via, Uri to) { if (DiagnosticUtility.ShouldTraceVerbose) { TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.PeerFloodedMessageReceived, SR.GetString(SR.TraceCodePeerFloodedMessageReceived), this.traceRecord, this, null); } if (via == null) { Fx.Assert("No VIA in the forwarded message!"); using (Message message = messageBuffer.CreateMessage()) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.PeerMessageMustHaveVia, message.Headers.Action))); } } if ((propagateFlags & PeerMessagePropagation.Local) != 0) { DeliverMessageToClientChannels(null, messageBuffer, via, to, messageBuffer.MessageContentType, (int)maxReceivedMessageSize, index, hopHeader); messageBuffer = null; } else { if (DiagnosticUtility.ShouldTraceVerbose) { using (Message traceMessage = messageBuffer.CreateMessage()) { TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.PeerFloodedMessageNotPropagated, SR.GetString(SR.TraceCodePeerFloodedMessageNotPropagated), this.traceRecord, this, null, traceMessage); } } } }
public void Add(MessageHeader header) { }
public void Insert(int headerIndex, MessageHeader header) { l.Insert(headerIndex, header); }
public void Add(MessageHeader header) { l.Add(header); }