Changeset 2541


Ignore:
Timestamp:
Jan 31, 2011, 7:07:17 PM (10 years ago)
Author:
Tim Podeszwa
Message:

code reworked

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/WebService/SignatureValidator.cs

    r639 r2541  
    1313namespace WebService
    1414{
    15    public class SignatureValidator
    16    {
    17        private XmlDocument inputString, tempdocument;
    18        private ArrayList wsSecurityHeaderElements;
    19        private ArrayList referenceList,encryptedDataList, decryptedDataList, encryptedKeyElements;
    20        private XmlElement reference;
    21        private WSSecurityTracer tracer;
    22        public string canonicalizedSignedInfo;
    23        private WebService webService;
    24        private SignedXml signedXml;
    25        private ArrayList signatureReferenceList;
    26        private XmlElement transformedElement;
    27        private Canonicalizator canon;
    28        private XmlNode securityHeader;
    29        public bool valid;
    30        
    31        private struct SignatureReference
    32        {
    33           public int nr;
    34           public Signature signature;
    35           public ArrayList references;
    36        }
    37      
    38        public SignatureValidator(WebService webService)
    39        {
    40            valid = true;
    41            this.inputString = (XmlDocument)webService.InputString.Clone();
    42            this.canon = new Canonicalizator(this.inputString);
    43            this.tempdocument = (XmlDocument)this.inputString.Clone();
    44            this.wsSecurityHeaderElements = new ArrayList();
    45            encryptedDataList = new ArrayList();
    46            decryptedDataList = new ArrayList();
    47            encryptedKeyElements = new ArrayList();
    48            this.referenceList = new ArrayList();
    49            this.webService = webService;
    50 
    51           signedXml = new SignedXml(inputString);
    52           signatureReferenceList = new ArrayList();
    53          securityHeader= this.inputString.GetElementsByTagName("wsse:Security")[0];
    54          if (securityHeader != null)
    55          {
    56              foreach (XmlElement tempElement in securityHeader)
    57              {
    58                  if (tempElement.Name.Equals("xenc:EncryptedData"))
    59                  {
    60                      this.dercryptElement((XmlElement)wsSecurityHeaderElements[0]);
    61                      this.fillSecurityHeaderElementsList();
    62                  }
    63                  this.wsSecurityHeaderElements.Add(tempElement);
    64              }
    65          }
    66 
    67        
    68            tracer = new WSSecurityTracer();
    69            
    70        
    71           foreach (XmlElement tempElement in wsSecurityHeaderElements)
    72           {
    73               if (tempElement.Name.Equals("xenc:EncryptedKey"))
    74               {
    75                   try
    76                   {
    77                       this.dercryptElement(tempElement);
    78                   }
    79                   catch(Exception e)
    80                   {
    81                       this.webService.showError(e.Message);
    82                       valid = false;
    83                   }
    84               }
    85               if (tempElement.Name.Equals("ds:Signature"))
    86               {
    87                  
    88                      
    89                           this.validateSignature(tempElement);
    90                      
    91                  
    92                  
    93               }
    94              
    95           }
    96           this.webService.presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    97           {
    98               this.webService.presentation.txtTrace.Text += this.tracer.signatureTrace;
    99               this.webService.presentation.txtTrace.Text += this.tracer.decryptionTrace;
    100 
    101 
    102 
    103 
    104           }, null);
    105    this.webService.modifiedInput = this.inputString;
    106        }
    107 
    108        private void fillSecurityHeaderElementsList()
    109        {
    110            this.wsSecurityHeaderElements.Clear();
    111           securityHeader= this.inputString.GetElementsByTagName("wsse:Security")[0];
    112           foreach (XmlElement tempElement in securityHeader)
    113           {
    114               this.wsSecurityHeaderElements.Add(tempElement);
    115           }
    116        }
    117        #region Decryption
    118        
    119        public string dercryptElement(XmlElement encryptedKeyElement)
    120        {
    121           // XmlDocument doc = (XmlDocument)this.inputString.Clone();
    122            EncryptedKey encKey = new EncryptedKey();
    123          
    124            encKey.LoadXml(encryptedKeyElement);
    125            ReferenceList referenceList = encKey.ReferenceList;
    126            EncryptedReference encryptedReference=referenceList.Item(0);
    127            string uri=encryptedReference.Uri;
    128            KeyInfo keyInfo = encKey.KeyInfo;
    129        
    130            this.referenceList.Clear();
    131            ArrayList referenceElementList = this.findEle(uri, this.inputString.ChildNodes[1]);
    132            XmlElement keyInfoElement = this.inputString.CreateElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
    133            keyInfoElement.AppendChild(encryptedKeyElement);
    134            XmlElement encryptedDataElement = (XmlElement)referenceElementList[0];
    135          //  encryptedDataElement.InsertAfter(keyInfoElement, encryptedDataElement.GetElementsByTagName("EncryptionMethod")[0]);
    136          
    137            RSACryptoServiceProvider provider = this.webService.provider;
    138            XmlDocument doc= new XmlDocument();
    139            XmlElement root= doc.CreateElement("root");
    140            root.AppendChild(doc.ImportNode((XmlNode)encryptedKeyElement, true));
    141            root.AppendChild(doc.ImportNode(encryptedDataElement,true));
    142      
    143            doc.AppendChild(root);
    144            EncryptedXml encxml2 = new EncryptedXml(doc);
    145            EncryptedKey encKey2= new EncryptedKey();
    146            encKey2.LoadXml((XmlElement)doc.GetElementsByTagName("xenc:EncryptedKey")[0]);
    147            EncryptedData encData2 = new EncryptedData();
    148            EncryptedData encDataElement2= new EncryptedData();
    149            XmlElement data2=(XmlElement) doc.GetElementsByTagName("xenc:EncryptedData")[0];
    150            encDataElement2.LoadXml((XmlElement)doc.GetElementsByTagName("xenc:EncryptedData")[0]);
    151            encxml2.AddKeyNameMapping("Web Service Public Key", provider);
    152 
    153            SymmetricAlgorithm algo2 = SymmetricAlgorithm.Create();
    154            algo2.Key = encxml2.DecryptEncryptedKey(encKey2);
    155            byte[] t2 = encxml2.DecryptData(encDataElement2, algo2);
    156            encxml2.ReplaceData(data2, t2);
    157            doc.GetElementsByTagName("root")[0].RemoveChild(doc.GetElementsByTagName("xenc:EncryptedKey")[0]);
    158          
    159            tracer.appendDecryptedData(uri,doc.FirstChild.InnerXml);
    160            
    161            EncryptedXml encXml = new EncryptedXml(this.inputString);
    162            encXml.AddKeyNameMapping("Web Service Public Key", provider);
    163          //  encXml.DecryptDocument();
    164            EncryptedData data = new EncryptedData();
    165            data.LoadXml((XmlElement)encryptedDataElement);
    166            SymmetricAlgorithm algo = SymmetricAlgorithm.Create();
    167            algo.Key = encXml.DecryptEncryptedKey(encKey);
    168          byte[] t=  encXml.DecryptData(data, algo);
    169          encXml.ReplaceData(encryptedDataElement, t);
    170          this.encryptedDataList.Add(encryptedDataElement);
    171          this.decryptedDataList.Add(doc.GetElementsByTagName("root")[0]);
    172          this.encryptedKeyElements.Add(encryptedKeyElement);
    173          string decryptedXmlString;
    174          return decryptedXmlString=Convert.ToBase64String(t);
    175          //  this.webService.InputString = this.inputString;
    176 
    177 
    178        }
    179        public XmlElement decryptSingleElement(int encryptedKeyNumber)
    180        {
    181            XmlElement decryptedXmlElement;
    182            EncryptedKey encKey = new EncryptedKey();
    183             encKey.LoadXml((XmlElement)encryptedKeyElements[encryptedKeyNumber]);
    184          
    185            ReferenceList referenceList = encKey.ReferenceList;
    186            EncryptedReference encryptedReference = referenceList.Item(0);
    187            string uri = encryptedReference.Uri;
    188            KeyInfo keyInfo = encKey.KeyInfo;
    189 
    190            this.referenceList.Clear();
    191            ArrayList referenceElementList= new ArrayList();
    192             referenceElementList   = this.findEle(uri, this.tempdocument.ChildNodes[1]);
    193            XmlElement keyInfoElement = this.tempdocument.CreateElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
    194            keyInfoElement.AppendChild(tempdocument.ImportNode((XmlNode) encKey.GetXml(),true));
    195            XmlElement encryptedDataElement = (XmlElement)referenceElementList[0];
    196            //  encryptedDataElement.InsertAfter(keyInfoElement, encryptedDataElement.GetElementsByTagName("EncryptionMethod")[0]);
    197 
    198            RSACryptoServiceProvider provider = this.webService.provider;
    199        
    200 
    201        
    202 
    203        
    204            EncryptedXml encXml = new EncryptedXml(this.tempdocument);
    205            encXml.AddKeyNameMapping("Web Service Public Key", provider);
    206            //  encXml.DecryptDocument();
    207            EncryptedData data = new EncryptedData();
    208            data.LoadXml((XmlElement)encryptedDataElement);
    209            SymmetricAlgorithm algo = SymmetricAlgorithm.Create();
    210            algo.Key = encXml.DecryptEncryptedKey(encKey);
    211            byte[] t = encXml.DecryptData(data, algo);
    212            encXml.ReplaceData(encryptedDataElement, t);
    213 
    214            this.tempdocument.GetElementsByTagName("wsse:Security")[0].RemoveChild(tempdocument.GetElementsByTagName("xenc:EncryptedKey")[0]);
    215            string decryptedXmlString;
    216            XmlElement root = (XmlElement)this.decryptedDataList[encryptedKeyNumber];
    217            //if(root.FirstChild.NodeType.Equals(XmlNodeType.Text))
    218            //{
    219            //    decryptedXmlElement = tempdocument.CreateElement("TextElement");
    220            //    XmlNode textNode = root.FirstChild.Clone();
    221            //    decryptedXmlElement.AppendChild(textNode);
    222            //}
    223 
    224            
    225              //  (XmlElement)root.FirstChild;
    226          
    227            return (XmlElement)root;
    228            //  this.webService.InputString = this.inputString;
    229        }
    230 
    231        #endregion
    232 
    233        #region Signatur Check
    234 
    235        public bool validateSignature(XmlElement signatureElement)
    236        {bool valid= true;
    237            if (valid)
    238            {
    239            }
    240            
    241            Signature signature = new Signature();
    242            signature.LoadXml(signatureElement);
    243            XmlNodeList signatureList = this.inputString.GetElementsByTagName("ds:Signature");
    244            if (signatureList.Count != 0)
    245            {
    246                
    247            
    248            signedXml.LoadXml((XmlElement)signatureElement);
    249           // XmlNodeList signatureList = this.inputString.GetElementsByTagName("Signature");
    250          bool validReference=  validateReferences(signedXml);
    251          if (validReference)
    252          {
    253              canonicalizeSignedInfo(signature.SignedInfo.GetXml());
    254              signedXml.LoadXml((XmlElement)signatureElement);
    255          }
    256          else
    257          {
    258             this.valid = false;
    259          }
    260              
    261                  
    262                
    263              
    264 
    265              
    266                
    267            
    268            }
    269            return valid;
    270          
    271            
    272        }
    273        public void canonicalizeSignedInfo(XmlElement SignedInfo)
    274        {   
    275            Canonicalizator canon = new Canonicalizator(inputString);
    276            //StreamReader sreader = new StreamReader(stream2);
    277            // string test3 = sreader.ReadToEnd();
    278            //return test3;
    279        Stream stream=    canon.canonicalizeNode(SignedInfo);
    280        StreamReader sreader = new StreamReader(stream);
    281        string canonString = sreader.ReadToEnd();
    282        this.canonicalizedSignedInfo = canonString;
    283        this.validateSignature(this.signedXml.Signature, signedXml.SignatureValue);
    284          
    285        }
    286      
    287        public ArrayList getSignedXmlSignatureReferences()
    288        {
    289            return signedXml.SignedInfo.References;
    290        }
    291        public bool validateReferences(SignedXml signedXml)
    292        {
    293            byte[] digest;
    294           ArrayList references = signedXml.SignedInfo.References;
    295           int i = 1;
    296            foreach(Reference reference in references)
    297            {
    298 
    299              
    300                string uri= reference.Uri;
    301          
    302                string hashAlgorithm = reference.DigestMethod;
    303                if (!uri.Equals(""))
    304                {
    305                    this.referenceList.Clear();
    306                    SignatureReference sigReference = new SignatureReference();
    307                    sigReference.nr = i;
    308                    i++;
    309                    sigReference.references = new ArrayList();
    310                    ArrayList newList = new ArrayList();
    311                   newList=this.findEle(uri, this.inputString.ChildNodes[0].NextSibling);
    312                   XmlElement referenceEle= (XmlElement)newList[0];
    313                   XmlElement clone = (XmlElement)referenceEle.Clone();
    314                   newList = (ArrayList)this.referenceList.Clone();
    315                   sigReference.references.Add(clone);
    316                    this.signatureReferenceList.Add(sigReference);
    317 
    318            
    319                }
    320                if (uri.Equals(""))
    321                {
    322                    XmlNode node=null;
    323                    SignatureReference sigReference = new SignatureReference();
    324                    sigReference.nr = i;
    325                    i++;
    326                    ArrayList list= new ArrayList();
    327                    XmlDocument doc = new XmlDocument();
    328                    Transform trans = reference.TransformChain[0];
    329                    XmlDsigXPathTransform xpathTransform = (XmlDsigXPathTransform)trans;
    330                    XmlElement xpathElement = xpathTransform.GetXml();
    331                    string xpath = xpathElement.InnerText;
    332                    XmlNamespaceManager manager = new XmlNamespaceManager(this.inputString.NameTable);
    333                    XmlElement b = (XmlElement)this.inputString.GetElementsByTagName("s:Body")[0];
    334                    manager.AddNamespace("s", b.NamespaceURI);
    335                    manager.AddNamespace("tns", "http://tempuri.org/");
    336                    node = this.inputString.SelectSingleNode(xpath, manager);
    337                    list.Add((XmlElement)node.Clone());
    338                    sigReference.references = list;
    339                    this.signatureReferenceList.Add(sigReference);
    340                }
    341             XmlElement referenceTransformed= this.applyTransform(reference);
    342              digest=digestElement(referenceTransformed,hashAlgorithm,"");
    343            string digestValue= Convert.ToBase64String(digest);
    344          
    345            this.tracer.appendReferenceValidation(uri, digestValue);
    346          string convertedDigest=Convert.ToBase64String(reference.DigestValue);
    347          if (convertedDigest.Equals(digestValue))
    348          {
    349              return true;
    350          }
    351          else { return false; }
    352          
    353                
    354 
    355            }
    356            return false;
    357        }
    358        public XmlElement applyTransform(Reference reference)
    359        {
    360            XmlNode node=null;
    361            TransformChain transformChain = reference.TransformChain;
    362            int transCounter = transformChain.Count;
    363            IEnumerator enumerator=transformChain.GetEnumerator();
    364            Stream transformstream = new MemoryStream();
    365            if (reference.Uri.Equals(""))
    366            {
    367 
    368                this.inputString.Save(transformstream);
    369                transformstream.Position = 0;
    370 
    371            }
    372            else
    373            {
    374 
    375                XmlNodeReader reader = new XmlNodeReader((XmlNode)this.reference);
    376 
    377                XmlWriter writer = new XmlTextWriter(transformstream, Encoding.UTF8);
    378                writer.WriteNode(reader, false);
    379                writer.Flush();
    380                transformstream.Position = 0;
    381            }
    382            for (int i = 0; i < transCounter; i++)
    383            {
    384                XmlUrlResolver test = new XmlUrlResolver();
    385 
    386                SignedXml t = signedXml;
    387                enumerator.MoveNext();
    388              
    389                Transform trans = (Transform) enumerator.Current;
    390                string typ = trans.ToString();
    391                XmlElement input;
    392                
    393                
    394              
    395                switch (typ)
    396                {
    397                    case "System.Security.Cryptography.Xml.XmlDsigExcC14NTransform":
    398 
    399                        if (!reference.Uri.Equals(""))
    400                        {
    401                            for (int j = 0; j < referenceList.Count; j++)
    402                            {
    403                                XmlElement temp = (XmlElement)referenceList[j];
    404                                string uri = "#" + temp.Attributes["Id"].Value;
    405                                if (uri.Equals(reference.Uri))
    406                                {
    407                                    node = temp;
    408                                }
    409                            }
    410                            
    411                        }
    412                    
    413                        break;
    414                    case "System.Security.Cryptography.Xml.XmlDsigXPathTransform":
    415                        XmlDocument doc= new XmlDocument();
    416                        XmlDsigXPathTransform xpathTransform = (XmlDsigXPathTransform)trans;
    417                        XmlElement xpathElement=xpathTransform.GetXml();
    418                        string xpath = xpathElement.InnerText;
    419                        XmlNamespaceManager manager = new XmlNamespaceManager(this.inputString.NameTable);
    420                        XmlElement b = (XmlElement)this.inputString.GetElementsByTagName("s:Body")[0];
    421                        manager.AddNamespace("s", b.NamespaceURI);
    422                        manager.AddNamespace("tns", "http://tempuri.org/");
    423                        node = this.inputString.SelectSingleNode(xpath,manager);
     15    public class SignatureValidator
     16    {
     17        #region Fields
     18
     19        private XmlDocument _inputDocument;
     20        private XmlDocument _tempdocument;
     21        private ArrayList _wsSecurityHeaderList;
     22        private ArrayList _referenceList;
     23        private ArrayList _encryptedDataList;
     24        private ArrayList _decryptedDataList;
     25        private ArrayList _encryptedKeyElements;
     26        private XmlElement _reference;
     27        private WSSecurityTracer _tracer;
     28        public string _canonicalizedSignedInfo;
     29        private WebService _webService;
     30        private SignedXml _signedXml;
     31        private ArrayList _signatureReferenceList;
     32        private XmlElement transformedElement;
     33        private Canonicalizator _canonicalizator;
     34        private XmlNode _securityHeader;
     35        private bool _valid;
     36        private struct SignatureReference
     37        {
     38            public int nr;
     39            public ArrayList references;
     40        }
     41
     42        #endregion
     43
     44        #region Properties
     45
     46        public bool Valid
     47        {
     48            get
     49            {
     50                return this._valid;
     51            }
     52        }
     53
     54        #endregion
     55
     56        #region Constructor
     57
     58        public SignatureValidator(WebService webService)
     59        {
     60            this._valid = true;
     61            this._inputDocument = (XmlDocument)webService.InputString.Clone();
     62            this._canonicalizator = new Canonicalizator(this._inputDocument);
     63            this._tempdocument = (XmlDocument)this._inputDocument.Clone();
     64            this._wsSecurityHeaderList = new ArrayList();
     65            this._encryptedDataList = new ArrayList();
     66            this._decryptedDataList = new ArrayList();
     67            this._encryptedKeyElements = new ArrayList();
     68            this._referenceList = new ArrayList();
     69            this._webService = webService;
     70            this._signedXml = new SignedXml(this._inputDocument);
     71            this._signatureReferenceList = new ArrayList();
     72            this._securityHeader = this._inputDocument.GetElementsByTagName("wsse:Security")[0];
     73            if (this._securityHeader != null)
     74            {
     75                foreach (XmlElement securityHeader in this._securityHeader)
     76                {
     77                    if (securityHeader.Name.Equals("xenc:EncryptedData"))
     78                    {
     79                        this.DercryptSingleXmlElement((XmlElement)this._wsSecurityHeaderList[0]);
     80                        this.FillSecurityHeaderElementsList();
     81                    }
     82                    this._wsSecurityHeaderList.Add(securityHeader);
     83                }
     84            }
     85
     86            this._tracer = new WSSecurityTracer();
     87
     88
     89            foreach (XmlElement tempElement in this._wsSecurityHeaderList)
     90            {
     91                if (tempElement.Name.Equals("xenc:EncryptedKey"))
     92                {
     93                    try
     94                    {
     95                        this.DercryptSingleXmlElement(tempElement);
     96                    }
     97                    catch (Exception e)
     98                    {
     99                        this._webService.showError(e.Message);
     100                        this._valid = false;
     101                    }
     102                }
     103                if (tempElement.Name.Equals("ds:Signature"))
     104                {
     105                    this.ValidateSignature(tempElement);
     106                }
     107
     108            }
     109            this._webService.presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     110            {
     111                this._webService.presentation.txtTrace.Text += this._tracer.signatureTrace;
     112                this._webService.presentation.txtTrace.Text += this._tracer.decryptionTrace;
     113            }, null);
     114            this._webService.modifiedInput = this._inputDocument;
     115        }
     116
     117        #endregion
     118
     119        #region Methods
     120
     121        private void FillSecurityHeaderElementsList()
     122        {
     123            this._wsSecurityHeaderList.Clear();
     124            this._securityHeader = this._inputDocument.GetElementsByTagName("wsse:Security")[0];
     125            foreach (XmlElement tempElement in _securityHeader)
     126            {
     127                this._wsSecurityHeaderList.Add(tempElement);
     128            }
     129        }
     130        private string DercryptSingleXmlElement(XmlElement encryptedKeyElement)
     131        {
     132            EncryptedKey encryptdKey = new EncryptedKey();
     133            encryptdKey.LoadXml(encryptedKeyElement);
     134            ReferenceList referenceList = encryptdKey.ReferenceList;
     135            EncryptedReference encryptedReference = referenceList.Item(0);
     136            string uri = encryptedReference.Uri;
     137            KeyInfo keyInfo = encryptdKey.KeyInfo;
     138            this._referenceList.Clear();
     139            ArrayList referenceElementList = this.FindXmlElementByURI(uri, this._inputDocument.ChildNodes[1]);
     140            XmlElement keyInfoElement = this._inputDocument.CreateElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
     141            keyInfoElement.AppendChild(encryptedKeyElement);
     142            XmlElement encryptedDataElement = (XmlElement)referenceElementList[0];
     143            RSACryptoServiceProvider provider = this._webService.provider;
     144            XmlDocument doc = new XmlDocument();
     145            XmlElement root = doc.CreateElement("root");
     146            root.AppendChild(doc.ImportNode((XmlNode)encryptedKeyElement, true));
     147            root.AppendChild(doc.ImportNode(encryptedDataElement, true));
     148            doc.AppendChild(root);
     149            EncryptedXml encxml2 = new EncryptedXml(doc);
     150            EncryptedKey encKey2 = new EncryptedKey();
     151            encKey2.LoadXml((XmlElement)doc.GetElementsByTagName("xenc:EncryptedKey")[0]);
     152            EncryptedData encData2 = new EncryptedData();
     153            EncryptedData encDataElement2 = new EncryptedData();
     154            XmlElement data2 = (XmlElement)doc.GetElementsByTagName("xenc:EncryptedData")[0];
     155            encDataElement2.LoadXml((XmlElement)doc.GetElementsByTagName("xenc:EncryptedData")[0]);
     156            encxml2.AddKeyNameMapping("Web Service Public Key", provider);
     157            SymmetricAlgorithm algo2 = SymmetricAlgorithm.Create();
     158            algo2.Key = encxml2.DecryptEncryptedKey(encKey2);
     159            byte[] t2 = encxml2.DecryptData(encDataElement2, algo2);
     160            encxml2.ReplaceData(data2, t2);
     161            doc.GetElementsByTagName("root")[0].RemoveChild(doc.GetElementsByTagName("xenc:EncryptedKey")[0]);
     162            this._tracer.appendDecryptedData(uri, doc.FirstChild.InnerXml);
     163            EncryptedXml encXml = new EncryptedXml(this._inputDocument);
     164            encXml.AddKeyNameMapping("Web Service Public Key", provider);
     165            EncryptedData data = new EncryptedData();
     166            data.LoadXml((XmlElement)encryptedDataElement);
     167            SymmetricAlgorithm algo = SymmetricAlgorithm.Create();
     168            algo.Key = encXml.DecryptEncryptedKey(encryptdKey);
     169            byte[] t = encXml.DecryptData(data, algo);
     170            encXml.ReplaceData(encryptedDataElement, t);
     171            this._encryptedDataList.Add(encryptedDataElement);
     172            this._decryptedDataList.Add(doc.GetElementsByTagName("root")[0]);
     173            this._encryptedKeyElements.Add(encryptedKeyElement);
     174            string decryptedXmlString;
     175            return decryptedXmlString = Convert.ToBase64String(t);
     176        }
     177        public XmlElement DecryptSingleElementByKeyNumber(int encryptedKeyNumber)
     178        {
     179            EncryptedKey encryptedKey = new EncryptedKey();
     180            encryptedKey.LoadXml((XmlElement)this._encryptedKeyElements[encryptedKeyNumber]);
     181            ReferenceList referenceList = encryptedKey.ReferenceList;
     182            EncryptedReference encryptedReference = referenceList.Item(0);
     183            string uri = encryptedReference.Uri;
     184            KeyInfo keyInfo = encryptedKey.KeyInfo;
     185            this._referenceList.Clear();
     186            ArrayList referenceElementList = new ArrayList();
     187            referenceElementList = this.FindXmlElementByURI(uri, this._tempdocument.ChildNodes[1]);
     188            XmlElement keyInfoElement = this._tempdocument.CreateElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
     189            keyInfoElement.AppendChild(_tempdocument.ImportNode((XmlNode)encryptedKey.GetXml(), true));
     190            XmlElement encryptedDataElement = (XmlElement)referenceElementList[0];
     191            RSACryptoServiceProvider provider = this._webService.provider;
     192            EncryptedXml encXml = new EncryptedXml(this._tempdocument);
     193            encXml.AddKeyNameMapping("Web Service Public Key", provider);
     194            EncryptedData data = new EncryptedData();
     195            data.LoadXml((XmlElement)encryptedDataElement);
     196            SymmetricAlgorithm algo = SymmetricAlgorithm.Create();
     197            algo.Key = encXml.DecryptEncryptedKey(encryptedKey);
     198            byte[] t = encXml.DecryptData(data, algo);
     199            encXml.ReplaceData(encryptedDataElement, t);
     200            this._tempdocument.GetElementsByTagName("wsse:Security")[0].RemoveChild(_tempdocument.GetElementsByTagName("xenc:EncryptedKey")[0]);
     201            XmlElement root = (XmlElement)this._decryptedDataList[encryptedKeyNumber];
     202            return (XmlElement)root;
     203        }
     204        public bool ValidateSignature(XmlElement signatureElement)
     205        {
     206            bool valid = true;
     207            Signature signature = new Signature();
     208            signature.LoadXml(signatureElement);
     209            XmlNodeList signatureList = this._inputDocument.GetElementsByTagName("ds:Signature");
     210            if (signatureList.Count != 0)
     211            {
     212                this._signedXml.LoadXml((XmlElement)signatureElement);
     213                bool validReference = ValidateReferences(_signedXml);
     214                if (validReference)
     215                {
     216                    this.CanonicalizeSignedInfo(signature.SignedInfo.GetXml());
     217                    this._signedXml.LoadXml((XmlElement)signatureElement);
     218                }
     219                else
     220                {
     221                    this._valid = false;
     222                }
     223            }
     224            return valid;
     225        }
     226        public void CanonicalizeSignedInfo(XmlElement SignedInfo)
     227        {
     228            Canonicalizator canonicalizator = new Canonicalizator(this._inputDocument);
     229            Stream stream = canonicalizator.CanonicalizeNode(SignedInfo);
     230            StreamReader canonicalizedStreamReader = new StreamReader(stream);
     231            string canonicalizedString = canonicalizedStreamReader.ReadToEnd();
     232            this._canonicalizedSignedInfo = canonicalizedString;
     233            this.ValidateSignature(this._signedXml.Signature, this._signedXml.SignatureValue);
     234
     235        }
     236        public ArrayList GetSignedXmlSignatureReferences()
     237        {
     238            return _signedXml.SignedInfo.References;
     239        }
     240        public bool ValidateReferences(SignedXml signedXml)
     241        {
     242            byte[] digest;
     243            ArrayList references = signedXml.SignedInfo.References;
     244            int singatureReferenceCounter = 1;
     245            foreach (Reference reference in references)
     246            {
     247                string uri = reference.Uri;
     248                string hashAlgorithm = reference.DigestMethod;
     249                if (!uri.Equals(""))
     250                {
     251                    this._referenceList.Clear();
     252                    SignatureReference sigReference = new SignatureReference();
     253                    sigReference.nr = singatureReferenceCounter;
     254                    singatureReferenceCounter++;
     255                    sigReference.references = new ArrayList();
     256                    ArrayList newList = new ArrayList();
     257                    newList = this.FindXmlElementByURI(uri, this._inputDocument.ChildNodes[0].NextSibling);
     258                    XmlElement referenceElement = (XmlElement)newList[0];
     259                    XmlElement clonedReferenceElement = (XmlElement)referenceElement.Clone();
     260                    newList = (ArrayList)this._referenceList.Clone();
     261                    sigReference.references.Add(clonedReferenceElement);
     262                    this._signatureReferenceList.Add(sigReference);
     263                }
     264                if (uri.Equals(""))
     265                {
     266                    XmlNode node = null;
     267                    SignatureReference sigReference = new SignatureReference();
     268                    sigReference.nr = singatureReferenceCounter;
     269                    singatureReferenceCounter++;
     270                    ArrayList list = new ArrayList();
     271                    XmlDocument doc = new XmlDocument();
     272                    Transform trans = reference.TransformChain[0];
     273                    XmlDsigXPathTransform xpathTransform = (XmlDsigXPathTransform)trans;
     274                    XmlElement xpathElement = xpathTransform.GetXml();
     275                    string xpath = xpathElement.InnerText;
     276                    XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(this._inputDocument.NameTable);
     277                    XmlElement bodyElement = (XmlElement)this._inputDocument.GetElementsByTagName("s:Body")[0];
     278                    xmlNamespaceManager.AddNamespace("s", bodyElement.NamespaceURI);
     279                    xmlNamespaceManager.AddNamespace("tns", "http://tempuri.org/");
     280                    node = this._inputDocument.SelectSingleNode(xpath, xmlNamespaceManager);
     281                    list.Add((XmlElement)node.Clone());
     282                    sigReference.references = list;
     283                    this._signatureReferenceList.Add(sigReference);
     284                }
     285                XmlElement referenceTransformed = this.ApplyTransform(reference);
     286                digest = this.DigestElement(referenceTransformed, hashAlgorithm, "");
     287                string digestValue = Convert.ToBase64String(digest);
     288                this._tracer.appendReferenceValidation(uri, digestValue);
     289                string convertedDigest = Convert.ToBase64String(reference.DigestValue);
     290                if (convertedDigest.Equals(digestValue))
     291                {
     292                    return true;
     293                }
     294                else
     295                {
     296                    return false;
     297                }
     298            }
     299            return false;
     300        }
     301        public XmlElement ApplyTransform(Reference reference)
     302        {
     303            XmlNode node = null;
     304            TransformChain transformChain = reference.TransformChain;
     305            int transCounter = transformChain.Count;
     306            IEnumerator enumerator = transformChain.GetEnumerator();
     307            Stream transformstream = new MemoryStream();
     308            if (reference.Uri.Equals(""))
     309            {
     310                this._inputDocument.Save(transformstream);
     311                transformstream.Position = 0;
     312            }
     313            else
     314            {
     315                XmlNodeReader reader = new XmlNodeReader((XmlNode)this._reference);
     316                XmlWriter writer = new XmlTextWriter(transformstream, Encoding.UTF8);
     317                writer.WriteNode(reader, false);
     318                writer.Flush();
     319                transformstream.Position = 0;
     320            }
     321            for (int i = 0; i < transCounter; i++)
     322            {
     323                enumerator.MoveNext();
     324                Transform trans = (Transform)enumerator.Current;
     325                string typ = trans.ToString();
     326                switch (typ)
     327                {
     328                    case "System.Security.Cryptography.Xml.XmlDsigExcC14NTransform":
     329
     330                        if (!reference.Uri.Equals(""))
     331                        {
     332                            for (int j = 0; j < _referenceList.Count; j++)
     333                            {
     334                                XmlElement temp = (XmlElement)this._referenceList[j];
     335                                string uri = "#" + temp.Attributes["Id"].Value;
     336                                if (uri.Equals(reference.Uri))
     337                                {
     338                                    node = temp;
     339                                }
     340                            }
     341
     342                        }
    424343                        break;
    425                    
    426                      
    427                      
    428                }
    429                
    430            }
    431            return (XmlElement) node;
    432 
    433        }
    434 
    435 
    436        public bool validateSignature(Signature signature, byte[] bytes)
    437        {
    438            bool valid=false;
    439            KeyInfo keyInfo= signature.KeyInfo;
    440            CspParameters parameter = new CspParameters();
    441            RSACryptoServiceProvider rsa;
    442            DSACryptoServiceProvider dsa;
    443           XmlElement KeyInfoXml = keyInfo.GetXml();
    444         Type type=   keyInfo.GetType();
    445         if (KeyInfoXml.FirstChild.FirstChild.Name.Equals("RSAKeyValue"))
    446         {
    447             rsa = new RSACryptoServiceProvider(parameter);
    448             rsa.FromXmlString(keyInfo.GetXml().InnerXml);
    449             RSAParameters param = rsa.ExportParameters(false);
    450             byte[] digestSignedInfo = this.digestElement(signature.SignedInfo.GetXml(), "", "");
    451             XmlElement signed = signature.SignedInfo.GetXml();
    452             string oid = CryptoConfig.MapNameToOID("SHA1");
    453          
    454             valid = rsa.VerifyHash(digestSignedInfo, oid, this.signedXml.SignatureValue);
    455           //  this.valid = valid;
    456         }
    457         else
    458         {
    459             dsa = new DSACryptoServiceProvider(parameter);
    460             dsa.FromXmlString(KeyInfoXml.InnerXml);
    461             byte[] digestSignedInfo = this.digestElement(signature.SignedInfo.GetXml(), "", "");
    462             string oid = CryptoConfig.MapNameToOID("SHA1");
    463             valid = dsa.VerifyHash(digestSignedInfo, oid, this.signedXml.SignatureValue);
    464            // this.valid = valid;
    465         }
    466          
    467          
    468          
    469            return valid;
    470        }
    471        public byte[] digestElement(XmlElement element, string hashAlgorithm, string canonicalizationAlgorithm)
    472        {
    473            Canonicalizator canonicalizator = new Canonicalizator(inputString);
    474            Stream canonicalStream=canonicalizator.canonicalizeNode(element);
    475            canonicalStream.Position = 0;
    476            StreamReader sreader = new StreamReader(canonicalStream);
    477            string canonString = sreader.ReadToEnd();
    478            SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
    479            canonicalStream.Position = 0;
    480            byte[] hash = sha1.ComputeHash(canonicalStream);
    481            string t = Convert.ToBase64String(hash);
    482            return hash;
    483          
    484 
    485            
    486        }
    487        public ArrayList findEle(string uri, XmlNode elem)
    488        
    489        { XmlElement foundEle = null;
    490        
    491            String uri2 = uri;
    492            string[] t = new string[2];
    493            char separators = '#';
    494            char s = uri2[1];
    495            t = uri2.Split(separators);
    496          
    497            string wert = t[1];
    498 
    499            for (int i = 0; i < elem.ChildNodes.Count; i++)
    500            {
    501                XmlNode childNote = (XmlNode)elem.ChildNodes[i];
    502 
    503                if (childNote.HasChildNodes)
    504                {
    505                    findEle(uri2, childNote);
    506                }
    507                if (childNote.Attributes != null)
    508                {
    509                    if (childNote.Attributes["Id"] != null)
    510                    {
    511                        if (childNote.Attributes["Id"].Value.Equals(wert))
    512                        {
    513                            foundEle = (XmlElement)childNote;
    514                            this.referenceList.Add(foundEle);
    515                            this.reference = foundEle;
    516                            break;
    517                        }
    518                        if (foundEle != null)
    519                        {
    520                            break;
    521                        }
    522                    }
    523                }
    524            }
    525 
    526 
    527            return this.referenceList;
    528 
    529 
    530        }
    531 
    532      
    533 
    534        #endregion
    535        #region GUIINTERFACE
    536          public string canonicalizeSignedInfo(int signatureNumber)
    537        {
    538            XmlElement signedInfo=(XmlElement)this.inputString.GetElementsByTagName("ds:SignedInfo")[signatureNumber];
    539             canon = new Canonicalizator(inputString);
    540            //StreamReader sreader = new StreamReader(stream2);
    541            // string test3 = sreader.ReadToEnd();
    542            //return test3;
    543            Stream stream = canon.canonicalizeNode(signedInfo);
    544            StreamReader sreader = new StreamReader(stream);
    545            string canonString = sreader.ReadToEnd();
    546            return canonString;
    547        }
    548        public string digestElement(int signatureNumber, int referenceNumber)
    549          {
    550              SignedXml signedXml = new SignedXml();
    551            signedXml.LoadXml((XmlElement)this.inputString.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
    552            Signature signature = signedXml.Signature;
    553            Reference reference= (Reference)signature.SignedInfo.References[referenceNumber];
    554            string uri = reference.Uri;
    555            ArrayList references=this.getSignatureReferences(signatureNumber);
    556         byte[] digestedElement=this.digestElement((XmlElement)references[referenceNumber], "", "");
    557         string convertedDigest = Convert.ToBase64String(digestedElement);
    558           return Convert.ToBase64String(digestedElement);
    559        
    560        }
    561 
    562        public string makeTransforms(int signatureNumber, int referenceNumber, int transformChainNumber)
    563        {
    564            SignedXml signedXml = new SignedXml();
    565            signedXml.LoadXml((XmlElement)this.tempdocument.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
    566            Signature signature = signedXml.Signature;
    567            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
    568            Transform trans = reference.TransformChain[transformChainNumber];
    569            string result = "";
    570            if (trans.ToString().Equals("System.Security.Cryptography.Xml.XmlDsigXPathTransform"))
    571            {
    572                XmlNode node = null;
    573                XmlDocument doc = new XmlDocument();
    574                XmlDsigXPathTransform xpathTransform = (XmlDsigXPathTransform)trans;
    575                XmlElement xpathElement = xpathTransform.GetXml();
    576                string xpath = xpathElement.InnerText;
    577                XmlNamespaceManager manager = new XmlNamespaceManager(this.inputString.NameTable);
    578                XmlElement b = (XmlElement)this.inputString.GetElementsByTagName("s:Body")[0];
    579                manager.AddNamespace("s", b.NamespaceURI);
    580                manager.AddNamespace("tns", "http://tempuri.org/");
    581                node = this.tempdocument.SelectSingleNode(xpath, manager);
    582                StringWriter sw = new StringWriter();
    583                XmlTextWriter xw = new XmlTextWriter(sw);
    584                xw.Formatting = Formatting.Indented;
    585                XmlElement element = (XmlElement)node;
    586                element.Normalize();
    587              
    588                element.WriteTo(xw);
    589                this.transformedElement = element;
    590              result= sw.ToString();
    591              
    592            }
    593            if (trans.ToString().Equals("System.Security.Cryptography.Xml.XmlDsigExcC14NTransform"))
    594            {
    595                Stream stream;
    596               if (transformedElement != null)
    597                {
    598                 stream = this.canon.canonicalizeNode(transformedElement);
    599                    StreamReader sreader = new StreamReader(stream);
    600                    string canonString = sreader.ReadToEnd();
    601                    result = canonString;
    602                
    603                }
    604                else
    605                { 
    606                    ArrayList references = this.getSignatureReferences(signatureNumber);
    607                    XmlElement referenceElement = (XmlElement)references[referenceNumber];
    608                    stream = this.canon.canonicalizeNode(referenceElement);
    609                    StreamReader sreader = new StreamReader(stream);
    610                    string canonString = sreader.ReadToEnd();
    611                    result = canonString;
    612                }
    613            }
    614        
    615          
    616            return result;
    617        }
    618    
    619        public int getReferenceNumber(int signatureNumber)
    620        {
    621            return getSignatureReferences(signatureNumber).Count;
    622        }
    623        public ArrayList getSignatureReferences(int i)
    624        {
    625            SignatureReference signatureReference = (SignatureReference)this.signatureReferenceList[i];
    626            return signatureReference.references;
    627        }
    628        public string getSignatureReferenceName(int i)
    629        {
    630            ArrayList referencedElementList = this.getSignatureReferences(i);
    631            XmlElement referencedElement = (XmlElement)referencedElementList[0];
    632            string[] splitter = referencedElement.Name.Split(new Char[] { ':' });
    633            return splitter[1].ToString();
    634  
    635        }
    636        public bool compareDigestValues(int signatureNumber, int referenceNumber, string digestValue)
    637        {
    638            SignedXml signedXml = new SignedXml();
    639            signedXml.LoadXml((XmlElement)this.inputString.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
    640            Signature signature = signedXml.Signature;
    641            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
    642           return Convert.ToBase64String(reference.DigestValue).Equals(digestValue);
    643        }
    644 
    645        public int getTransformsCounter(int signatureNumber,int referenceNumber)
    646        {
    647            SignedXml signedXml = new SignedXml();
    648            signedXml.LoadXml((XmlElement)this.inputString.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
    649            Signature signature = signedXml.Signature;
    650            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
    651            return reference.TransformChain.Count;
    652        }
    653        #endregion
    654 
    655        public int getEncryptedKeyNumber()
    656        {
    657            return this.encryptedKeyElements.Count;
    658        }
    659 
    660        public int getTotalSecurityElementsNumber()
    661        {
    662            return this.wsSecurityHeaderElements.Count;
    663        }
    664        public string getWSSecurityHeaderElement(int i)
    665        {string returnString="";
    666            try
    667            {
    668                XmlElement tempElement = (XmlElement)this.wsSecurityHeaderElements[i];
    669                returnString = tempElement.Name;
    670            }
    671            catch
    672            {
    673                returnString = "null";
    674            }
    675            return returnString;
    676        }
    677 
    678    }   
    679    
     344
     345                    case "System.Security.Cryptography.Xml.XmlDsigXPathTransform":
     346                        XmlDocument doc = new XmlDocument();
     347                        XmlDsigXPathTransform xpathTransform = (XmlDsigXPathTransform)trans;
     348                        XmlElement xpathElement = xpathTransform.GetXml();
     349                        string xpath = xpathElement.InnerText;
     350                        XmlNamespaceManager xmlNameSpaceManager = new XmlNamespaceManager(this._inputDocument.NameTable);
     351                        XmlElement bodyElement = (XmlElement)this._inputDocument.GetElementsByTagName("s:Body")[0];
     352                        xmlNameSpaceManager.AddNamespace("s", bodyElement.NamespaceURI);
     353                        xmlNameSpaceManager.AddNamespace("tns", "http://tempuri.org/");
     354                        node = this._inputDocument.SelectSingleNode(xpath, xmlNameSpaceManager);
     355                        break;
     356                }
     357
     358            }
     359            return (XmlElement)node;
     360
     361        }
     362        public bool ValidateSignature(Signature signature, byte[] bytes)
     363        {
     364            bool valid = false;
     365            KeyInfo keyInfo = signature.KeyInfo;
     366            CspParameters parameter = new CspParameters();
     367            RSACryptoServiceProvider rsa;
     368            DSACryptoServiceProvider dsa;
     369            XmlElement KeyInfoXml = keyInfo.GetXml();
     370            Type type = keyInfo.GetType();
     371            if (KeyInfoXml.FirstChild.FirstChild.Name.Equals("RSAKeyValue"))
     372            {
     373                rsa = new RSACryptoServiceProvider(parameter);
     374                rsa.FromXmlString(keyInfo.GetXml().InnerXml);
     375                RSAParameters param = rsa.ExportParameters(false);
     376                byte[] digestSignedInfo = this.DigestElement(signature.SignedInfo.GetXml(), "", "");
     377                XmlElement signed = signature.SignedInfo.GetXml();
     378                string oid = CryptoConfig.MapNameToOID("SHA1");
     379                valid = rsa.VerifyHash(digestSignedInfo, oid, this._signedXml.SignatureValue);
     380
     381            }
     382            else
     383            {
     384                dsa = new DSACryptoServiceProvider(parameter);
     385                dsa.FromXmlString(KeyInfoXml.InnerXml);
     386                byte[] digestSignedInfo = this.DigestElement(signature.SignedInfo.GetXml(), "", "");
     387                string oid = CryptoConfig.MapNameToOID("SHA1");
     388                valid = dsa.VerifyHash(digestSignedInfo, oid, this._signedXml.SignatureValue);
     389            }
     390            return valid;
     391        }
     392        public byte[] DigestElement(XmlElement element, string hashAlgorithm, string canonicalizationAlgorithm)
     393        {
     394            Canonicalizator canonicalizator = new Canonicalizator(this._inputDocument);
     395            Stream canonicalStream = canonicalizator.CanonicalizeNode(element);
     396            canonicalStream.Position = 0;
     397            StreamReader canonicalStreamReader = new StreamReader(canonicalStream);
     398            string canonString = canonicalStreamReader.ReadToEnd();
     399            SHA1CryptoServiceProvider sha1CryptoServiceProvider = new SHA1CryptoServiceProvider();
     400            canonicalStream.Position = 0;
     401            byte[] hash = sha1CryptoServiceProvider.ComputeHash(canonicalStream);
     402            string base64ConvertedHashValue = Convert.ToBase64String(hash);
     403            return hash;
     404        }
     405        public ArrayList FindXmlElementByURI(string uri, XmlNode element)
     406        {
     407            XmlElement foundElement = null;
     408            String identifier = uri;
     409            string[] splittedUri = new string[2];
     410            char separators = '#';
     411            splittedUri = identifier.Split(separators);
     412            string value = splittedUri[1];
     413
     414            for (int i = 0; i < element.ChildNodes.Count; i++)
     415            {
     416                XmlNode childNote = (XmlNode)element.ChildNodes[i];
     417
     418                if (childNote.HasChildNodes)
     419                {
     420                    this.FindXmlElementByURI(identifier, childNote);
     421                }
     422                if (childNote.Attributes != null)
     423                {
     424                    if (childNote.Attributes["Id"] != null)
     425                    {
     426                        if (childNote.Attributes["Id"].Value.Equals(value))
     427                        {
     428                            foundElement = (XmlElement)childNote;
     429                            this._referenceList.Add(foundElement);
     430                            this._reference = foundElement;
     431                            break;
     432                        }
     433                        if (foundElement != null)
     434                        {
     435                            break;
     436                        }
     437                    }
     438                }
     439            }
     440            return this._referenceList;
     441        }
     442        public string CanonicalizeSignedInfo(int signatureNumber)
     443        {
     444            XmlElement signedInfo = (XmlElement)this._inputDocument.GetElementsByTagName("ds:SignedInfo")[signatureNumber];
     445            this._canonicalizator = new Canonicalizator(this._inputDocument);
     446            Stream stream = this._canonicalizator.CanonicalizeNode(signedInfo);
     447            StreamReader sreader = new StreamReader(stream);
     448            string canonString = sreader.ReadToEnd();
     449            return canonString;
     450        }
     451        public string DigestElement(int signatureNumber, int referenceNumber)
     452        {
     453            SignedXml signedXml = new SignedXml();
     454            signedXml.LoadXml((XmlElement)this._inputDocument.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
     455            Signature signature = signedXml.Signature;
     456            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
     457            string uri = reference.Uri;
     458            ArrayList references = this.GetSignatureReferences(signatureNumber);
     459            byte[] digestedElement = this.DigestElement((XmlElement)references[referenceNumber], "", "");
     460            string convertedDigest = Convert.ToBase64String(digestedElement);
     461            return Convert.ToBase64String(digestedElement);
     462
     463        }
     464        public string MakeTransforms(int signatureNumber, int referenceNumber, int transformChainNumber)
     465        {
     466            SignedXml signedXml = new SignedXml();
     467            signedXml.LoadXml((XmlElement)this._tempdocument.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
     468            Signature signature = signedXml.Signature;
     469            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
     470            Transform transform = reference.TransformChain[transformChainNumber];
     471            string result = "";
     472            if (transform.ToString().Equals("System.Security.Cryptography.Xml.XmlDsigXPathTransform"))
     473            {
     474                XmlNode node = null;
     475                XmlDocument doc = new XmlDocument();
     476                XmlDsigXPathTransform xpathTransform = (XmlDsigXPathTransform)transform;
     477                XmlElement xpathElement = xpathTransform.GetXml();
     478                string xpath = xpathElement.InnerText;
     479                XmlNamespaceManager manager = new XmlNamespaceManager(this._inputDocument.NameTable);
     480                XmlElement bodyElement = (XmlElement)this._inputDocument.GetElementsByTagName("s:Body")[0];
     481                manager.AddNamespace("s", bodyElement.NamespaceURI);
     482                manager.AddNamespace("tns", "http://tempuri.org/");
     483                node = this._tempdocument.SelectSingleNode(xpath, manager);
     484                StringWriter stringWriter = new StringWriter();
     485                XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
     486                xmlTextWriter.Formatting = Formatting.Indented;
     487                XmlElement element = (XmlElement)node;
     488                element.Normalize();
     489                element.WriteTo(xmlTextWriter);
     490                this.transformedElement = element;
     491                result = stringWriter.ToString();
     492
     493            }
     494            if (transform.ToString().Equals("System.Security.Cryptography.Xml.XmlDsigExcC14NTransform"))
     495            {
     496                Stream stream;
     497                if (transformedElement != null)
     498                {
     499                    stream = this._canonicalizator.CanonicalizeNode(transformedElement);
     500                    StreamReader sreader = new StreamReader(stream);
     501                    string canonString = sreader.ReadToEnd();
     502                    result = canonString;
     503
     504                }
     505                else
     506                {
     507                    ArrayList references = this.GetSignatureReferences(signatureNumber);
     508                    XmlElement referenceElement = (XmlElement)references[referenceNumber];
     509                    stream = this._canonicalizator.CanonicalizeNode(referenceElement);
     510                    StreamReader sreader = new StreamReader(stream);
     511                    string canonString = sreader.ReadToEnd();
     512                    result = canonString;
     513                }
     514            }
     515
     516
     517            return result;
     518        }
     519        public int GetReferenceNumber(int signatureNumber)
     520        {
     521            return GetSignatureReferences(signatureNumber).Count;
     522        }
     523        public ArrayList GetSignatureReferences(int signatureNumber)
     524        {
     525            SignatureReference signatureReference = (SignatureReference)this._signatureReferenceList[signatureNumber];
     526            return signatureReference.references;
     527        }
     528        public string GetSignatureReferenceName(int signatureNumber)
     529        {
     530            ArrayList referencedElementList = this.GetSignatureReferences(signatureNumber);
     531            XmlElement referencedElement = (XmlElement)referencedElementList[0];
     532            string[] splitter = referencedElement.Name.Split(new Char[] { ':' });
     533            return splitter[1].ToString();
     534
     535        }
     536        public bool CompareDigestValues(int signatureNumber, int referenceNumber, string digestValue)
     537        {
     538            SignedXml signedXml = new SignedXml();
     539            signedXml.LoadXml((XmlElement)this._inputDocument.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
     540            Signature signature = signedXml.Signature;
     541            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
     542            return Convert.ToBase64String(reference.DigestValue).Equals(digestValue);
     543        }
     544        public int GetTransformsCounter(int signatureNumber, int referenceNumber)
     545        {
     546            SignedXml signedXml = new SignedXml();
     547            signedXml.LoadXml((XmlElement)this._inputDocument.GetElementsByTagName("Signature", "http://www.w3.org/2000/09/xmldsig#")[signatureNumber]);
     548            Signature signature = signedXml.Signature;
     549            Reference reference = (Reference)signature.SignedInfo.References[referenceNumber];
     550            return reference.TransformChain.Count;
     551        }
     552        public int GetEncryptedKeyNumber()
     553        {
     554            return this._encryptedKeyElements.Count;
     555        }
     556        public int GetTotalSecurityElementsNumber()
     557        {
     558            return this._wsSecurityHeaderList.Count;
     559        }
     560        public string GetWSSecurityHeaderElement(int i)
     561        {
     562            string returnString = "";
     563            try
     564            {
     565                XmlElement tempElement = (XmlElement)this._wsSecurityHeaderList[i];
     566                returnString = tempElement.Name;
     567            }
     568            catch
     569            {
     570                returnString = "null";
     571            }
     572            return returnString;
     573        }
     574        #endregion
     575
     576    }
     577
    680578}
Note: See TracChangeset for help on using the changeset viewer.