Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / WindowsStreamSecurityUpgradeProvider.cs / 2 / WindowsStreamSecurityUpgradeProvider.cs
//------------------------------------------------------------ // Copyright (c) Microsoft Corporation. All rights reserved. //----------------------------------------------------------- namespace System.ServiceModel.Channels { using System.Collections.ObjectModel; using System.Diagnostics; using System.IO; using System.Net; using System.Net.Security; using System.Security.Authentication; using System.IdentityModel.Claims; using System.IdentityModel.Policy; using System.IdentityModel.Selectors; using System.IdentityModel.Tokens; using System.Security.Principal; using System.ServiceModel.Security.Tokens; using System.ServiceModel; using System.ServiceModel.Security; using System.Globalization; using System.ServiceModel.Description; class WindowsStreamSecurityUpgradeProvider : StreamSecurityUpgradeProvider { bool extractGroupsForWindowsAccounts; EndpointIdentity identity; IdentityVerifier identityVerifier; ProtectionLevel protectionLevel; SecurityTokenManager securityTokenManager; NetworkCredential serverCredential; string scheme; bool isClient; public WindowsStreamSecurityUpgradeProvider(WindowsStreamSecurityBindingElement bindingElement, BindingContext context, bool isClient) : base(context.Binding) { this.extractGroupsForWindowsAccounts = TransportDefaults.ExtractGroupsForWindowsAccounts; this.protectionLevel = bindingElement.ProtectionLevel; this.scheme = context.Binding.Scheme; this.isClient = isClient; SecurityCredentialsManager credentialProvider = context.BindingParameters.Find(); if (credentialProvider == null) { if (isClient) { credentialProvider = ClientCredentials.CreateDefaultCredentials(); } else { credentialProvider = ServiceCredentials.CreateDefaultCredentials(); } } this.securityTokenManager = credentialProvider.CreateSecurityTokenManager(); } public string Scheme { get { return this.scheme; } } internal bool ExtractGroupsForWindowsAccounts { get { return this.extractGroupsForWindowsAccounts; } } public override EndpointIdentity Identity { get { // If the server credential is null, then we have not been opened yet and have no identity to expose. if (this.serverCredential != null) { if (this.identity == null) { lock (ThisLock) { if (this.identity == null) { this.identity = SecurityUtils.CreateWindowsIdentity(this.serverCredential); } } } } return this.identity; } } internal IdentityVerifier IdentityVerifier { get { return this.identityVerifier; } } public ProtectionLevel ProtectionLevel { get { return protectionLevel; } } NetworkCredential ServerCredential { get { return this.serverCredential; } } public override StreamUpgradeAcceptor CreateUpgradeAcceptor() { ThrowIfDisposedOrNotOpen(); return new WindowsStreamSecurityUpgradeAcceptor(this); } public override StreamUpgradeInitiator CreateUpgradeInitiator(EndpointAddress remoteAddress, Uri via) { ThrowIfDisposedOrNotOpen(); return new WindowsStreamSecurityUpgradeInitiator(this, remoteAddress, via); } protected override void OnAbort() { } protected override void OnClose(TimeSpan timeout) { } protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return new CompletedAsyncResult(callback, state); } protected override void OnEndClose(IAsyncResult result) { CompletedAsyncResult.End(result); } protected override void OnOpen(TimeSpan timeout) { if (!isClient) { SecurityTokenRequirement sspiTokenRequirement = TransportSecurityHelpers.CreateSspiTokenRequirement(this.Scheme); this.serverCredential = TransportSecurityHelpers.GetSspiCredential(this.securityTokenManager, sspiTokenRequirement, timeout, out this.extractGroupsForWindowsAccounts); } } protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { OnOpen(timeout); return new CompletedAsyncResult(callback, state); } protected override void OnEndOpen(IAsyncResult result) { CompletedAsyncResult.End(result); } protected override void OnOpened() { base.OnOpened(); if (this.identityVerifier == null) { this.identityVerifier = IdentityVerifier.CreateDefault(); } if (this.serverCredential == null) { this.serverCredential = CredentialCache.DefaultNetworkCredentials; } } class WindowsStreamSecurityUpgradeAcceptor : StreamSecurityUpgradeAcceptorBase { WindowsStreamSecurityUpgradeProvider parent; SecurityMessageProperty clientSecurity; public WindowsStreamSecurityUpgradeAcceptor(WindowsStreamSecurityUpgradeProvider parent) : base(FramingUpgradeString.Negotiate) { this.parent = parent; this.clientSecurity = new SecurityMessageProperty(); } protected override Stream OnAcceptUpgrade(Stream stream, out SecurityMessageProperty remoteSecurity) { // wrap stream NegotiateStream negotiateStream = new NegotiateStream(stream); // authenticate try { negotiateStream.AuthenticateAsServer(parent.ServerCredential, parent.ProtectionLevel, TokenImpersonationLevel.Identification); } catch (AuthenticationException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(exception.Message, exception)); } catch (IOException ioException) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException( SR.GetString(SR.NegotiationFailedIO, ioException.Message), ioException)); } remoteSecurity = CreateClientSecurity(negotiateStream, parent.ExtractGroupsForWindowsAccounts); return negotiateStream; } protected override IAsyncResult OnBeginAcceptUpgrade(Stream stream, AsyncCallback callback, object state) { AcceptUpgradeAsyncResult result = new AcceptUpgradeAsyncResult(this, callback, state); result.Begin(stream); return result; } protected override Stream OnEndAcceptUpgrade(IAsyncResult result, out SecurityMessageProperty remoteSecurity) { return AcceptUpgradeAsyncResult.End(result, out remoteSecurity); } SecurityMessageProperty CreateClientSecurity(NegotiateStream negotiateStream, bool extractGroupsForWindowsAccounts) { WindowsIdentity remoteIdentity = (WindowsIdentity)negotiateStream.RemoteIdentity; SecurityUtils.ValidateAnonymityConstraint(remoteIdentity, false); WindowsSecurityTokenAuthenticator authenticator = new WindowsSecurityTokenAuthenticator(extractGroupsForWindowsAccounts); SecurityToken token = new WindowsSecurityToken(remoteIdentity); ReadOnlyCollection authorizationPolicies = authenticator.ValidateToken(token); this.clientSecurity = new SecurityMessageProperty(); this.clientSecurity.TransportToken = new SecurityTokenSpecification(token, authorizationPolicies); this.clientSecurity.ServiceSecurityContext = new ServiceSecurityContext(authorizationPolicies); return this.clientSecurity; } public override SecurityMessageProperty GetRemoteSecurity() { if (this.clientSecurity.TransportToken != null) { return this.clientSecurity; } return base.GetRemoteSecurity(); } class AcceptUpgradeAsyncResult : StreamSecurityUpgradeAcceptorAsyncResult { WindowsStreamSecurityUpgradeAcceptor acceptor; NegotiateStream negotiateStream; public AcceptUpgradeAsyncResult(WindowsStreamSecurityUpgradeAcceptor acceptor, AsyncCallback callback, object state) : base(callback, state) { this.acceptor = acceptor; } protected override IAsyncResult OnBegin(Stream stream, AsyncCallback callback) { this.negotiateStream = new NegotiateStream(stream); return this.negotiateStream.BeginAuthenticateAsServer(this.acceptor.parent.ServerCredential, this.acceptor.parent.ProtectionLevel, TokenImpersonationLevel.Identification, callback, this); } protected override Stream OnCompleteAuthenticateAsServer(IAsyncResult result) { this.negotiateStream.EndAuthenticateAsServer(result); return this.negotiateStream; } protected override SecurityMessageProperty ValidateCreateSecurity() { return this.acceptor.CreateClientSecurity(this.negotiateStream, this.acceptor.parent.ExtractGroupsForWindowsAccounts); } } } class WindowsStreamSecurityUpgradeInitiator : StreamSecurityUpgradeInitiatorBase { WindowsStreamSecurityUpgradeProvider parent; IdentityVerifier identityVerifier; NetworkCredential credential; TokenImpersonationLevel impersonationLevel; SspiSecurityTokenProvider clientTokenProvider; bool allowNtlm; public WindowsStreamSecurityUpgradeInitiator( WindowsStreamSecurityUpgradeProvider parent, EndpointAddress remoteAddress, Uri via) : base(FramingUpgradeString.Negotiate, remoteAddress, via) { this.parent = parent; this.clientTokenProvider = TransportSecurityHelpers.GetSspiTokenProvider( parent.securityTokenManager, remoteAddress, via, parent.Scheme, out this.identityVerifier); } IAsyncResult BaseBeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return base.BeginOpen(timeout, callback, state); } void BaseEndOpen(IAsyncResult result) { base.EndOpen(result); } internal override IAsyncResult BeginOpen(TimeSpan timeout, AsyncCallback callback, object state) { return new OpenAsyncResult(this, timeout, callback, state); } internal override void EndOpen(IAsyncResult result) { OpenAsyncResult.End(result); } internal override void Open(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); base.Open(timeoutHelper.RemainingTime()); SecurityUtils.OpenTokenProviderIfRequired(this.clientTokenProvider, timeoutHelper.RemainingTime()); this.credential = TransportSecurityHelpers.GetSspiCredential(this.clientTokenProvider, timeoutHelper.RemainingTime(), out this.impersonationLevel, out this.allowNtlm); } IAsyncResult BaseBeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return base.BeginClose(timeout, callback, state); } void BaseEndClose(IAsyncResult result) { base.EndClose(result); } internal override IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state) { return new CloseAsyncResult(this, timeout, callback, state); } internal override void EndClose(IAsyncResult result) { CloseAsyncResult.End(result); } internal override void Close(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); base.Close(timeoutHelper.RemainingTime()); SecurityUtils.CloseTokenProviderIfRequired(this.clientTokenProvider, timeoutHelper.RemainingTime()); } protected override IAsyncResult OnBeginInitiateUpgrade(Stream stream, AsyncCallback callback, object state) { InitiateUpgradeAsyncResult result = new InitiateUpgradeAsyncResult(this, callback, state); result.Begin(stream); return result; } protected override Stream OnEndInitiateUpgrade(IAsyncResult result, out SecurityMessageProperty remoteSecurity) { return InitiateUpgradeAsyncResult.End(result, out remoteSecurity); } static SecurityMessageProperty CreateServerSecurity(NegotiateStream negotiateStream) { GenericIdentity remoteIdentity = (GenericIdentity)negotiateStream.RemoteIdentity; string principalName = remoteIdentity.Name; if ((principalName != null) && (principalName.Length > 0)) { ReadOnlyCollection authorizationPolicies = SecurityUtils.CreatePrincipalNameAuthorizationPolicies(principalName); SecurityMessageProperty result = new SecurityMessageProperty(); result.TransportToken = new SecurityTokenSpecification(null, authorizationPolicies); result.ServiceSecurityContext = new ServiceSecurityContext(authorizationPolicies); return result; } else { return null; } } protected override Stream OnInitiateUpgrade(Stream stream, out SecurityMessageProperty remoteSecurity) { NegotiateStream negotiateStream; string targetName; EndpointIdentity identity; // prepare this.InitiateUpgradePrepare(stream, out negotiateStream, out targetName, out identity); // authenticate try { negotiateStream.AuthenticateAsClient(credential, targetName, parent.ProtectionLevel, impersonationLevel); } catch (AuthenticationException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(exception.Message, exception)); } catch (IOException ioException) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException( SR.GetString(SR.NegotiationFailedIO, ioException.Message), ioException)); } remoteSecurity = CreateServerSecurity(negotiateStream); this.ValidateMutualAuth(identity, negotiateStream, remoteSecurity, allowNtlm); return negotiateStream; } void InitiateUpgradePrepare( Stream stream, out NegotiateStream negotiateStream, out string targetName, out EndpointIdentity identity) { negotiateStream = new NegotiateStream(stream); targetName = string.Empty; identity = null; if (parent.IdentityVerifier.TryGetIdentity(this.RemoteAddress, this.Via, out identity)) { targetName = SecurityUtils.GetSpnFromIdentity(identity, this.RemoteAddress); } else { targetName = SecurityUtils.GetSpnFromTarget(this.RemoteAddress); } } void ValidateMutualAuth(EndpointIdentity expectedIdentity, NegotiateStream negotiateStream, SecurityMessageProperty remoteSecurity, bool allowNtlm) { if (negotiateStream.IsMutuallyAuthenticated) { if (expectedIdentity != null) { if (!parent.IdentityVerifier.CheckAccess(expectedIdentity, remoteSecurity.ServiceSecurityContext.AuthorizationContext)) { string primaryIdentity = SecurityUtils.GetIdentityNamesFromContext(remoteSecurity.ServiceSecurityContext.AuthorizationContext); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(SR.GetString( SR.RemoteIdentityFailedVerification, primaryIdentity))); } } } else if (!allowNtlm) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityNegotiationException(SR.GetString( SR.StreamMutualAuthNotSatisfied))); } } class InitiateUpgradeAsyncResult : StreamSecurityUpgradeInitiatorAsyncResult { EndpointIdentity expectedIdentity; WindowsStreamSecurityUpgradeInitiator initiator; NegotiateStream negotiateStream; public InitiateUpgradeAsyncResult(WindowsStreamSecurityUpgradeInitiator initiator, AsyncCallback callback, object state) : base(callback, state) { this.initiator = initiator; } protected override IAsyncResult OnBeginAuthenticateAsClient(Stream stream, AsyncCallback callback) { string targetName; this.initiator.InitiateUpgradePrepare(stream, out this.negotiateStream, out targetName, out this.expectedIdentity); return this.negotiateStream.BeginAuthenticateAsClient(this.initiator.credential, targetName, this.initiator.parent.ProtectionLevel, this.initiator.impersonationLevel, callback, this); } protected override Stream OnCompleteAuthenticateAsClient(IAsyncResult result) { this.negotiateStream.EndAuthenticateAsClient(result); return this.negotiateStream; } protected override SecurityMessageProperty ValidateCreateSecurity() { SecurityMessageProperty remoteSecurity = CreateServerSecurity(negotiateStream); this.initiator.ValidateMutualAuth(this.expectedIdentity, this.negotiateStream, remoteSecurity, this.initiator.allowNtlm); return remoteSecurity; } } class OpenAsyncResult : AsyncResult { WindowsStreamSecurityUpgradeInitiator parent; TimeoutHelper timeoutHelper; AsyncCallback onBaseOpen; AsyncCallback onOpenTokenProvider; AsyncCallback onGetSspiCredential; public OpenAsyncResult(WindowsStreamSecurityUpgradeInitiator parent, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.parent = parent; TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); // since we're at channel.Open and not per-message, minimize our statics overhead and leverage GC for our callback this.onBaseOpen = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnBaseOpen)); this.onGetSspiCredential = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnGetSspiCredential)); this.onOpenTokenProvider = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnOpenTokenProvider)); IAsyncResult result = parent.BaseBeginOpen(timeoutHelper.RemainingTime(), onBaseOpen, this); if (!result.CompletedSynchronously) { return; } if (HandleBaseOpenComplete(result)) { base.Complete(true); } } public static void End(IAsyncResult result) { AsyncResult.End (result); } bool HandleBaseOpenComplete(IAsyncResult result) { parent.BaseEndOpen(result); IAsyncResult openTokenProviderResult = SecurityUtils.BeginOpenTokenProviderIfRequired( parent.clientTokenProvider, timeoutHelper.RemainingTime(), onOpenTokenProvider, this); if (!openTokenProviderResult.CompletedSynchronously) { return false; } return HandleOpenTokenProviderComplete(openTokenProviderResult); } bool HandleOpenTokenProviderComplete(IAsyncResult result) { SecurityUtils.EndOpenTokenProviderIfRequired(result); IAsyncResult getCredentialResult = TransportSecurityHelpers.BeginGetSspiCredential( parent.clientTokenProvider, timeoutHelper.RemainingTime(), onGetSspiCredential, this); if (!getCredentialResult.CompletedSynchronously) { return false; } return HandleGetSspiCredentialComplete(getCredentialResult); } bool HandleGetSspiCredentialComplete(IAsyncResult result) { parent.credential = TransportSecurityHelpers.EndGetSspiCredential(result, out parent.impersonationLevel, out parent.allowNtlm); return true; } void OnBaseOpen(IAsyncResult result) { if (result.CompletedSynchronously) { return; } Exception completionException = null; bool completeSelf = false; try { completeSelf = this.HandleBaseOpenComplete(result); } #pragma warning suppress 56500 // [....], transferring exception to another thread catch (Exception e) { if (DiagnosticUtility.IsFatal(e)) { throw; } completeSelf = true; completionException = e; } if (completeSelf) { base.Complete(false, completionException); } } void OnOpenTokenProvider(IAsyncResult result) { if (result.CompletedSynchronously) { return; } Exception completionException = null; bool completeSelf = false; try { completeSelf = this.HandleOpenTokenProviderComplete(result); } #pragma warning suppress 56500 // [....], transferring exception to another thread catch (Exception e) { if (DiagnosticUtility.IsFatal(e)) { throw; } completeSelf = true; completionException = e; } if (completeSelf) { base.Complete(false, completionException); } } void OnGetSspiCredential(IAsyncResult result) { if (result.CompletedSynchronously) { return; } Exception completionException = null; bool completeSelf = false; try { completeSelf = this.HandleGetSspiCredentialComplete(result); } #pragma warning suppress 56500 // [....], transferring exception to another thread catch (Exception e) { if (DiagnosticUtility.IsFatal(e)) { throw; } completeSelf = true; completionException = e; } if (completeSelf) { base.Complete(false, completionException); } } } class CloseAsyncResult : AsyncResult { WindowsStreamSecurityUpgradeInitiator parent; TimeoutHelper timeoutHelper; AsyncCallback onBaseClose; AsyncCallback onCloseTokenProvider; public CloseAsyncResult(WindowsStreamSecurityUpgradeInitiator parent, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.parent = parent; this.timeoutHelper = new TimeoutHelper(timeout); // since we're at channel.Open and not per-message, minimize our statics overhead and leverage GC for our callback this.onBaseClose = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnBaseClose)); this.onCloseTokenProvider = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnCloseTokenProvider)); IAsyncResult result = parent.BaseBeginClose(timeoutHelper.RemainingTime(), onBaseClose, this); if (!result.CompletedSynchronously) { return; } if (HandleBaseCloseComplete(result)) { base.Complete(true); } } public static void End(IAsyncResult result) { AsyncResult.End (result); } bool HandleBaseCloseComplete(IAsyncResult result) { parent.BaseEndClose(result); IAsyncResult closeTokenProviderResult = SecurityUtils.BeginCloseTokenProviderIfRequired( parent.clientTokenProvider, timeoutHelper.RemainingTime(), onCloseTokenProvider, this); if (!closeTokenProviderResult.CompletedSynchronously) { return false; } SecurityUtils.EndCloseTokenProviderIfRequired(closeTokenProviderResult); return true; } void OnBaseClose(IAsyncResult result) { if (result.CompletedSynchronously) { return; } Exception completionException = null; bool completeSelf = false; try { completeSelf = this.HandleBaseCloseComplete(result); } #pragma warning suppress 56500 // [....], transferring exception to another thread catch (Exception e) { if (DiagnosticUtility.IsFatal(e)) { throw; } completeSelf = true; completionException = e; } if (completeSelf) { base.Complete(false, completionException); } } void OnCloseTokenProvider(IAsyncResult result) { if (result.CompletedSynchronously) { return; } Exception completionException = null; try { SecurityUtils.EndCloseTokenProviderIfRequired(result); } #pragma warning suppress 56500 // [....], transferring exception to another thread catch (Exception e) { if (DiagnosticUtility.IsFatal(e)) { throw; } completionException = e; } base.Complete(false, completionException); } } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- WebPartVerb.cs
- PolygonHotSpot.cs
- DependencyPropertyChangedEventArgs.cs
- ValidationError.cs
- GatewayDefinition.cs
- CreateDataSourceDialog.cs
- TextEditorMouse.cs
- FunctionGenerator.cs
- BinaryWriter.cs
- EventManager.cs
- TextRangeEditLists.cs
- ConnectionStringsExpressionBuilder.cs
- InternalConfigRoot.cs
- ExceptionUtil.cs
- FactoryMaker.cs
- XPathNodeHelper.cs
- StructuredTypeEmitter.cs
- ResourceCategoryAttribute.cs
- CodeBlockBuilder.cs
- CellCreator.cs
- MsmqTransportElement.cs
- UInt16Converter.cs
- MobileRedirect.cs
- TypeInfo.cs
- InvokePattern.cs
- SqlBinder.cs
- VirtualPathUtility.cs
- Soap.cs
- MarkupCompilePass2.cs
- ReliableChannelFactory.cs
- MenuStrip.cs
- EditorZoneAutoFormat.cs
- SafeNativeMethodsMilCoreApi.cs
- Attributes.cs
- SmiTypedGetterSetter.cs
- StreamGeometry.cs
- linebase.cs
- EnumMemberAttribute.cs
- FontStretch.cs
- GeneralTransform3DGroup.cs
- PixelShader.cs
- FileChangesMonitor.cs
- ReadOnlyDictionary.cs
- RichTextBoxDesigner.cs
- shaper.cs
- DateTimeHelper.cs
- Form.cs
- TriggerCollection.cs
- SortedDictionary.cs
- TraceListeners.cs
- OptimalTextSource.cs
- Base64Decoder.cs
- _NegoState.cs
- x509store.cs
- DayRenderEvent.cs
- HuffCodec.cs
- URLString.cs
- SectionXmlInfo.cs
- MembershipUser.cs
- ClipboardData.cs
- ResourceProviderFactory.cs
- VoiceInfo.cs
- ToolStripItemImageRenderEventArgs.cs
- SinglePageViewer.cs
- ClientSession.cs
- RewritingProcessor.cs
- DragDrop.cs
- LambdaCompiler.Lambda.cs
- Effect.cs
- OleDbConnection.cs
- CodeAttributeArgument.cs
- DynamicUpdateCommand.cs
- LineProperties.cs
- Rotation3DAnimation.cs
- FormsIdentity.cs
- TraceEventCache.cs
- relpropertyhelper.cs
- WindowsFormsHostPropertyMap.cs
- EditingCoordinator.cs
- BufferedWebEventProvider.cs
- UnmanagedMemoryStream.cs
- ParameterExpression.cs
- FixedDocument.cs
- GACIdentityPermission.cs
- HwndSource.cs
- Style.cs
- DataGridViewComboBoxColumn.cs
- AnnotationMap.cs
- Marshal.cs
- CopyNodeSetAction.cs
- LinqDataSourceUpdateEventArgs.cs
- DataBindingList.cs
- PrivacyNoticeElement.cs
- TypeContext.cs
- SkinBuilder.cs
- XsdValidatingReader.cs
- TextModifierScope.cs
- TraceLevelHelper.cs
- WpfWebRequestHelper.cs
- UnicodeEncoding.cs