/// <summary> /// Read the policy as a LINQ expression /// </summary> /// <param name="rdr">XmlDictionaryReader for the policy Xml</param> /// <returns></returns> public Expression<Func<ClaimsPrincipal, bool>> ReadPolicy(XmlDictionaryReader rdr) { if (rdr.Name != "policy") { throw new InvalidOperationException("Invalid policy document"); } rdr.Read(); if (!rdr.IsStartElement()) { rdr.ReadEndElement(); // There are no claims inside this policy which means allow access to the page. return AllowAccessForDefaultPagePolicy; } // // Instantiate a parameter for the ClaimsPrincipal so it can be evaluated against // each claim constraint. // ParameterExpression subject = Expression.Parameter(typeof(ClaimsPrincipal), "subject"); Expression<Func<ClaimsPrincipal, bool>> result = ReadNode(rdr, subject); rdr.ReadEndElement(); return result; }
public static CloseSequenceResponseInfo Create(XmlDictionaryReader reader) { if (reader == null) { Fx.Assert("Argument reader cannot be null."); } CloseSequenceResponseInfo closeSequenceResponseInfo = new CloseSequenceResponseInfo(); XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(ReliableMessagingVersion.WSReliableMessaging11); reader.ReadStartElement(DXD.Wsrm11Dictionary.CloseSequenceResponse, wsrmNs); reader.ReadStartElement(XD.WsrmFeb2005Dictionary.Identifier, wsrmNs); closeSequenceResponseInfo.Identifier = reader.ReadContentAsUniqueId(); reader.ReadEndElement(); while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); return closeSequenceResponseInfo; }
public void ReadXml( XmlDictionaryReader reader ) { if ( reader == null ) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull( "reader" ); } reader.MoveToContent(); if ( !reader.IsStartElement( XmlEncryptionConstants.Elements.CipherData, XmlEncryptionConstants.Namespace ) ) { throw DiagnosticUtility.ThrowHelperXml( reader, SR.GetString( SR.ID4188 ) ); } reader.ReadStartElement( XmlEncryptionConstants.Elements.CipherData, XmlEncryptionConstants.Namespace ); reader.ReadStartElement( XmlEncryptionConstants.Elements.CipherValue, XmlEncryptionConstants.Namespace ); _cipherText = reader.ReadContentAsBase64(); _iv = null; // <CipherValue> reader.MoveToContent(); reader.ReadEndElement(); // <CipherData> reader.MoveToContent(); reader.ReadEndElement(); }
private static object DeserializeStruct(XmlDictionaryReader reader, Type targetType) { if (targetType.IsDefined(typeof(DataContractAttribute), false)) { Dictionary<string, MemberInfo> dataMembers = GetDataMembers(targetType); object targetObject = Activator.CreateInstance(targetType); reader.ReadStartElement(XmlRpcProtocol.Struct); while( reader.NodeType != XmlNodeType.EndElement ) { string memberName; reader.ReadStartElement(XmlRpcProtocol.Member); reader.ReadStartElement(XmlRpcProtocol.Name); memberName = reader.ReadContentAsString(); reader.ReadEndElement(); reader.ReadStartElement(XmlRpcProtocol.Value); reader.MoveToContent(); if (dataMembers.ContainsKey(memberName)) { MemberInfo member = dataMembers[memberName]; if (member is PropertyInfo) { ((PropertyInfo)member).SetValue( targetObject, Deserialize(reader, ((PropertyInfo)member).PropertyType), BindingFlags.Instance | BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.NonPublic, null, null, CultureInfo.CurrentCulture); } else if (member is FieldInfo) { ((FieldInfo)member).SetValue( targetObject, Deserialize(reader, ((FieldInfo)member).FieldType), BindingFlags.Instance|BindingFlags.SetField|BindingFlags.Public|BindingFlags.NonPublic, null, CultureInfo.CurrentCulture); } } reader.ReadEndElement(); // value reader.ReadEndElement(); // member } reader.ReadEndElement(); // struct reader.MoveToContent(); return targetObject; } else { throw new InvalidOperationException(); } }
/// <summary> /// Reads the body of an object /// </summary> public override object ReadObject(System.Xml.XmlDictionaryReader reader, bool verifyObjectName) { if (reader == null) { throw new ArgumentNullException("reader"); } reader.MoveToContent(); bool isSelfClosed = reader.IsEmptyElement, isNil = reader.GetAttribute("nil") == "true"; reader.ReadStartElement(PROTO_ELEMENT); // explicitly null if (isNil) { if (!isSelfClosed) { reader.ReadEndElement(); } return(null); } if (isSelfClosed) // no real content { if (isList || isEnum) { return(model.Deserialize(Stream.Null, null, type, null)); } using (ProtoReader protoReader = new ProtoReader(Stream.Null, model, null)) { return(model.Deserialize(key, null, protoReader)); } } object result; Helpers.DebugAssert(reader.CanReadBinaryContent, "CanReadBinaryContent"); using (MemoryStream ms = new MemoryStream(reader.ReadContentAsBase64())) { if (isList || isEnum) { result = model.Deserialize(ms, null, type, null); } else { using (ProtoReader protoReader = new ProtoReader(ms, model, null)) { result = model.Deserialize(key, null, protoReader); } } } reader.ReadEndElement(); return(result); }
protected override void OnReadBodyContents(XmlDictionaryReader reader) { base.OnReadBodyContents(reader); reader.ReadStartElement("ResourceCreated", "http://schemas.xmlsoap.org/ws/2004/09/transfer"); reader.Skip(); reader.ReadStartElement("ReferenceParameters", "http://www.w3.org/2005/08/addressing"); XmlUtility.DeserializeObjectReference(reader, out this._objectReference); this._instance = reader.ReadElementString("instance", "http://schemas.microsoft.com/2008/1/ActiveDirectory"); reader.ReadEndElement(); reader.ReadEndElement(); DirectoryControlSerializer.Deserialize(reader, out this._controls, false, false); reader.ReadEndElement(); }
public static CloseSequenceResponseInfo Create(XmlDictionaryReader reader) { CloseSequenceResponseInfo info = new CloseSequenceResponseInfo(); XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(ReliableMessagingVersion.WSReliableMessaging11); reader.ReadStartElement(DXD.Wsrm11Dictionary.CloseSequenceResponse, namespaceUri); reader.ReadStartElement(XD.WsrmFeb2005Dictionary.Identifier, namespaceUri); info.Identifier = reader.ReadContentAsUniqueId(); reader.ReadEndElement(); while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); return info; }
public override void ReadXml(XmlDictionaryReader reader, SamlSerializer samlSerializer, SecurityTokenSerializer keyInfoSerializer, SecurityTokenResolver outOfBandTokenResolver) { if (reader == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader")); } if (samlSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("samlSerializer")); } SamlDictionary samlDictionary = samlSerializer.DictionaryManager.SamlDictionary; if (!reader.IsStartElement(samlDictionary.DoNotCacheCondition, samlDictionary.Namespace)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(System.IdentityModel.SR.GetString("SAMLBadSchema", new object[] { samlDictionary.DoNotCacheCondition.Value }))); } if (reader.IsEmptyElement) { reader.MoveToContent(); reader.Read(); } else { reader.MoveToContent(); reader.Read(); reader.ReadEndElement(); } }
public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName) { reader.ReadStartElement("Data"); var data = reader.ReadContentAsBase64(); reader.ReadEndElement(); return DecodeObject(data); }
public BinaryBodyReader(XmlDictionaryReader reader) { reader.ReadStartElement(BinaryElementName); _data = reader.ReadContentAsBase64(); if (reader.NodeType == XmlNodeType.Text) reader.Read(); reader.ReadEndElement(); }
protected override void OnReadBodyContents(XmlDictionaryReader reader) { reader.ReadStartElement("BaseObjectSearchResponse", "http://schemas.microsoft.com/2006/11/IdentityManagement/DirectoryAccess"); ResultSerializer.Deserialize(reader, ResultSerializer.ResultDialect.XPath1, out this._entry); DirectoryControlSerializer.Deserialize(reader, out this._controls, false, false); reader.ReadEndElement(); }
public override void ReadXml(XmlDictionaryReader reader, SamlSerializer samlSerializer, SecurityTokenSerializer keyInfoSerializer, SecurityTokenResolver outOfBandTokenResolver) { if (reader == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader")); if (samlSerializer == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("samlSerializer")); #pragma warning suppress 56506 // samlSerializer.DictionaryManager is never null. SamlDictionary dictionary = samlSerializer.DictionaryManager.SamlDictionary; if (!reader.IsStartElement(dictionary.DoNotCacheCondition, dictionary.Namespace)) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.SAMLBadSchema, dictionary.DoNotCacheCondition.Value))); // saml:DoNotCacheCondition is a empty element. So just issue a read for // the empty element. if (reader.IsEmptyElement) { reader.MoveToContent(); reader.Read(); return; } reader.MoveToContent(); reader.Read(); reader.ReadEndElement(); }
public void ReadFrom(XmlDictionaryReader reader, long maxBufferSize) { this.ValidateReadState(); reader.MoveToStartElement(this.OpeningElementName, NamespaceUri); this.encoding = reader.GetAttribute(EncodingAttribute, null); this.id = reader.GetAttribute(System.ServiceModel.XD.XmlEncryptionDictionary.Id, null) ?? System.ServiceModel.Security.SecurityUniqueId.Create().Value; this.wsuId = reader.GetAttribute(System.ServiceModel.XD.XmlEncryptionDictionary.Id, System.ServiceModel.XD.UtilityDictionary.Namespace) ?? System.ServiceModel.Security.SecurityUniqueId.Create().Value; this.mimeType = reader.GetAttribute(MimeTypeAttribute, null); this.type = reader.GetAttribute(TypeAttribute, null); this.ReadAdditionalAttributes(reader); reader.Read(); if (reader.IsStartElement(EncryptionMethodElement.ElementName, NamespaceUri)) { this.encryptionMethod.ReadFrom(reader); } if (this.tokenSerializer.CanReadKeyIdentifier(reader)) { this.KeyIdentifier = this.tokenSerializer.ReadKeyIdentifier(reader); } reader.ReadStartElement(CipherDataElementName, NamespaceUri); reader.ReadStartElement(CipherValueElementName, NamespaceUri); if (maxBufferSize == 0L) { this.ReadCipherData(reader); } else { this.ReadCipherData(reader, maxBufferSize); } reader.ReadEndElement(); reader.ReadEndElement(); this.ReadAdditionalElements(reader); reader.ReadEndElement(); this.State = EncryptionState.Read; }
internal X509CertificateEndpointIdentity(XmlDictionaryReader reader) { if (reader == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader"); reader.MoveToContent(); if (reader.IsEmptyElement) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.UnexpectedEmptyElementExpectingClaim, XD.AddressingDictionary.X509v3Certificate.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value))); reader.ReadStartElement(XD.XmlSignatureDictionary.X509Data, XD.XmlSignatureDictionary.Namespace); while (reader.IsStartElement(XD.XmlSignatureDictionary.X509Certificate, XD.XmlSignatureDictionary.Namespace)) { reader.MoveToContent(); X509Certificate2 certificate = new X509Certificate2(Convert.FromBase64String(reader.ReadContentAsString())); if (certificateCollection.Count == 0) { // This is the first certificate. We assume this as the primary // certificate and initialize the base class. Initialize(new Claim(ClaimTypes.Thumbprint, certificate.GetCertHash(), Rights.PossessProperty)); } certificateCollection.Add(certificate); } reader.ReadEndElement(); if (certificateCollection.Count == 0) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.UnexpectedEmptyElementExpectingClaim, XD.AddressingDictionary.X509v3Certificate.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value))); }
public static ResourceUriHeader ReadFrom(XmlDictionaryReader reader) { reader.ReadStartElement(ElementName, ManagementNamespaces.Namespace); string result = reader.Value; reader.Read(); reader.ReadEndElement(); return new ResourceUriHeader(result); }
public override SecurityKeyIdentifierClause ReadKeyIdentifierClauseCore(XmlDictionaryReader reader) { string encryptionMethod = null; string carriedKeyName = null; SecurityKeyIdentifier encryptingKeyIdentifier = null; byte[] encryptedKey = null; reader.ReadStartElement(XD.XmlEncryptionDictionary.EncryptedKey, NamespaceUri); if (reader.IsStartElement(XD.XmlEncryptionDictionary.EncryptionMethod, NamespaceUri)) { encryptionMethod = reader.GetAttribute(XD.XmlEncryptionDictionary.AlgorithmAttribute, null); bool isEmptyElement = reader.IsEmptyElement; reader.ReadStartElement(); if (!isEmptyElement) { while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); } } if (this.securityTokenSerializer.CanReadKeyIdentifier(reader)) { encryptingKeyIdentifier = this.securityTokenSerializer.ReadKeyIdentifier(reader); } reader.ReadStartElement(XD.XmlEncryptionDictionary.CipherData, NamespaceUri); reader.ReadStartElement(XD.XmlEncryptionDictionary.CipherValue, NamespaceUri); encryptedKey = reader.ReadContentAsBase64(); reader.ReadEndElement(); reader.ReadEndElement(); if (reader.IsStartElement(XD.XmlEncryptionDictionary.CarriedKeyName, NamespaceUri)) { reader.ReadStartElement(); carriedKeyName = reader.ReadString(); reader.ReadEndElement(); } reader.ReadEndElement(); return new EncryptedKeyIdentifierClause(encryptedKey, encryptionMethod, encryptingKeyIdentifier, carriedKeyName); }
public static TotalItemsCountEstimate ReadFrom(XmlDictionaryReader reader) { reader.ReadStartElement(ElementName, ManagementNamespaces.Namespace); int value = XmlConvert.ToInt32(reader.ReadString()); TotalItemsCountEstimate result = new TotalItemsCountEstimate(value); reader.ReadEndElement(); return result; }
public static IdentifierHeader ReadFrom(XmlDictionaryReader reader) { reader.ReadStartElement(ElementName, EventingActions.Namespace); string result = reader.Value; reader.Read(); reader.ReadEndElement(); return new IdentifierHeader(result); }
public InvalidAcknowledgementFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader, ReliableMessagingVersion reliableMessagingVersion) : base(code, "InvalidAcknowledgement", reason, true, false) { UniqueId id; bool flag; WsrmAcknowledgmentInfo.ReadAck(reliableMessagingVersion, detailReader, out id, out this.ranges, out flag); base.SequenceID = id; while (detailReader.IsStartElement()) { detailReader.Skip(); } detailReader.ReadEndElement(); }
public static WsrmAckRequestedInfo ReadHeader(ReliableMessagingVersion reliableMessagingVersion, XmlDictionaryReader reader, MessageHeaderInfo header) { WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary; XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(reliableMessagingVersion); reader.ReadStartElement(); reader.ReadStartElement(dictionary.Identifier, namespaceUri); UniqueId sequenceID = reader.ReadContentAsUniqueId(); reader.ReadEndElement(); if ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005) && reader.IsStartElement(dictionary.MessageNumber, namespaceUri)) { reader.ReadStartElement(); WsrmUtilities.ReadSequenceNumber(reader, true); reader.ReadEndElement(); } while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); return new WsrmAckRequestedInfo(sequenceID, header); }
public static FragmentTransferHeader ReadFrom(XmlDictionaryReader reader) { reader.ReadStartElement(ElementName, Const.ManagementNamespace); StringBuilder fragment = new StringBuilder(); while (reader.NodeType == XmlNodeType.Text) { fragment.Append(reader.Value); reader.Read(); } FragmentTransferHeader result = new FragmentTransferHeader(fragment.ToString()); reader.ReadEndElement(); return result; }
public static MaxEnvelopeSizeHeader ReadFrom(XmlDictionaryReader reader) { reader.ReadStartElement(ElementName, Const.ManagementNamespace); var fragment = new StringBuilder(); while (reader.NodeType == XmlNodeType.Text) { fragment.Append(reader.Value); reader.Read(); } var result = new MaxEnvelopeSizeHeader(int.Parse(fragment.ToString())); reader.ReadEndElement(); return result; }
public static CloseSequenceInfo Create(XmlDictionaryReader reader) { CloseSequenceInfo info = new CloseSequenceInfo(); XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(ReliableMessagingVersion.WSReliableMessaging11); Wsrm11Dictionary dictionary = DXD.Wsrm11Dictionary; reader.ReadStartElement(dictionary.CloseSequence, namespaceUri); reader.ReadStartElement(XD.WsrmFeb2005Dictionary.Identifier, namespaceUri); info.Identifier = reader.ReadContentAsUniqueId(); reader.ReadEndElement(); if (reader.IsStartElement(dictionary.LastMsgNumber, namespaceUri)) { reader.ReadStartElement(); info.LastMsgNumber = WsrmUtilities.ReadSequenceNumber(reader, false); reader.ReadEndElement(); } while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); return info; }
public Expression<Func<ClaimsPrincipal, bool>> ReadPolicy(XmlDictionaryReader rdr) { if (rdr.Name != "policy") { throw new InvalidOperationException("Invalid policy document"); } rdr.Read(); if (!rdr.IsStartElement()) { rdr.ReadEndElement(); return AllowAccessForDefaultPagePolicy; } ParameterExpression subject = Expression.Parameter(typeof(ClaimsPrincipal), "subject"); Expression<Func<ClaimsPrincipal, bool>> result = ReadNode(rdr, subject); rdr.ReadEndElement(); return result; }
private Expression<Func<ClaimsPrincipal, bool>> ReadAnd(XmlDictionaryReader rdr, ParameterExpression subject) { rdr.Read(); BinaryExpression lambda1 = Expression.AndAlso( Expression.Invoke(ReadNode(rdr, subject), subject), Expression.Invoke(ReadNode(rdr, subject), subject)); rdr.ReadEndElement(); Expression<Func<ClaimsPrincipal, bool>> lambda2 = Expression.Lambda<Func<ClaimsPrincipal, bool>>(lambda1, subject); return lambda2; }
public static CreateSequenceResponseInfo Create(AddressingVersion addressingVersion, ReliableMessagingVersion reliableMessagingVersion, XmlDictionaryReader reader) { CreateSequenceResponseInfo info = new CreateSequenceResponseInfo(); WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary; XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(reliableMessagingVersion); reader.ReadStartElement(dictionary.CreateSequenceResponse, namespaceUri); reader.ReadStartElement(dictionary.Identifier, namespaceUri); info.Identifier = reader.ReadContentAsUniqueId(); reader.ReadEndElement(); if (reader.IsStartElement(dictionary.Expires, namespaceUri)) { reader.ReadElementContentAsTimeSpan(); } if ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) && reader.IsStartElement(DXD.Wsrm11Dictionary.IncompleteSequenceBehavior, namespaceUri)) { string str2 = reader.ReadElementContentAsString(); if (((str2 != "DiscardEntireSequence") && (str2 != "DiscardFollowingFirstGap")) && (str2 != "NoDiscard")) { string message = System.ServiceModel.SR.GetString("CSResponseWithInvalidIncompleteSequenceBehavior"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(message)); } } if (reader.IsStartElement(dictionary.Accept, namespaceUri)) { reader.ReadStartElement(); info.AcceptAcksTo = EndpointAddress.ReadFrom(addressingVersion, reader, dictionary.AcksTo, namespaceUri); while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); } while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); return info; }
internal RsaEndpointIdentity(XmlDictionaryReader reader) { reader.ReadStartElement(XD.XmlSignatureDictionary.RsaKeyValue, XD.XmlSignatureDictionary.Namespace); byte[] modulus = Convert.FromBase64String(reader.ReadElementString(XD.XmlSignatureDictionary.Modulus.Value, XD.XmlSignatureDictionary.Namespace.Value)); byte[] exponent = Convert.FromBase64String(reader.ReadElementString(XD.XmlSignatureDictionary.Exponent.Value, XD.XmlSignatureDictionary.Namespace.Value)); reader.ReadEndElement(); RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); RSAParameters parameters = new RSAParameters(); parameters.Exponent = exponent; parameters.Modulus = modulus; rsa.ImportParameters(parameters); base.Initialize(Claim.CreateRsaClaim(rsa)); }
public static MakeConnectionMessageInfo Create(XmlDictionaryReader reader) { MakeConnectionMessageInfo makeConnectionInfo = new MakeConnectionMessageInfo(); if (reader.IsStartElement(MakeConnectionConstants.MakeConnectionMessage.Name, MakeConnectionConstants.Namespace)) { reader.ReadStartElement(); reader.MoveToContent(); while (reader.IsStartElement()) { if (reader.IsStartElement(MakeConnectionConstants.MakeConnectionMessage.AddressElement, MakeConnectionConstants.Namespace)) { if (!string.IsNullOrEmpty(makeConnectionInfo.Address)) { makeConnectionInfo.MultipleAddressHeaders = true; reader.Skip(); } else { makeConnectionInfo.Address = reader.ReadElementContentAsString(); } } else if (reader.IsStartElement(MakeConnectionConstants.MakeConnectionMessage.IdentifierElement, MakeConnectionConstants.Namespace)) { if (makeConnectionInfo.Identifier != null) { makeConnectionInfo.MultipleIdentifierHeaders = true; reader.Skip(); } else { makeConnectionInfo.Identifier = reader.ReadElementContentAsUniqueId(); } } else { if (string.IsNullOrEmpty(makeConnectionInfo.UnknownSelection)) { makeConnectionInfo.UnknownSelection = reader.LocalName; } reader.Skip(); } } reader.ReadEndElement(); } return makeConnectionInfo; }
protected override void ReadAdditionalElements(XmlDictionaryReader reader) { if (reader.IsStartElement(System.ServiceModel.Security.ReferenceList.ElementName, EncryptedType.NamespaceUri)) { this.referenceList = new System.ServiceModel.Security.ReferenceList(); this.referenceList.ReadFrom(reader); } if (reader.IsStartElement(CarriedKeyElementName, EncryptedType.NamespaceUri)) { reader.ReadStartElement(CarriedKeyElementName, EncryptedType.NamespaceUri); this.carriedKeyName = reader.ReadString(); reader.ReadEndElement(); } }
public void ReadFrom(XmlDictionaryReader reader, DictionaryManager dictionaryManager) { reader.MoveToStartElement(dictionaryManager.XmlSignatureDictionary.Signature, dictionaryManager.XmlSignatureDictionary.Namespace); this.prefix = reader.Prefix; this.Id = reader.GetAttribute(dictionaryManager.UtilityDictionary.IdAttribute, null); reader.Read(); this.signedInfo.ReadFrom(reader, this.signedXml.TransformFactory, dictionaryManager); this.signatureValueElement.ReadFrom(reader, dictionaryManager); if (this.signedXml.SecurityTokenSerializer.CanReadKeyIdentifier(reader)) { this.keyIdentifier = this.signedXml.SecurityTokenSerializer.ReadKeyIdentifier(reader); } reader.ReadEndElement(); }
public override void ReadEndElement() { reader.ReadEndElement(); }
internal X509CertificateEndpointIdentity(XmlDictionaryReader reader) { this.certificateCollection = new X509Certificate2Collection(); if (reader == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader"); } reader.MoveToContent(); if (reader.IsEmptyElement) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("UnexpectedEmptyElementExpectingClaim", new object[] { XD.AddressingDictionary.X509v3Certificate.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value }))); } reader.ReadStartElement(XD.XmlSignatureDictionary.X509Data, XD.XmlSignatureDictionary.Namespace); while (reader.IsStartElement(XD.XmlSignatureDictionary.X509Certificate, XD.XmlSignatureDictionary.Namespace)) { X509Certificate2 certificate = new X509Certificate2(Convert.FromBase64String(reader.ReadElementString())); if (this.certificateCollection.Count == 0) { base.Initialize(new Claim(ClaimTypes.Thumbprint, certificate.GetCertHash(), Rights.PossessProperty)); } this.certificateCollection.Add(certificate); } reader.ReadEndElement(); if (this.certificateCollection.Count == 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("UnexpectedEmptyElementExpectingClaim", new object[] { XD.AddressingDictionary.X509v3Certificate.Value, XD.AddressingDictionary.IdentityExtensionNamespace.Value }))); } }