Changeset 2551


Ignore:
Timestamp:
Feb 1, 2011, 8:04:44 PM (10 years ago)
Author:
Tim Podeszwa
Message:

Code cleaned

Location:
trunk/CrypPlugins/Soap
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Soap/EncryptionAnimator.cs

    r641 r2551  
    7373        {
    7474            dispatcherTimer.Stop();
    75             soap.showsecuredSoap();
     75            soap.ShowSecuredSoap();
    7676            presentation.animationRunning = false;
    77             soap.createInfoMessage("Animation end");
     77            soap.CreateInfoMessage("Animation end");
    7878        }
    7979
     
    8383            {
    8484                dispatcherTimer.Stop();
    85                 soap.createInfoMessage("Stop encryption animation");
     85                soap.CreateInfoMessage("Stop encryption animation");
    8686
    8787            }
     
    8989            {
    9090                dispatcherTimer.Start();
    91                 soap.createInfoMessage("Restart encryption animation");
     91                soap.CreateInfoMessage("Restart encryption animation");
    9292            }
    9393        }
     
    142142                    break;
    143143                case 2:
    144                     presentation.addTextToInformationBox("Session Key is: "+soap.lastSessionKey);
     144                    presentation.addTextToInformationBox("Session Key is: "+soap.LastSessionKey);
    145145
    146146                    status = 3;   
     
    148148                case 3:
    149149                 
    150                     if (!soap.getEncContent())
     150                    if (!soap.GetIsEncryptContent())
    151151                    {
    152152                    string id=checkForID(itemToEncrypt);
     
    158158                    else
    159159                    {
    160                         actId = soap.getIdToElement(actElementToEncrypt.Name);
     160                        actId = soap.GetIdToElement(actElementToEncrypt.Name);
    161161                     
    162162                            presentation.addTextToInformationBox("The " + actElementToEncrypt.Name + " gets the id: " +  actId);
     
    167167                    else
    168168                    {
    169                         XmlNode encryptedElement = soap.securedSOAP.GetElementsByTagName(actElementToEncrypt.Name)[0];
     169                        XmlNode encryptedElement = soap.SecuredSoap.GetElementsByTagName(actElementToEncrypt.Name)[0];
    170170                        foreach(XmlAttribute att in encryptedElement.FirstChild.Attributes)
    171171                        {
     
    184184                    break;
    185185                case 5:
    186                     XmlNodeList encryptedDataElements = soap.securedSOAP.GetElementsByTagName("xenc:EncryptedData");
     186                    XmlNodeList encryptedDataElements = soap.SecuredSoap.GetElementsByTagName("xenc:EncryptedData");
    187187                   
    188188                    foreach(XmlNode node in encryptedDataElements )
     
    259259
    260260                case 12:
    261                     if (soap.getEncContent())
     261                    if (soap.GetIsEncryptContent())
    262262                    {
    263263                        presentation.addTextToInformationBox("Replase the content of the "+actElementToEncrypt.Name );
     
    313313                    presentation.addTextToInformationBox("Check for Header");
    314314                   
    315                     if (!soap.hadHeader)
     315                    if (!soap.HadHeader)
    316316                    {
    317317                        this.secHeader = false;
     
    323323                case 14:
    324324                    presentation.addTextToInformationBox("No Header found. Create SOAP and Security Header");
    325                     addChildElement("s:Envelope", soap.securedSOAP.GetElementsByTagName("s:Header")[0], true);
    326                     addChildElement("s:Header", soap.securedSOAP.GetElementsByTagName("wsse:Security")[0], true);
     325                    addChildElement("s:Envelope", soap.SecuredSoap.GetElementsByTagName("s:Header")[0], true);
     326                    addChildElement("s:Header", soap.SecuredSoap.GetElementsByTagName("wsse:Security")[0], true);
    327327                    status =15;
    328328                    break;
    329329                case 15:
    330330                    presentation.addTextToInformationBox("Create Encrypted Key");
    331                     actEncKey =  addChildElement("wsse:Security", soap.securedSOAP.GetElementsByTagName("xenc:EncryptedKey")[0], true);
     331                    actEncKey = addChildElement("wsse:Security", soap.SecuredSoap.GetElementsByTagName("xenc:EncryptedKey")[0], true);
    332332                    status = 16;
    333333                    break;
     
    335335                case 16:
    336336                    presentation.addTextToInformationBox("Create Encryption Method Element");
    337                     addChildElement(actEncKey, soap.securedSOAP.GetElementsByTagName("xenc:EncryptionMethod")[0], true);
     337                    addChildElement(actEncKey, soap.SecuredSoap.GetElementsByTagName("xenc:EncryptionMethod")[0], true);
    338338                    status = 17;
    339339                    break;
    340340                case 17:
    341341                    presentation.addTextToInformationBox("Add Key Info Element");
    342                     TreeViewItem keyInfo = addChildElement(actEncKey, soap.securedSOAP.GetElementsByTagName("ds:KeyInfo")[0], true);
     342                    TreeViewItem keyInfo = addChildElement(actEncKey, soap.SecuredSoap.GetElementsByTagName("ds:KeyInfo")[0], true);
    343343                    keyInfo.IsExpanded = true;
    344                     presentation.CopyXmlToTreeView(soap.securedSOAP.GetElementsByTagName("ds:KeyInfo")[0].FirstChild,ref keyInfo);
     344                    presentation.CopyXmlToTreeView(soap.SecuredSoap.GetElementsByTagName("ds:KeyInfo")[0].FirstChild, ref keyInfo);
    345345                    status = 18;
    346346                    break;
     
    348348                case 18:
    349349                    presentation.addTextToInformationBox("Create CipherData Element");
    350                     actcipherdataitem = addChildElement(actEncKey, soap.securedSOAP.GetElementsByTagName("xenc:CipherData")[0], false);
     350                    actcipherdataitem = addChildElement(actEncKey, soap.SecuredSoap.GetElementsByTagName("xenc:CipherData")[0], false);
    351351                    status = 19;
    352352                    break;
    353353                case 19:
    354354                    presentation.addTextToInformationBox("Create CipherValue Element");
    355                      actciphervalueitem= addChildElement(actcipherdataitem , soap.securedSOAP.GetElementsByTagName("xenc:CipherValue")[0], false);
     355                    actciphervalueitem = addChildElement(actcipherdataitem, soap.SecuredSoap.GetElementsByTagName("xenc:CipherValue")[0], false);
    356356                    status = 20;
    357357                    break;
     
    361361                    break;
    362362                case 21:
    363                     presentation.addTextToInformationBox("Cipher Value is: " + soap.securedSOAP.GetElementsByTagName("xenc:CipherValue")[0].InnerText);
     363                    presentation.addTextToInformationBox("Cipher Value is: " + soap.SecuredSoap.GetElementsByTagName("xenc:CipherValue")[0].InnerText);
    364364                    status = 22;
    365365                    break;
    366366                case 22:
    367367                    presentation.addTextToInformationBox("Insert Cipher Value");
    368                     createValue(actciphervalueitem, soap.securedSOAP.GetElementsByTagName("xenc:CipherValue")[0].InnerText);
     368                    createValue(actciphervalueitem, soap.SecuredSoap.GetElementsByTagName("xenc:CipherValue")[0].InnerText);
    369369                    status = 23;
    370370                    break;
    371371                case 23:
    372372                    presentation.addTextToInformationBox("Create Reference List");
    373                     actRefList = addChildElement(actEncKey, soap.securedSOAP.GetElementsByTagName("xenc:ReferenceList")[0], false);
     373                    actRefList = addChildElement(actEncKey, soap.SecuredSoap.GetElementsByTagName("xenc:ReferenceList")[0], false);
    374374                    status = 24;
    375375                    break;
     
    377377                    status = 25;
    378378                    presentation.addTextToInformationBox("Insert Data Reference");
    379                     addChildElement(actRefList, soap.securedSOAP.GetElementsByTagName("xenc:ReferenceList")[0], false);
     379                    addChildElement(actRefList, soap.SecuredSoap.GetElementsByTagName("xenc:ReferenceList")[0], false);
    380380                    status = 25;
    381381                    break;
     
    385385                    presentation.animationRunning = false;
    386386                    status = 0;
    387                     soap.showsecuredSoap();
     387                    soap.ShowSecuredSoap();
    388388                    break;
    389389
  • trunk/CrypPlugins/Soap/SignatureAnimator.cs

    r641 r2551  
    9292
    9393                actTimer.Stop();
    94                 soap.createInfoMessage("Stop signature animation");
     94                soap.CreateInfoMessage("Stop signature animation");
    9595                animationRunning = false;
    9696
     
    100100                actTimer.Start();
    101101                animationRunning = true;
    102                 soap.createInfoMessage("Restart signature animation");
     102                soap.CreateInfoMessage("Restart signature animation");
    103103               
    104104            }
     
    117117            transformSteps = 0;
    118118            transformsCounter = 0;
    119             if (!soap.checkSecurityHeader())
    120             {
    121                 soap.createSecurityHeaderAndSoapHeader();
     119            if (!soap.CheckSecurityHeader())
     120            {
     121                soap.CreateSecurityHeaderAndSoapHeader();
    122122            }
    123123            if (!signed)
    124124            {
    125                 soap.signElementsManual(this.elementsToSign);
     125                soap.SignElementsManual(this.elementsToSign);
    126126            }
    127127           
    128128            presentation.animationRunning = false;
    129129            animationRunning = false;
    130             soap.createInfoMessage("Animation end");
    131             soap.showsecuredSoap();
     130            soap.CreateInfoMessage("Animation end");
     131            soap.ShowSecuredSoap();
    132132        }
    133133
     
    719719                    dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 6, 0);
    720720                    presentation.addTextToInformationBox("Check Envelope for SOAP-Header");
    721                     bool secHead = soap.checkSecurityHeader();
     721                    bool secHead = soap.CheckSecurityHeader();
    722722                    if (!secHead)
    723723                    {
     
    736736                    //Create Soap Header
    737737                    presentation.addTextToInformationBox("Add Soap-Header to Envelope");
    738                     soap.createSecurityHeaderAndSoapHeader();
    739                     addChildElement("s:Envelope",soap.securedSOAP.GetElementsByTagName("s:Header")[0],true);
     738                    soap.CreateSecurityHeaderAndSoapHeader();
     739                    addChildElement("s:Envelope",soap.SecuredSoap.GetElementsByTagName("s:Header")[0],true);
    740740                    status = 3;
    741741                    //  slider1.Value++;
     
    753753                    //Create Security Header
    754754                    presentation.addTextToInformationBox("Create Security-Header as child of SOAP-Header");
    755                     addChildElement("s:Header", soap.securedSOAP.GetElementsByTagName("wsse:Security")[0], true);
     755                    addChildElement("s:Header", soap.SecuredSoap.GetElementsByTagName("wsse:Security")[0], true);
    756756                    status = 4;
    757757                    break;
     
    760760                    //Create Signature Element
    761761                    presentation.addTextToInformationBox("Create a ds:Signature-Element as first child of the Security-Header");
    762                     soap.signElementsManual(this.elementsToSign);
     762                    soap.SignElementsManual(this.elementsToSign);
    763763                    signed = true;
    764                     addChildElement("wsse:Security", soap.securedSOAP.GetElementsByTagName("ds:Signature")[0], true);
     764                    addChildElement("wsse:Security", soap.SecuredSoap.GetElementsByTagName("ds:Signature")[0], true);
    765765                    //Signature TreeViewItem is saved in actSignatureItem var
    766766                    status = 5;
     
    771771                    presentation.addTextToInformationBox("Create a ds:SignedInfo Element");
    772772                    useactSigItem = true;
    773                     addChildElement("ds:Signature",soap.securedSOAP.GetElementsByTagName("ds:SignedInfo")[0],false);
     773                    addChildElement("ds:Signature", soap.SecuredSoap.GetElementsByTagName("ds:SignedInfo")[0], false);
    774774                    status = 6;
    775775                    break;
     
    786786                    //Create Canon
    787787                    useactSigItem = true;
    788                     addChildElement("ds:SignedInfo", soap.securedSOAP.GetElementsByTagName("ds:CanonicalizationMethod")[0], false);
     788                    addChildElement("ds:SignedInfo", soap.SecuredSoap.GetElementsByTagName("ds:CanonicalizationMethod")[0], false);
    789789                    status = 8;
    790790                    break;
     
    794794                    presentation.addTextToInformationBox("Create Signature Method Element with the choosen signature algorithm");
    795795                    string s = "";
    796                     if(soap.getSignatureAlg().Equals("1"))
     796                    if(soap.GetSignatureAlgorithm().Equals("1"))
    797797                    {
    798798                        s="RSA-SHA1";
     
    807807                    //Create Signature Method
    808808                    useactSigItem = true;
    809                     addChildElement("ds:SignedInfo", soap.securedSOAP.GetElementsByTagName("ds:SignatureMethod")[0], false);
     809                    addChildElement("ds:SignedInfo", soap.SecuredSoap.GetElementsByTagName("ds:SignatureMethod")[0], false);
    810810                    status = 10;
    811811                    break;
     
    822822                case 11:
    823823                    presentation.addTextToInformationBox("Create Signature Value Element");
    824                    actSignatureValue= addChildElement(actSignatureItem, soap.securedSOAP.GetElementsByTagName("ds:SignatureValue")[0], false);
     824                    actSignatureValue = addChildElement(actSignatureItem, soap.SecuredSoap.GetElementsByTagName("ds:SignatureValue")[0], false);
    825825                    status = 12;
    826826                    break;
     
    829829                    rootItem = (TreeViewItem)presentation.treeView.Items[0];
    830830                    TreeViewItem canon = new TreeViewItem();
    831                     StreamReader sreader = new StreamReader(soap.canonicalizeNodeWithExcC14n((XmlElement) soap.securedSOAP.GetElementsByTagName("ds:SignedInfo")[0]));
     831                    StreamReader sreader = new StreamReader(soap.CanonicalizeNodeWithExcC14n((XmlElement)soap.SecuredSoap.GetElementsByTagName("ds:SignedInfo")[0]));
    832832                    string canonString = sreader.ReadToEnd();
    833833                    XmlDocument doc = new XmlDocument();
     
    852852                    break;
    853853                case 14:
    854                     XmlElement signedInfo = (XmlElement)soap.securedSOAP.GetElementsByTagName("ds:SignedInfo")[0];
    855                     byte[] temp = soap.getDigestValueForElement(signedInfo);
     854                    XmlElement signedInfo = (XmlElement)soap.SecuredSoap.GetElementsByTagName("ds:SignedInfo")[0];
     855                    byte[] temp = soap.GetDigestValueForElementWithSha1(signedInfo);
    856856                    string value = Convert.ToBase64String(temp);
    857857                    presentation.addTextToInformationBox("SHA-1 Hash Value of the ds:SignedInfo Element is: "+value);
     
    863863                    break;
    864864                case 16:
    865                     XmlNode signatureValue=soap.securedSOAP.GetElementsByTagName("ds:SignatureValue")[0];
     865                    XmlNode signatureValue = soap.SecuredSoap.GetElementsByTagName("ds:SignatureValue")[0];
    866866                    presentation.addTextToInformationBox("The Signature Value is: "+signatureValue.InnerText);
    867867                    presentation.treeView.Items.Clear();
     
    878878                case 18:
    879879                    TreeViewItem keyInfo = new TreeViewItem();
    880                     XmlNode keyInfoXML = soap.securedSOAP.GetElementsByTagName("ds:KeyInfo")[0];
     880                    XmlNode keyInfoXML = soap.SecuredSoap.GetElementsByTagName("ds:KeyInfo")[0];
    881881                    StackPanel panel1 = new StackPanel();
    882882                    panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
     
    910910                    dispatcherTimer.Stop();
    911911                    presentation.animationRunning = false;
    912                     soap.showsecuredSoap();
     912                    soap.ShowSecuredSoap();
    913913                    this.animationRunning = false;
    914914                    break;
     
    926926                    element.BringIntoView();
    927927                    actElementToReferenceTVI = element;
    928                     if (!soap.getxPathTrans())
     928                    if (!soap.GetXPathTransForm())
    929929                    {
    930930                        actElementToReference = elementsToSign[referencesCounter];
     
    955955                    presentation.addTextToInformationBox("Create Id for the Element");
    956956                    TreeViewItem element1 = findItem(presentation.securedSoapItem, actElementToReference.Name);
    957                     createAttributeForElement(actElementToReference.Name, "Id", soap.getIdToElement(actElementToReference.Name));
     957                    createAttributeForElement(actElementToReference.Name, "Id", soap.GetIdToElement(actElementToReference.Name));
    958958                    referencesSteps = 2;
    959959                    break;
     
    962962                case 2:
    963963                    presentation.addTextToInformationBox("Create Reference Element for " + actElementToReference.Name + " Element");
    964                     actReferenceElementTVI = addChildElement("ds:SignedInfo", soap.securedSOAP.GetElementsByTagName("ds:Reference")[referencesCounter], false);
    965                     actReferenceElement = (XmlElement)soap.securedSOAP.GetElementsByTagName("ds:Reference")[referencesCounter];
     964                    actReferenceElementTVI = addChildElement("ds:SignedInfo", soap.SecuredSoap.GetElementsByTagName("ds:Reference")[referencesCounter], false);
     965                    actReferenceElement = (XmlElement)soap.SecuredSoap.GetElementsByTagName("ds:Reference")[referencesCounter];
    966966                 
    967967                   referencesSteps = 5;
     
    972972                    //XPAth Reference Element
    973973                    presentation.addTextToInformationBox("Create Reference Element for " + actElementToReference.Name + " Element");
    974                     actReferenceElementTVI = addChildElement("ds:SignedInfo", soap.securedSOAP.GetElementsByTagName("ds:Reference")[referencesCounter], false);
    975                     actReferenceElement = (XmlElement)soap.securedSOAP.GetElementsByTagName("ds:Reference")[referencesCounter];
     974                    actReferenceElementTVI = addChildElement("ds:SignedInfo", soap.SecuredSoap.GetElementsByTagName("ds:Reference")[referencesCounter], false);
     975                    actReferenceElement = (XmlElement)soap.SecuredSoap.GetElementsByTagName("ds:Reference")[referencesCounter];
    976976                    referencesSteps = 4;
    977977                    break;
     
    983983                    presentation.addTextToInformationBox("Create a Transforms Element");
    984984                    useactSigItem = true;
    985                     actTransformsElementTVI = addChildElement("ds:Reference", soap.securedSOAP.GetElementsByTagName("ds:Transforms")[referencesCounter], false);
     985                    actTransformsElementTVI = addChildElement("ds:Reference", soap.SecuredSoap.GetElementsByTagName("ds:Transforms")[referencesCounter], false);
    986986                    referencesSteps = 6;
    987987                    break;
     
    996996                case 7:
    997997                    presentation.addTextToInformationBox("Create the DigestMethod-Element");
    998                     addChildElement("ds:Reference", soap.securedSOAP.GetElementsByTagName("ds:DigestMethod")[referencesCounter], false);
     998                    addChildElement("ds:Reference", soap.SecuredSoap.GetElementsByTagName("ds:DigestMethod")[referencesCounter], false);
    999999                    referencesSteps = 8;
    10001000                    break;
     
    10091009                    break;
    10101010                case 10:
    1011                     if (soap.getxPathTrans())
     1011                    if (soap.GetXPathTransForm())
    10121012                    {
    10131013                        presentation.addTextToInformationBox("URI is empty, so the complete document is referenced");
     
    10521052                    rootItem = (TreeViewItem)presentation.treeView.Items[0];
    10531053                    TreeViewItem canon = new TreeViewItem();
    1054                     StreamReader sreader = new StreamReader(soap.canonicalizeNodeWithExcC14n(actElementToReference));
     1054                    StreamReader sreader = new StreamReader(soap.CanonicalizeNodeWithExcC14n(actElementToReference));
    10551055                    string canonString = sreader.ReadToEnd();
    10561056                    XmlDocument doc = new XmlDocument();
     
    10751075                    break;
    10761076                case 17:
    1077                     XmlNode digest = soap.securedSOAP.GetElementsByTagName("ds:DigestValue")[referencesCounter];
     1077                    XmlNode digest = soap.SecuredSoap.GetElementsByTagName("ds:DigestValue")[referencesCounter];
    10781078                    presentation.addTextToInformationBox("SHA-1 Value:" + digest.InnerText);
    10791079                    referencesSteps = 18;
     
    10851085
    10861086                    presentation.addTextToInformationBox("Create Digest Value Element");
    1087                     actDigestValue = addChildElement(actReferenceElementTVI, soap.securedSOAP.GetElementsByTagName("ds:DigestValue")[referencesCounter], false);
     1087                    actDigestValue = addChildElement(actReferenceElementTVI, soap.SecuredSoap.GetElementsByTagName("ds:DigestValue")[referencesCounter], false);
    10881088                    referencesSteps = 19;
    10891089                    break;
     
    10911091                case 19:
    10921092                    presentation.addTextToInformationBox("Add Digest Value to Digest Value Element");
    1093                     createValue(actDigestValue, soap.securedSOAP.GetElementsByTagName("ds:DigestValue")[referencesCounter].InnerText);
     1093                    createValue(actDigestValue, soap.SecuredSoap.GetElementsByTagName("ds:DigestValue")[referencesCounter].InnerText);
    10941094                    referencesSteps = 20;
    10951095                    break;
     
    11741174                    //Create C14N
    11751175                    presentation.addTextToInformationBox("Create Canonicalization Transform");
    1176                     if (soap.getxPathTrans())
     1176                    if (soap.GetXPathTransForm())
    11771177                    {
    11781178                        addChildElement(actTransformsElementTVI, actReferenceElement.FirstChild.ChildNodes[1], false);
  • trunk/CrypPlugins/Soap/Soap.cs

    r2334 r2551  
    2727    [Author("Tim Podeszwa", "tim.podeszwa@student.uni-siegen.de", "Uni Siegen", "http://www.uni-siegen.de")]
    2828    [PluginInfo(true, "SoapMessage", "Represents a SoapMessage", "", "Soap/soap.png")]
    29     public class Soap:IThroughput
     29    public class Soap : IThroughput
    3030    {
    31         private ISettings settings = new SoapSettings();
    32         private SoapPresentation presentation;
    33      
    34         private XmlNode node, envelope, body;
    35         public XmlDocument soap, inputDocument;
    36         public XmlDocument securedSOAP;
    37         private string[] signedElements;
    38         public Hashtable idTable;
    39         private bool bodySigned, methodNameSigned, bodyEncrypted, methodNameEncrypted ,secHeaderEnc,secHeaderSigned;
    40         private int contentCounter;
    41         private RSACryptoServiceProvider wsRSACryptoProv, rsaCryptoProv;
     31
     32        #region Fields
     33
     34        private ISettings _settings = new SoapSettings();
     35        private SoapPresentation presentation;
     36        private XmlNode _node;
     37        private XmlNode _envelope;
     38        private XmlNode _body;
     39        private XmlDocument _soap;
     40        private XmlDocument _inputDocument;
     41        private XmlDocument _securedSOAP;
     42        private string[] _signedElements;
     43        private Hashtable _idTable;
     44        private bool _bodySigned;
     45        private bool _methodNameSigned;
     46        private bool _bodyEncrypted;
     47        private bool _methodNameEncrypted;
     48        private bool _secHeaderEnc;
     49        private bool _secHeaderSigned;
     50        private bool _loaded;
     51        private bool send;
     52        private bool _gotKey;
     53        private bool _wsdlLoaded;
     54        private int _contentCounter;
     55        private bool _hadHeader;
     56        private RSACryptoServiceProvider _wsRSACryptoProv;
     57        private RSACryptoServiceProvider _rsaCryptoProv;
     58        private DSACryptoServiceProvider _dsaCryptoProv;
     59        private CspParameters _cspParams;
     60        private RSACryptoServiceProvider _rsaKey;
     61        private string _wsPublicKey;
     62        private string _lastSessionKey;
     63        private EncryptionSettings _encryptionSettings;
     64        private SignatureSettings _signatureSettings;
     65
     66        #endregion
     67
     68        #region Properties
     69
     70        public string LastSessionKey
     71        {
     72            get
     73            {
     74                return this._lastSessionKey;
     75            }
     76        }
     77        public bool HadHeader
     78        {
     79            get
     80            {
     81                return this._hadHeader;
     82            }
     83        }
     84
     85        public bool WSDLLoaded
     86        {
     87            get
     88            {
     89                return this._wsdlLoaded;
     90            }
     91        }
     92        public bool GotKey
     93        {
     94            get
     95            {
     96                return this._gotKey;
     97            }
     98        }
     99        public XmlDocument SecuredSoap
     100        {
     101            get
     102            {
     103                return this._securedSOAP;
     104            }
     105        }
    42106
    43107        public RSACryptoServiceProvider WsRSACryptoProv
    44108        {
    45             get { return wsRSACryptoProv; }
    46             set { wsRSACryptoProv = value; }
    47         }
    48         private DSACryptoServiceProvider dsaCryptoProv;
    49         private string wsPublicKey;
     109            get { return this._wsRSACryptoProv; }
     110            set { this._wsRSACryptoProv = value; }
     111        }
     112
    50113
    51114        public string WsPublicKey
    52115        {
    53             get { return wsPublicKey; }
    54             set { wsPublicKey = value; }
    55         }
    56         public bool gotKey;
    57         public bool wsdlLoaded,loaded;
    58         public string lastSessionKey;
    59         public bool hadHeader;
    60         public bool send = false;
    61 
    62 
    63 
    64         /// <summary>
    65         /// Encryption Variablen rausnehmen
    66         /// </summary>
    67         private CspParameters cspParams;
    68         private RSACryptoServiceProvider rsaKey;
     116            get { return this._wsPublicKey; }
     117            set { this._wsPublicKey = value; }
     118        }
     119
     120        [PropertyInfo(Direction.InputData, "WSDL Input", "WSDL to create the soap message", null)]
     121        public XmlDocument Wsdl
     122        {
     123            set
     124            {
     125                presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     126                {
     127                    string s = CopyXmlToString(value);
     128                    this.LoadWSDL(s);
     129                    this._wsdlLoaded = true;
     130                    this.OnPropertyChanged("wsdl");
     131                    this.CreateInfoMessage("Received WSDL File");
     132                    this.CreateInfoMessage("Created SOAP Message");
     133                }, null);
     134            }
     135            get
     136            {
     137                return null;
     138            }
     139        }
     140
     141        [PropertyInfo(Direction.InputData, "Public-Key input", "Encryption Key", null)]
     142        public string PublicKey
     143        {
     144            get
     145            {
     146                return this._wsPublicKey;
     147            }
     148            set
     149            {
     150                Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     151                {
     152                    {
     153                        this._wsPublicKey = value;
     154                        WsRSACryptoProv.FromXmlString(this._wsPublicKey);
     155                        this._gotKey = true;
     156                        mySettings.gotkey = true;
     157                        mySettings.wsRSAcryptoProv = WsRSACryptoProv.ToXmlString(false);
     158                        OnPropertyChanged("publicKey");
     159                        CreateInfoMessage("Public Key Received");
     160                    }
     161                }, null);
     162            }
     163        }
     164
     165        [PropertyInfo(Direction.OutputData, "SOAP output", "Send a SOAP Message", "", true, true, QuickWatchFormat.Text, "XmlConverter")]
     166        public XmlDocument OutputString
     167        {
     168            get { return this._securedSOAP; }
     169            set
     170            {
     171
     172                this._securedSOAP = value;
     173                OnPropertyChanged("OutputString");
     174                send = true;
     175
     176            }
     177        }
     178        [PropertyInfo(Direction.InputData, "SOAP input", "Input a SOAP message to be processed by the Web Service", "", false, false, QuickWatchFormat.Text, "XmlOutputConverter")]
     179        public XmlDocument InputString
     180        {
     181            get { return this._inputDocument; }
     182            set
     183            {
     184                this._inputDocument = value;
     185
     186                OnPropertyChanged("InputString");
     187            }
     188        }
     189
     190        #endregion
     191
     192        #region Structs
    69193
    70194        private struct EncryptionSettings
    71195        {
    72             public string key;
    73196            public bool content;
    74197            public bool showsteps;
     
    80203            public bool showsteps;
    81204        }
    82         private EncryptionSettings encset;
    83         private SignatureSettings sigset;
    84        
    85        
     205
     206        #endregion
     207
     208        #region Constructor
     209
    86210        public Soap()
    87         {   
    88             soap = new XmlDocument();
    89             gotKey = false;
     211        {
     212            this._soap = new XmlDocument();
     213            this._gotKey = false;
    90214            this.presentation = new SoapPresentation(this);
    91             settings.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(settings_PropertyChanged);
    92             wsdlLoaded = false;
    93             idTable = new Hashtable();
    94             soap = new XmlDocument();
    95             encset = new EncryptionSettings();
    96             sigset = new SignatureSettings();
    97             cspParams = new CspParameters();
    98             cspParams.KeyContainerName = "XML_ENC_RSA_KEY";
    99             rsaKey = new RSACryptoServiceProvider(cspParams);
    100             rsaCryptoProv = new RSACryptoServiceProvider();
    101             dsaCryptoProv = new DSACryptoServiceProvider();
    102             wsRSACryptoProv = new RSACryptoServiceProvider();
    103             securedSOAP = new XmlDocument();
    104             soap = new XmlDocument();
    105             mySettings.idtable = idTable;
    106             rsaCryptoProv.ToXmlString(false);
    107             mySettings.rsacryptoProv = rsaCryptoProv.ToXmlString(true);
    108             mySettings.dsacryptoProv = dsaCryptoProv.ToXmlString(true);
    109             mySettings.wsRSAcryptoProv = wsRSACryptoProv.ToXmlString(false);
    110             contentCounter = 0;
    111             mySettings.securedsoap = xmlToString(securedSOAP);
     215            this._settings.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(SettingsPropertyChangedEventHandler);
     216            this._wsdlLoaded = false;
     217            this._idTable = new Hashtable();
     218            this._soap = new XmlDocument();
     219            this._encryptionSettings = new EncryptionSettings();
     220            this._signatureSettings = new SignatureSettings();
     221            this._cspParams = new CspParameters();
     222            this._cspParams.KeyContainerName = "XML_ENC_RSA_KEY";
     223            this._rsaKey = new RSACryptoServiceProvider(_cspParams);
     224            this._rsaCryptoProv = new RSACryptoServiceProvider();
     225            this._dsaCryptoProv = new DSACryptoServiceProvider();
     226            this._wsRSACryptoProv = new RSACryptoServiceProvider();
     227            this._securedSOAP = new XmlDocument();
     228            this._soap = new XmlDocument();
     229            mySettings.idtable = _idTable;
     230            this._rsaCryptoProv.ToXmlString(false);
     231            mySettings.rsacryptoProv = this._rsaCryptoProv.ToXmlString(true);
     232            mySettings.dsacryptoProv = this._dsaCryptoProv.ToXmlString(true);
     233            mySettings.wsRSAcryptoProv = this._wsRSACryptoProv.ToXmlString(false);
     234            this._contentCounter = 0;
     235            mySettings.securedsoap = CopyXmlToString(this._securedSOAP);
    112236            this.InputString = new XmlDocument();
    113             loaded = false;
    114             sigset.sigAlg = "1";
    115            
    116         }
    117 
    118         public bool getshowSteps()
    119         {
    120             return sigset.showsteps;
    121         }
    122 
    123 
    124         [PropertyInfo(Direction.InputData, "WSDL Input", "WSDL to create the soap message", null)]
    125         public XmlDocument Wsdl
    126         {
    127             set
    128             {
    129                 presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    130                    {
    131                        string s = xmlToString(value);
    132                        loadWSDL(s);
    133                        wsdlLoaded = true;
    134 
    135                        OnPropertyChanged("wsdl");
    136                        createInfoMessage("Received WSDL File");
    137                        createInfoMessage("Created SOAP Message");
    138                    }, null);
    139             }
    140             get
    141             {
    142                 return null;
    143             }
    144         }
    145 
    146         [PropertyInfo(Direction.InputData, "Public-Key input", "Encryption Key",null)]
    147         public string PublicKey
    148         {
    149             get
    150             {
    151                 return this.wsPublicKey;
    152             }
    153             set
    154             {
    155                 Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    156                 {
    157                     {
    158                         WsPublicKey = value;
    159 
    160                         WsRSACryptoProv.FromXmlString(wsPublicKey);
    161                         gotKey = true;
    162                         mySettings.gotkey = true;
    163                         mySettings.wsRSAcryptoProv = WsRSACryptoProv.ToXmlString(false);
    164                         OnPropertyChanged("publicKey");
    165                         createInfoMessage("Public Key Received");
    166                     }
    167                 }, null);
    168             }
    169         }
    170 
    171        [PropertyInfo(Direction.OutputData, "SOAP output", "Send a SOAP Message", "",true, true, QuickWatchFormat.Text, "XmlConverter")]
    172         public XmlDocument OutputString                                                                                                 
    173         {
    174             get {  return this.securedSOAP;  }
    175             set
    176             {
    177 
    178                 this.securedSOAP = value;
    179                 OnPropertyChanged("OutputString");
    180                 send = true;
    181 
    182             }
    183         }
    184        private XmlDocument inputString;
    185        [PropertyInfo(Direction.InputData, "SOAP input", "Input a SOAP message to be processed by the Web Service", "", false, false, QuickWatchFormat.Text, "XmlOutputConverter")]
    186         public XmlDocument InputString       
    187         {
    188             get { return this.inputDocument; }
    189             set
    190             {
    191             this.inputDocument = value;
    192 
    193              OnPropertyChanged("InputString");
    194             }
    195         }
    196 
    197         public Object XmlOutputConverter(Object Data)
    198         {
    199             string test = Data.ToString();
    200 
    201             if (test.StartsWith("<"))
    202             {
    203                 string test1 = Data.GetType().ToString();
    204                 test1 = test1 + " " + test;
    205                 XmlDocument doc = (XmlDocument)Data;
    206                 StringWriter t = new StringWriter();
    207                 Object obj = new Object();
    208                 try
    209                 {
    210                     XmlTextWriter j = new XmlTextWriter(t);
    211                     j.Formatting = Formatting.Indented;
    212                     doc.WriteContentTo(j);
    213                     obj = (Object)t.ToString();
    214                 }
    215                 catch (Exception e)
    216                 {
    217                     Console.WriteLine(e.ToString());
    218 
    219                 }
    220                 return obj;
     237            this._loaded = false;
     238            this._signatureSettings.sigAlg = "1";
     239        }
     240
     241        #endregion
     242
     243        #region Methods
     244
     245        public bool GetShowSteps()
     246        {
     247            return this._signatureSettings.showsteps;
     248        }
     249
     250        private void SetSignedElements(DataSet ds)
     251        {
     252            if (ds != null && ds.Tables.Count > 0)
     253            {
     254                DataTable table = ds.Tables[0];
     255                this._signedElements = new string[table.Columns.Count];
     256            }
     257        }
     258
     259        public void AddIdToElement(string element)
     260        {
     261            if (element != null)
     262            {
     263                if (!this._idTable.ContainsKey(element))
     264                {
     265                    System.Random randomizer = new Random();
     266                    int randomNumber = randomizer.Next(100000000);
     267                    if (!this._idTable.ContainsValue(randomNumber))
     268                    {
     269                        System.Threading.Thread.Sleep(500);
     270                        randomNumber = randomizer.Next(100000000);
     271                    }
     272                    this._idTable.Add(element, randomNumber);
     273                    mySettings.idtable = this._idTable;
     274                }
     275            }
     276        }
     277
     278        private XmlNode GetElementById(string id)
     279        {
     280            XmlNodeList securityHeader = this._securedSOAP.GetElementsByTagName("wsse:Security");
     281            if (securityHeader != null)
     282            {
     283                foreach (XmlNode node in securityHeader)
     284                {
     285                    foreach (XmlAttribute att in node.Attributes)
     286                    {
     287                        if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
     288                        {
     289                            return node;
     290                        }
     291                    }
     292                }
     293            }
     294            XmlNode body = this._securedSOAP.GetElementsByTagName("s:Body")[0];
     295            if (body != null)
     296            {
     297                foreach (XmlAttribute att in body.Attributes)
     298                {
     299                    if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
     300                    {
     301                        return body;
     302                    }
     303                }
     304            }
     305
     306            foreach (XmlNode node in body.ChildNodes)
     307            {
     308                foreach (XmlAttribute att in node.Attributes)
     309                {
     310                    if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
     311                    {
     312                        return node;
     313                    }
     314                }
     315                foreach (XmlNode child in node.ChildNodes)
     316                {
     317                    foreach (XmlAttribute att in child.Attributes)
     318                    {
     319                        if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
     320                        {
     321                            return child;
     322                        }
     323                    }
     324                }
    221325            }
    222326            return null;
    223          
    224         }
    225 
    226         public Object XmlConverter(Object Data)
    227         {
    228             string test = Data.ToString();
    229             if (test.StartsWith("<"))
    230             {
    231                 XmlDocument doc = (XmlDocument)this.securedSOAP;
    232                 StringWriter t = new StringWriter();
    233                 Object obj = new Object();
    234                 try
    235                 {
    236                     XmlTextWriter j = new XmlTextWriter(t);
    237                     j.Formatting = Formatting.Indented;
    238                     doc.WriteContentTo(j);
    239                     obj = (Object)t.ToString();
    240                 }
    241                 catch (Exception e)
    242                 {
    243                     Console.WriteLine(e.ToString());
    244 
    245                 }
    246                 return obj;
    247             }
    248             return null;
    249         }
    250 
    251         public void setSignedElements(DataSet ds)
    252         {
    253             DataTable table = ds.Tables[0];
    254             signedElements = new string[table.Columns.Count];
    255         }
    256 
    257         public void clearSoap()
    258         {
    259             this.soap.RemoveAll();
    260             this.soap = new XmlDocument();
    261      
    262             this.node = null;   
    263         }
    264 
    265         public void addIdToElement(string element)
    266         {
    267             if(!idTable.ContainsKey(element))
    268             {
    269             System.Random r = new Random();
    270             int zufallszahl = r.Next(100000000);
    271                 if(!idTable.ContainsValue(zufallszahl))
    272                 {
    273                     System.Threading.Thread.Sleep(500);
    274                     zufallszahl = r.Next(100000000);
    275                 }
    276                 idTable.Add(element, zufallszahl);
    277                 mySettings.idtable = idTable;
    278             }
    279         }
    280 
    281         private XmlNode getElementById(string id)
    282         {
    283 
    284             XmlNodeList securityHeader = securedSOAP.GetElementsByTagName("wsse:Security");
    285             foreach(XmlNode node in securityHeader)
    286             {
    287                 foreach (XmlAttribute att in node.Attributes)
    288                 {
    289                     if(att.Name.Equals("Id") && ("#"+att.Value).Equals(id))
    290                     {
    291                         return node;
    292                     }
    293                 }
    294             }
    295 
    296             XmlNode body = securedSOAP.GetElementsByTagName("s:Body")[0];
    297             foreach (XmlAttribute att in body.Attributes)
    298             {
    299                 if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
    300                 {
    301                     return body;
    302                 }
    303             }
    304  
    305             foreach (XmlNode node in body.ChildNodes)
    306             {
    307                 foreach (XmlAttribute att in node.Attributes)
    308                 {
    309                     if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
    310                     {
    311                         return node;
    312                     }
    313                 }
    314                 foreach(XmlNode child in node.ChildNodes)
    315                 {
    316                     foreach (XmlAttribute att in child.Attributes)
    317                     {
    318                         if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
    319                         {
    320                             return child;
    321                         }
    322                     }
    323                 }
    324             }
    325             return null;
    326         }
    327      
    328         public XmlNode[] getSignedElements()
     327        }
     328
     329        public XmlNode[] GetSignedElements()
    329330        {
    330331            ArrayList list = new ArrayList();
    331             if (bodySigned)
    332             {
    333                 list.Add(securedSOAP.GetElementsByTagName("s:Body")[0]);
    334             }
    335             if (methodNameSigned)
    336             {
    337                 list.Add(securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild);
    338             }
    339             foreach(XmlNode node in securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.ChildNodes)
    340             {
    341                 if(isSigned(node))
     332            if (this._bodySigned)
     333            {
     334                list.Add(this._securedSOAP.GetElementsByTagName("s:Body")[0]);
     335            }
     336            if (this._methodNameSigned)
     337            {
     338                list.Add(this._securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild);
     339            }
     340            foreach (XmlNode node in this._securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.ChildNodes)
     341            {
     342                if (this.GetIsSigned(node))
    342343                {
    343344                    list.Add(node);
    344345                }
    345346            }
    346             if(secHeaderSigned)
    347             {
    348                 if (isSigned(securedSOAP.GetElementsByTagName("wsse:Security")[0]));
    349              {
    350                 list.Add(securedSOAP.GetElementsByTagName("wsse:Security")[0]);
    351             }
    352             }
    353 
    354 
    355             XmlNode[] retArray = new XmlNode[list.Count];
     347            if (this._secHeaderSigned)
     348            {
     349                if (this.GetIsSigned(this._securedSOAP.GetElementsByTagName("wsse:Security")[0])) ;
     350                {
     351                    list.Add(this._securedSOAP.GetElementsByTagName("wsse:Security")[0]);
     352                }
     353            }
     354
     355
     356            XmlNode[] signedElements = new XmlNode[list.Count];
    356357
    357358            for (int i = 0; i < list.Count; i++)
    358359            {
    359                 retArray[i] = (XmlNode)list[i];
    360             }
    361             return retArray;
    362         }
    363 
    364         public XmlNode[] getElementsToSign()
    365         {
    366             if (secHeaderEnc && secHeaderSigned)
    367             {
    368                 XmlNode[] retArray = new XmlNode[0];
    369                 return retArray;
    370             }
    371             if (secHeaderEnc)
    372             {
    373                 XmlNode[] retArray = new XmlNode[1];
    374                 retArray[0] = securedSOAP.GetElementsByTagName("wsse:Security")[0];
    375                 return retArray;
    376             }
    377 
    378            
     360                signedElements[i] = (XmlNode)list[i];
     361            }
     362            return signedElements;
     363        }
     364
     365        public XmlNode[] GetElementsToSign()
     366        {
     367            if (this._secHeaderEnc && this._secHeaderSigned)
     368            {
     369                XmlNode[] elementToSign = new XmlNode[0];
     370                return elementToSign;
     371            }
     372            if (this._secHeaderEnc)
     373            {
     374                XmlNode[] elementToSign = new XmlNode[1];
     375                elementToSign[0] = this._securedSOAP.GetElementsByTagName("wsse:Security")[0];
     376                return elementToSign;
     377            }
     378
     379
    379380            ArrayList list = new ArrayList();
    380             if (!secHeaderSigned && (securedSOAP.GetElementsByTagName("wsse:Security").Count>0))
    381             {
    382                 list.Add(securedSOAP.GetElementsByTagName("wsse:Security")[0]);
    383             }
    384             XmlNode Body = securedSOAP.GetElementsByTagName("s:Body")[0];
    385             XmlNode BodysChild = Body.ChildNodes[0];
    386             if (!bodySigned)
    387             {
    388                 list.Add(Body);
    389                 if (!bodyEncrypted)
    390                
    391                     if (!methodNameSigned)
    392                     {
    393                         list.Add(BodysChild);
    394                         if(!methodNameEncrypted)
    395                         {
    396                             foreach(XmlNode childNode in BodysChild.ChildNodes)
     381            if (!this._secHeaderSigned && (this._securedSOAP.GetElementsByTagName("wsse:Security").Count > 0))
     382            {
     383                list.Add(this._securedSOAP.GetElementsByTagName("wsse:Security")[0]);
     384            }
     385            XmlNode body = _securedSOAP.GetElementsByTagName("s:Body")[0];
     386            XmlNode bodysChildNode = body.ChildNodes[0];
     387            if (!this._bodySigned)
     388            {
     389                list.Add(body);
     390                if (!this._bodyEncrypted)
     391
     392                    if (!this._methodNameSigned)
     393                    {
     394                        list.Add(bodysChildNode);
     395                        if (!this._methodNameEncrypted)
     396                        {
     397                            foreach (XmlNode childNode in bodysChildNode.ChildNodes)
    397398                            {
    398                                 bool Signed = false;
    399                                 XmlNode[] signedElement = this.getSignedElements();
    400                                 foreach(XmlNode sigElem in signedElement)
     399                                bool signed = false;
     400                                XmlNode[] signedElements = this.GetSignedElements();
     401                                foreach (XmlNode signedElement in signedElements)
    401402                                {
    402                                     if (childNode.Name.Equals(sigElem.Name))
     403                                    if (childNode.Name.Equals(signedElement.Name))
    403404                                    {
    404                                         Signed = true;
     405                                        signed = true;
    405406                                    }
    406407                                }
    407                                 if(!Signed)
     408                                if (!signed)
    408409                                {
    409410                                    list.Add(childNode);
     
    412413                        }
    413414                    }
    414                 }
    415 
    416            
    417             XmlNode[] retArray1 = new XmlNode[list.Count];
     415            }
     416
     417
     418            XmlNode[] elementsToSign = new XmlNode[list.Count];
    418419
    419420            for (int i = 0; i < list.Count; i++)
    420421            {
    421                 retArray1[i] = (XmlNode)list[i];
    422             }
    423             return retArray1;
    424         }
    425 
    426         public bool hasEncryptedContent(XmlNode node)
     422                elementsToSign[i] = (XmlNode)list[i];
     423            }
     424            return elementsToSign;
     425        }
     426
     427        private bool GetHasEncryptedContent(XmlNode node)
    427428        {
    428429            bool value = false;
    429             if (node.HasChildNodes)
     430            if (node != null && node.HasChildNodes)
    430431            {
    431432                if (node.ChildNodes[0].Name.Equals("xenc:EncryptedData"))
     
    443444        }
    444445
    445         public XmlNode[] getEncryptedElements()
     446        public XmlNode[] GetEncryptedElements()
    446447        {
    447448            ArrayList list = new ArrayList();
    448 
    449 
    450             XmlNode header = securedSOAP.GetElementsByTagName("s:Header")[0];
     449            XmlNode header = this._securedSOAP.GetElementsByTagName("s:Header")[0];
    451450            if (header != null)
    452451            {
    453                 foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
     452                foreach (XmlNode node in this._securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
    454453                {
    455454                    if (node.Name.Equals("wsse:Security"))
    456455                    {
    457                         if (hasEncryptedContent(node))
     456                        if (GetHasEncryptedContent(node))
    458457                        {
    459458                            list.Add(node);
     
    463462            }
    464463
    465             XmlElement body = (XmlElement)securedSOAP.GetElementsByTagName("s:Body")[0];
    466 
    467 
    468             if (hasEncryptedContent(body))
     464            XmlElement body = (XmlElement)_securedSOAP.GetElementsByTagName("s:Body")[0];
     465            if (GetHasEncryptedContent(body))
    469466            {
    470467                list.Add(body);
     
    480477                    else
    481478                    {
    482                         if(hasEncryptedContent(node))
    483                         {list.Add(node);
     479                        if (GetHasEncryptedContent(node))
     480                        {
     481                            list.Add(node);
    484482                        }
    485483                        foreach (XmlNode nod in node.ChildNodes)
     
    491489                            else
    492490                            {
    493                                 if (hasEncryptedContent(nod))
     491                                if (GetHasEncryptedContent(nod))
    494492                                {
    495493                                    list.Add(nod);
     
    502500
    503501
    504             XmlNode[] retArray = new XmlNode[list.Count];
     502            XmlNode[] encryptedElements = new XmlNode[list.Count];
    505503
    506504            for (int i = 0; i < list.Count; i++)
    507505            {
    508                 retArray[i] = (XmlNode)list[i];
    509             }
    510             return retArray;
    511         }
    512 
    513         public XmlNode[] getElementsToEnc()
    514         {
    515             if (secHeaderEnc && secHeaderSigned)
    516             {
    517                 XmlNode[] retArray = new XmlNode[0];
    518                 return retArray;
    519             }
    520             if (secHeaderSigned)
    521             {
    522                 XmlNode[] retArray = new XmlNode[1];
    523                 retArray[0] = securedSOAP.GetElementsByTagName("wsse:Security")[0];
    524                 return retArray;
     506                encryptedElements[i] = (XmlNode)list[i];
     507            }
     508            return encryptedElements;
     509        }
     510
     511        public XmlNode[] GetElementsToEncrypt()
     512        {
     513            if (this._secHeaderEnc && this._secHeaderSigned)
     514            {
     515                XmlNode[] elementToEncrypt = new XmlNode[0];
     516                return elementToEncrypt;
     517            }
     518            if (this._secHeaderSigned)
     519            {
     520                XmlNode[] elementToEncrypt = new XmlNode[1];
     521                elementToEncrypt[0] = _securedSOAP.GetElementsByTagName("wsse:Security")[0];
     522                return elementToEncrypt;
    525523            }
    526524            else
     
    528526
    529527                ArrayList list = new ArrayList();
    530                 XmlNode header = securedSOAP.GetElementsByTagName("s:Header")[0];
     528                XmlNode header = this._securedSOAP.GetElementsByTagName("s:Header")[0];
    531529                if (header != null)
    532530                {
    533                     foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
    534                     {
    535                         if (node.Name.Equals("wsse:Security") && (!hasEncryptedContent(node)))
     531                    foreach (XmlNode node in this._securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
     532                    {
     533                        if (node.Name.Equals("wsse:Security") && (!GetHasEncryptedContent(node)))
    536534                        {
    537535                            list.Add(node);
     
    539537                    }
    540538                }
    541                 XmlElement body = (XmlElement)securedSOAP.GetElementsByTagName("s:Body")[0];
    542 
    543 
    544                 if (!hasEncryptedContent(body))
     539                XmlElement body = (XmlElement)_securedSOAP.GetElementsByTagName("s:Body")[0];
     540                if (!GetHasEncryptedContent(body))
    545541                {
    546542                    list.Add(body);
    547                     if (!bodySigned)
     543                    if (!this._bodySigned)
    548544                    {
    549545                        foreach (XmlNode node in body.ChildNodes)
    550546                        {
    551                             if (!hasEncryptedContent(node) && (!node.Name.Equals("xenc:EncryptedData")))
     547                            if (!GetHasEncryptedContent(node) && (!node.Name.Equals("xenc:EncryptedData")))
    552548                            {
    553549                                list.Add(node);
    554                                 if (!methodNameSigned)
     550                                if (!this._methodNameSigned)
    555551                                {
    556552                                    foreach (XmlNode nod in node.ChildNodes)
    557553                                    {
    558                                         if (!hasEncryptedContent(nod) && (!nod.Name.Equals("xenc:EncryptedData")))
     554                                        if (!GetHasEncryptedContent(nod) && (!nod.Name.Equals("xenc:EncryptedData")))
    559555                                        {
    560556                                            list.Add(nod);
     
    566562                    }
    567563                }
    568                 XmlNode[] retArray = new XmlNode[list.Count];
     564                XmlNode[] elementsToEncrypt = new XmlNode[list.Count];
    569565
    570566                for (int i = 0; i < list.Count; i++)
    571567                {
    572                     retArray[i] = (XmlNode)list[i];
    573                 }
    574                 return retArray;
    575             }
    576            
    577         }
    578 
    579         private bool isSigned(XmlNode node)
     568                    elementsToEncrypt[i] = (XmlNode)list[i];
     569                }
     570                return elementsToEncrypt;
     571            }
     572
     573        }
     574
     575        private bool GetIsSigned(XmlNode node)
    580576        {
    581577            bool signed = false;
    582             foreach(XmlAttribute att in node.Attributes )
    583             {
    584                 if (att.Name.Equals("Id"))
    585                 {
    586                     foreach (XmlNode refElem in securedSOAP.GetElementsByTagName("ds:Reference"))
    587                     {
    588                         foreach(XmlAttribute refAtt in refElem.Attributes)
    589                         {
    590                             if(refAtt.Name.Equals("URI"))
     578            if (node != null)
     579            {
     580                foreach (XmlAttribute att in node.Attributes)
     581                {
     582                    if (att.Name.Equals("Id"))
     583                    {
     584                        foreach (XmlNode refElem in this._securedSOAP.GetElementsByTagName("ds:Reference"))
     585                        {
     586                            foreach (XmlAttribute refAtt in refElem.Attributes)
    591587                            {
    592                                 if (refAtt.Value.Equals("#"+att.Value))
     588                                if (refAtt.Name.Equals("URI"))
    593589                                {
    594                                     return true;
     590                                    if (refAtt.Value.Equals("#" + att.Value))
     591                                    {
     592                                        return true;
     593                                    }
    595594                                }
    596595                            }
     
    598597                    }
    599598                }
    600             }
    601             foreach (XmlNode xPath in securedSOAP.GetElementsByTagName("ds:XPath"))
    602             {
    603                 string[] splitter = xPath.InnerText.Split(new char[]{'/'});
    604                 if(splitter[splitter.Length-1].Equals(node.Name))
    605                 {
    606                    return true;
     599                foreach (XmlNode xPath in _securedSOAP.GetElementsByTagName("ds:XPath"))
     600                {
     601                    string[] splitter = xPath.InnerText.Split(new char[] { '/' });
     602                    if (splitter[splitter.Length - 1].Equals(node.Name))
     603                    {
     604                        return true;
     605                    }
    607606                }
    608607            }
     
    610609        }
    611610
    612         public XmlNode[] getParameterToEdit()
     611        public XmlNode[] GetParameterToEdit()
    613612        {
    614613            ArrayList list = new ArrayList();
    615             if(bodyEncrypted ||bodySigned || methodNameEncrypted || methodNameSigned)
     614            if (this._bodyEncrypted || this._bodySigned || this._methodNameEncrypted || this._methodNameSigned)
    616615            {
    617616                XmlNode[] emptySet = new XmlNode[0];
    618617                return emptySet;
    619618            }
    620             if (secHeaderEnc || secHeaderSigned)
    621             {
    622                 XmlNode[] retArray = new XmlNode[0];
    623                 return retArray;
    624             }
    625 
    626             if (!secHeaderEnc)
    627             {
    628                 foreach (XmlNode param in securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.ChildNodes)
    629                 {
    630                     if (!isSigned(param))
    631                     {
    632                         if (!hasEncryptedContent(param))
    633                         {
    634                             if (!param.Name.Equals("xenc:EncryptedData"))
    635                                 list.Add(param);
    636                         }
    637                     }
    638                 }
    639             }
    640             XmlNode[] nodeset = new XmlNode[list.Count];
     619            if (this._secHeaderEnc || this._secHeaderSigned)
     620            {
     621                XmlNode[] emptySet = new XmlNode[0];
     622                return emptySet;
     623            }
     624
     625            if (!this._secHeaderEnc)
     626            {
     627                foreach (XmlNode parameter in this._securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.ChildNodes)
     628                {
     629                    if (!GetIsSigned(parameter))
     630                    {
     631                        if (!GetHasEncryptedContent(parameter))
     632                        {
     633                            if (!parameter.Name.Equals("xenc:EncryptedData"))
     634                                list.Add(parameter);
     635                        }
     636                    }
     637                }
     638            }
     639            XmlNode[] parametersToEdit = new XmlNode[list.Count];
    641640            for (int i = 0; i < list.Count; i++)
    642641            {
    643                 nodeset[i] = (XmlNode)list[i];
    644             }
    645             return nodeset;
    646         }
    647 
    648         public XmlNode[] getParameter()
     642                parametersToEdit[i] = (XmlNode)list[i];
     643            }
     644            return parametersToEdit;
     645        }
     646
     647        public XmlNode[] GetParameter()
    649648        {
    650649            ArrayList list = new ArrayList();
    651             foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Body")[0].ChildNodes[0].ChildNodes)
    652             {
    653                 XmlNode[] signedNodes = getSignedElements();
     650            foreach (XmlNode node in this._securedSOAP.GetElementsByTagName("s:Body")[0].ChildNodes[0].ChildNodes)
     651            {
     652                XmlNode[] signedNodes = GetSignedElements();
    654653                bool isSigned = false;
    655654                foreach (XmlNode signedElement in signedNodes)
     
    661660
    662661                }
    663                 XmlNode[] encryptedNodes = getEncryptedElements();
    664                 bool isEncrypted=false;
     662                XmlNode[] encryptedNodes = GetEncryptedElements();
     663                bool isEncrypted = false;
    665664                foreach (XmlNode encryptedNode in encryptedNodes)
    666665                {
    667                     if(encryptedNode.Equals(node))
     666                    if (encryptedNode.Equals(node))
    668667                    {
    669668                        isEncrypted = true;
     
    675674                }
    676675            }
    677             XmlNode[] nodeset = new XmlNode[list.Count];
     676            XmlNode[] parameters = new XmlNode[list.Count];
    678677            for (int i = 0; i < list.Count; i++)
    679678            {
    680                 nodeset[i] = (XmlNode)list[i];
    681             }
    682             return nodeset;
    683         }
    684 
    685         public string getSignatureAlg()
    686         {
    687             return sigset.sigAlg;
    688         }
    689 
    690         void settings_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    691         {
    692             SoapSettings s = (SoapSettings)sender;
    693 
    694             switch (e.PropertyName)
    695             {
    696                 case "SignatureAlg":
    697                     sigset.sigAlg = s.SignatureAlg;
    698                     break;
    699 
    700                 case "SigXPathRef":
    701                     sigset.Xpath = s.SigXPathRef;
    702                     break;
    703 
    704                 case "SigShowSteps":
    705                     sigset.showsteps = s.SigShowSteps;
    706                     break;
    707                 case "EncContentRadio":
    708                     if (s.EncContentRadio == 0)
    709                     {
    710                         encset.content = false;
    711                     }
    712                     if (s.EncContentRadio == 1)
    713                     {
    714                         encset.content = true;
    715                     }
    716                     break;
    717 
    718                 case "EncShowSteps":
    719                     encset.showsteps = s.EncShowSteps;
    720                     break;
    721                 case "gotkey":
    722                     this.gotKey = s.gotkey;
    723                     break;
    724                 case "wspublicKey":
    725                    this.wsPublicKey =s.wspublicKey;
    726                     break;
    727                 case "dsacryptoProv":
    728                     this.dsaCryptoProv.FromXmlString( s.dsacryptoProv);
    729                     break;
    730                 case "rsacryptoProv":
    731                     this.rsaCryptoProv.FromXmlString( s.rsacryptoProv);
    732                     break;
    733                 case "wsRSAcryptoProv":
    734                     this.wsRSACryptoProv.FromXmlString(s.wsRSAcryptoProv);
    735                     break;
    736                 case "contentcounter":
    737                     this.contentCounter = s.contentcounter;
    738                     break;
    739                 case "secheaderSigned":
    740                     this.secHeaderSigned = s.secheaderSigned;
    741                     break;
    742                 case "secheaderEnc":
    743                     this.secHeaderEnc = s.secheaderEnc;
    744                     break;
    745                 case "methodnameencrypted":
    746                     this.methodNameEncrypted = s.methodnameencrypted;
    747                     break;
    748                 case "bodyencrypted":
    749                     this.bodyEncrypted = s.bodyencrypted;
    750                     break;
    751                 case "methodnameSigned":
    752                     this.methodNameSigned = s.methodnameSigned;
    753                     break;
    754                 case "bodysigned":
    755                     this.bodySigned= s.bodysigned;
    756                     break;
    757                 case "idtable":
    758                     this.idTable = s.idtable;
    759                     break;
    760                 case "securedsoap":
    761                     if (s.securedsoap != null)
    762                     {
    763                         if (!loaded)
    764                         {
    765                             securedSOAP = (stringToXml(s.securedsoap));
    766                             showsecuredSoap();
    767                             loaded = true;
    768                         }
    769                         else
    770                         {
    771                             loaded = true;
    772                         }
    773                     }
    774                     break;
    775                 case "soapelement":
    776                     if (s.soapelement != null)
    777                     {
    778                         this.soap = stringToXml(s.soapelement);
    779                     }
    780                    break;
    781                 case "wsdlloaded":
    782                     this.wsdlLoaded = s.wsdlloaded ;
    783                     break;
    784                 case "sendSoap":
    785                     if (!send)
    786                     {
    787                         OnPropertyChanged("OutputString");
    788                         send = true;
    789                     }
    790                     break;
    791                 case "resetSoap":
    792                     if (this.soap != null)
    793                     {
    794                         securedSOAP = (XmlDocument)this.soap.Clone();
    795                         mySettings.securedsoap = xmlToString(securedSOAP);
    796                         showsecuredSoap();
    797                     }
    798                     break;
    799                 case "AnimationSpeed":
    800                     presentation.setAnimationSpeed(s.AnimationSpeed);
    801                     break;
    802                 case "playPause":
    803                     presentation.startstopanimation();
    804                     break;
    805                 case "endAnimation":
    806                     presentation.endAnimation();
    807                     break;
    808 
    809             }
    810         }
    811 
    812         public void saveSoap()
    813         {
    814             mySettings.securedsoap = xmlToString(this.securedSOAP);
    815         }
    816 
    817         public void loadWSDL(string wsdlString)
    818         {
    819             if (!wsdlString.Equals(""))
    820             {
    821                 StringReader sr = new StringReader(wsdlString);
    822                 XmlTextReader tx = new XmlTextReader(sr);
    823 
    824                 ServiceDescription t = ServiceDescription.Read(tx);
    825                 ServiceDescription serviceDescription = t.Services[0].ServiceDescription;
     679                parameters[i] = (XmlNode)list[i];
     680            }
     681            return parameters;
     682        }
     683
     684        public string GetSignatureAlgorithm()
     685        {
     686            return this._signatureSettings.sigAlg;
     687        }
     688
     689        public void SaveSoap()
     690        {
     691            mySettings.securedsoap = CopyXmlToString(this._securedSOAP);
     692        }
     693
     694        public void LoadWSDL(string wsdlString)
     695        {
     696            if (wsdlString != null && !wsdlString.Equals(""))
     697            {
     698                StringReader stringReader = new StringReader(wsdlString);
     699                XmlTextReader xmlTextReader = new XmlTextReader(stringReader);
     700                ServiceDescription serviceDescriptionsRead = ServiceDescription.Read(xmlTextReader);
     701                ServiceDescription serviceDescription = serviceDescriptionsRead.Services[0].ServiceDescription;
    826702                Types types = serviceDescription.Types;
    827                 PortTypeCollection portTypes = serviceDescription.PortTypes;
    828                 MessageCollection messages = serviceDescription.Messages;
    829                 XmlSchema schema = types.Schemas[0];
    830                 PortType porttype = portTypes[0];
    831                 Operation operation = porttype.Operations[0];
    832                 OperationInput input = operation.Messages[0].Operation.Messages.Input;
    833                 Message message = messages[input.Message.Name];
    834                 MessagePart messagePart = message.Parts[0];
    835                 XmlSchema fsdf = types.Schemas[0];
    836                 if (fsdf == null)
    837                 {
    838                     Console.WriteLine("Test");
    839                 }
    840                 StringWriter twriter = new StringWriter();
    841                 fsdf.Write(twriter);
     703                //PortTypeCollection portTypes = serviceDescription.PortTypes;
     704                //MessageCollection messages = serviceDescription.Messages;
     705                //XmlSchema schema = types.Schemas[0];
     706                //PortType porttype = portTypes[0];
     707                //Operation operation = porttype.Operations[0];
     708                //OperationInput input = operation.Messages[0].Operation.Messages.Input;
     709                //Message message = messages[input.Message.Name];
     710                //MessagePart messagePart = message.Parts[0];
     711                XmlSchema xmlSchema = types.Schemas[0];
     712                StringWriter stringWriter = new StringWriter();
     713                xmlSchema.Write(stringWriter);
    842714                DataSet set = new DataSet();
    843                 StringReader sreader = new StringReader(twriter.ToString());
     715                StringReader sreader = new StringReader(stringWriter.ToString());
    844716                XmlTextReader xmlreader = new XmlTextReader(sreader);
    845717                set.ReadXmlSchema(xmlreader);
    846                 this.setSignedElements(set);
    847                 soap = new XmlDocument();
    848                 node = soap.CreateXmlDeclaration("1.0", "ISO-8859-1", "yes");
    849                 soap.AppendChild(node);
    850                 envelope = soap.CreateElement("s", "Envelope", "http://www.w3.org/2003/05/soap-envelope");
    851                 soap.AppendChild(envelope);
    852                 body = soap.CreateElement("s", "Body", "http://www.w3.org/2003/05/soap-envelope");
    853                 XmlNode eingabe = soap.CreateElement("tns", set.Tables[0].ToString(), set.Tables[0].Namespace);
     718                this.SetSignedElements(set);
     719                this._soap = new XmlDocument();
     720                this._node = this._soap.CreateXmlDeclaration("1.0", "ISO-8859-1", "yes");
     721                this._soap.AppendChild(_node);
     722                this._envelope = this._soap.CreateElement("s", "Envelope", "http://www.w3.org/2003/05/soap-envelope");
     723                this._soap.AppendChild(_envelope);
     724                this._body = this._soap.CreateElement("s", "Body", "http://www.w3.org/2003/05/soap-envelope");
     725                XmlNode inputNode = this._soap.CreateElement("tns", set.Tables[0].ToString(), set.Tables[0].Namespace);
    854726                DataTable table = set.Tables[0];
    855727                foreach (DataColumn tempColumn in table.Columns)
    856728                {
    857                     XmlNode neu = soap.CreateElement("tns", tempColumn.ColumnName, set.Tables[0].Namespace);
    858                     eingabe.AppendChild(neu);
    859                 }
    860                 body.AppendChild(eingabe);
    861                 envelope.AppendChild(body);
    862                 StringWriter ti = new StringWriter();
    863                 XmlTextWriter j = new XmlTextWriter(ti);
    864                 j.Formatting = Formatting.Indented;
    865                 soap.WriteContentTo(j);
    866                 XmlNode rootElement = soap.SelectSingleNode("/*");
     729                    XmlNode newElement = this._soap.CreateElement("tns", tempColumn.ColumnName, set.Tables[0].Namespace);
     730                    inputNode.AppendChild(newElement);
     731                }
     732                this._body.AppendChild(inputNode);
     733                this._envelope.AppendChild(this._body);
     734                stringWriter = new StringWriter();
     735                XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
     736                xmlTextWriter.Formatting = Formatting.Indented;
     737                this._soap.WriteContentTo(xmlTextWriter);
     738                XmlNode rootElement = this._soap.SelectSingleNode("/*");
    867739                presentation.origSoapItem = new System.Windows.Controls.TreeViewItem();
    868740                presentation.origSoapItem.IsExpanded = true;
     
    883755                origSoapPanel2.Children.Insert(0, origSoapElem2);
    884756                presentation.origSoapItem.Header = panel1;
    885                 loaded = false;
    886                 securedSOAP = (XmlDocument)soap.Clone();
    887                 mySettings.soapelement = xmlToString(soap);
    888                 mySettings.securedsoap = xmlToString(securedSOAP);
     757                this._loaded = false;
     758                this._securedSOAP = (XmlDocument)this._soap.Clone();
     759                mySettings.soapelement = CopyXmlToString(this._soap);
     760                mySettings.securedsoap = CopyXmlToString(this._securedSOAP);
    889761                this.presentation.CopyXmlToTreeView(rootElement, ref presentation.origSoapItem);
    890762                this.presentation.treeView.Items.Add(presentation.origSoapItem);
    891763                presentation.treeView.Items.Refresh();
    892                 showsecuredSoap();
    893                 loaded = true;
    894                 this.InputString = this.soap;
    895                 wsdlLoaded = true;
     764                ShowSecuredSoap();
     765                this._loaded = true;
     766                this.InputString = this._soap;
     767                this._wsdlLoaded = true;
    896768                mySettings.wsdlloaded = true;
    897769                OnPropertyChanged("OutputString");
     
    899771        }
    900772
    901         public bool getShowEncSteps()
    902         {
    903             return encset.showsteps;
    904         }
    905 
    906         public bool getEncContent()
    907         {
    908             return encset.content;
    909         }
    910 
    911         public string xmlToString(XmlDocument doc)
     773        public bool GetIsShowEncryptionsSteps()
     774        {
     775            return this._encryptionSettings.showsteps;
     776        }
     777
     778        public bool GetIsEncryptContent()
     779        {
     780            return this._encryptionSettings.content;
     781        }
     782
     783        public string CopyXmlToString(XmlDocument doc)
    912784        {
    913785            if (doc != null)
    914786            {
    915                 StringWriter sw = new StringWriter();
     787                StringWriter stringWriter = new StringWriter();
    916788                doc.Normalize();
    917                 XmlTextWriter tx = new XmlTextWriter(sw);
    918                 tx.Formatting = Formatting.Indented;
    919                 doc.WriteContentTo(tx);
    920                 return sw.ToString();
     789                XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
     790                xmlTextWriter.Formatting = Formatting.Indented;
     791                doc.WriteContentTo(xmlTextWriter);
     792                return stringWriter.ToString();
    921793            }
    922794            else
     
    926798        }
    927799
    928         public XmlDocument stringToXml(string s)
     800        public XmlDocument CopyStringToXml(string s)
    929801        {
    930802            XmlDocument doc = new XmlDocument();
    931803            if (!s.Equals(""))
    932804            {
    933                 StringReader sr = new StringReader(s);
    934                 XmlTextReader tx = new XmlTextReader(sr);
    935                 doc.Load(tx);
     805                StringReader stringReader = new StringReader(s);
     806                XmlTextReader xmlTextReader = new XmlTextReader(stringReader);
     807                doc.Load(xmlTextReader);
    936808            }
    937809            return doc;
    938810        }
    939811
    940         public void addSignedElement(string newElement)
     812        public void AddSignedElement(string newElement)
    941813        {
    942814            bool isSigned = false;
    943             foreach (string s in signedElements)
     815            foreach (string signedElement in this._signedElements)
     816            {
     817                if (signedElement != null)
     818                {
     819                    if (signedElement.Equals(newElement))
     820                    {
     821                        isSigned = true;
     822                    }
     823                }
     824            }
     825            if (!isSigned)
     826            {
     827                int count = -1;
     828                foreach (string signedElement in this._signedElements)
     829                {
     830                    count++;
     831                    if (signedElement == null)
     832                    {
     833                        break;
     834                    }
     835
     836                }
     837                this._signedElements[count] = newElement;
     838            }
     839        }
     840
     841        public bool GetIsSigned(string Element)
     842        {
     843            bool issigned = false;
     844            foreach (string s in _signedElements)
    944845            {
    945846                if (s != null)
    946847                {
    947                     if (s.Equals(newElement))
    948                     {
    949                         isSigned = true;
    950                     }
    951                 }
    952             }
    953             if (!isSigned)
    954             {
    955                 int count = -1;
    956                 foreach (string s in signedElements)
    957                 {
    958                     count++;
    959                     if(s==null)
    960                     {
    961                         break;
    962                     }
    963                
    964                 }
    965                 signedElements[count] = newElement;
    966             }
    967         }
    968 
    969         public bool isSigned(string Element)
    970         {
    971             bool issigned = false;
    972             foreach(string s in signedElements)
    973             {
    974                 if (s != null)
    975                 {
    976848                    if (s.Equals(Element))
    977849                    {
     
    983855        }
    984856
    985         public void removeSignature(string Id)
    986         {
    987             XmlNodeList SignatureElements = securedSOAP.GetElementsByTagName("ds:Signature");
     857        public void RemoveSignature(string Id)
     858        {
     859            XmlNodeList signatureElements = this._securedSOAP.GetElementsByTagName("ds:Signature");
    988860            ArrayList list = new ArrayList();
    989             XmlNode toDelete=null;
    990             foreach(XmlNode node in SignatureElements)
    991             {
    992                
    993                 foreach(XmlNode child in node.FirstChild.ChildNodes)
    994                 {
    995                 if (child.Name.Equals("ds:Reference"))
    996                 {
    997                     foreach(XmlAttribute att in child.Attributes)
    998                     {
    999                         if (att.Name.Equals("URI"))
    1000                         {
    1001                             if (att.Value.Equals("#" + Id))
    1002                             {
    1003                                 toDelete = node;
    1004                             }
    1005                         }
    1006                     }
    1007                 }
    1008             }
    1009             }
    1010             if (toDelete != null)
    1011             {
    1012                 foreach (XmlNode node in toDelete.ChildNodes)
    1013                 {
    1014                     if(node.Name.Equals("ds:Reference"))
    1015                     {
    1016                         foreach (XmlAttribute att in node.Attributes)
     861            XmlNode nodeToDelete = null;
     862            foreach (XmlNode node in signatureElements)
     863            {
     864
     865                foreach (XmlNode child in node.FirstChild.ChildNodes)
     866                {
     867                    if (child.Name.Equals("ds:Reference"))
     868                    {
     869                        foreach (XmlAttribute att in child.Attributes)
    1017870                        {
    1018871                            if (att.Name.Equals("URI"))
    1019872                            {
    1020                                 if (!att.Value.Equals("#" + Id))
     873                                if (att.Value.Equals("#" + Id))
    1021874                                {
    1022                                     string[] id = att.Value.Split(new char[]{'#'});
    1023                                     XmlNode elem = getElementById(id[0]);
    1024                                     list.Add(elem);
     875                                    nodeToDelete = node;
    1025876                                }
    1026877                            }
     
    1029880                }
    1030881            }
     882            if (nodeToDelete != null)
     883            {
     884                foreach (XmlNode node in nodeToDelete.ChildNodes)
     885                {
     886                    if (node.Name.Equals("ds:Reference"))
     887                    {
     888                        foreach (XmlAttribute atttribute in node.Attributes)
     889                        {
     890                            if (atttribute.Name.Equals("URI"))
     891                            {
     892                                if (!atttribute.Value.Equals("#" + Id))
     893                                {
     894                                    string[] id = atttribute.Value.Split(new char[] { '#' });
     895                                    XmlNode element = this.GetElementById(id[0]);
     896                                    list.Add(element);
     897                                }
     898                            }
     899                        }
     900                    }
     901                }
     902            }
    1031903            XmlElement[] signArray = new XmlElement[list.Count];
    1032904
     
    1036908            }
    1037909
    1038             if (toDelete != null)
    1039             {
    1040                 securedSOAP.GetElementsByTagName("wsse:Security")[0].RemoveChild(toDelete);
     910            if (nodeToDelete != null)
     911            {
     912                this._securedSOAP.GetElementsByTagName("wsse:Security")[0].RemoveChild(nodeToDelete);
    1041913            }
    1042914
    1043915            if (signArray.Length > 0)
    1044916            {
    1045                 signElements(signArray);
    1046             }
    1047             showsecuredSoap();
    1048         }
    1049 
    1050         public void encElements(XmlElement[] elements)
    1051         {
    1052             if (gotKey)
    1053             {
    1054                 bool content = encset.content;
    1055                 XmlNode secHeader = this.securedSOAP.GetElementsByTagName("wsse:Security")[0];
    1056                 if (secHeader == null)
    1057                 {
    1058                     hadHeader = false;
    1059                     XmlNode head = this.securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
    1060 
    1061                     string wssenamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
    1062 
    1063                     secHeader = this.securedSOAP.CreateElement("wsse", "Security", wssenamespace);
    1064 
    1065                     head.AppendChild(secHeader);
    1066                     XmlNode env = this.securedSOAP.GetElementsByTagName("s:Envelope")[0];
    1067                     XmlNode soapbody = this.securedSOAP.GetElementsByTagName("s:Body")[0];
    1068                     env.InsertBefore(head, soapbody);
     917                this.SignElements(signArray);
     918            }
     919            this.ShowSecuredSoap();
     920        }
     921
     922        public void EncryptElements(XmlElement[] elements)
     923        {
     924            if (this._gotKey)
     925            {
     926                bool content = this._encryptionSettings.content;
     927                XmlNode securityHeader = this._securedSOAP.GetElementsByTagName("wsse:Security")[0];
     928                if (securityHeader == null)
     929                {
     930                    this._hadHeader = false;
     931                    XmlNode header = this._securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
     932                    string wsseNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
     933                    securityHeader = this._securedSOAP.CreateElement("wsse", "Security", wsseNamespace);
     934                    header.AppendChild(securityHeader);
     935                    XmlNode envelope = this._securedSOAP.GetElementsByTagName("s:Envelope")[0];
     936                    XmlNode soapBody = this._securedSOAP.GetElementsByTagName("s:Body")[0];
     937                    envelope.InsertBefore(header, soapBody);
    1069938                }
    1070939                else
    1071940                {
    1072                     hadHeader = true;
     941                    this._hadHeader = true;
    1073942                }
    1074943                RijndaelManaged sessionKey = new RijndaelManaged();
    1075944                sessionKey.KeySize = 256;
    1076 
    1077 
    1078                 EncryptedXml encXML = new EncryptedXml();
    1079 
    1080                 EncryptedKey ek = new EncryptedKey();
    1081 
    1082                 byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, wsRSACryptoProv, false);
    1083                 ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
    1084                 ek.CipherData = new CipherData(encryptedKey);
    1085                 //ek.KeyInfo = new KeyInfo();
    1086 
    1087                 KeyInfoName name = new KeyInfoName();
    1088                 name.Value = "Web Service Public Key";
    1089                 ek.KeyInfo.AddClause(name);
    1090 
     945                EncryptedXml encryptedXML = new EncryptedXml();
     946                EncryptedKey encryptedKey = new EncryptedKey();
     947                byte[] encryptedEncryptionKey = EncryptedXml.EncryptKey(sessionKey.Key, this._wsRSACryptoProv, false);
     948                encryptedKey.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
     949                encryptedKey.CipherData = new CipherData(encryptedEncryptionKey);
     950                KeyInfoName keyName = new KeyInfoName();
     951                keyName.Value = "Web Service Public Key";
     952                encryptedKey.KeyInfo.AddClause(keyName);
    1091953                foreach (XmlElement elem in elements)
    1092954                {
     
    1098960                            if (content == false)
    1099961                            {
    1100                                 createErrorMessage("Only the content of the  "+elem.Name+" element can be encrypted");
     962                                CreateErrorMessage("Only the content of the  " + elem.Name + " element can be encrypted");
    1101963                            }
    1102964                            content = true;
    1103965                        }
    1104                         lastSessionKey = Convert.ToBase64String(sessionKey.Key);
    1105                         byte[] encryptedElement = encXML.EncryptData(elem, sessionKey, content);
     966                        this._lastSessionKey = Convert.ToBase64String(sessionKey.Key);
     967                        byte[] encryptedElement = encryptedXML.EncryptData(elem, sessionKey, content);
    1106968                        EncryptedData encElement = new EncryptedData();
    1107                         DataReference ekRef = new DataReference();
     969                        DataReference encryptedDataReference = new DataReference();
    1108970                        if (!content)
    1109971                        {
    1110972                            encElement.Type = EncryptedXml.XmlEncElementUrl;
    1111                             encElement.Id = idTable[elem.Name].ToString();
    1112                             ekRef.Uri = "#" + idTable[elem.Name].ToString();
     973                            encElement.Id = this._idTable[elem.Name].ToString();
     974                            encryptedDataReference.Uri = "#" + this._idTable[elem.Name].ToString();
    1113975                        }
    1114976                        else
    1115977                        {
    1116978                            encElement.Type = EncryptedXml.XmlEncElementContentUrl;
    1117                             addIdToElement(contentCounter+elem.Name);
    1118                             encElement.Id = idTable[contentCounter+elem.Name].ToString();
    1119                             ekRef.Uri = "#" + idTable[contentCounter+elem.Name].ToString();
    1120                             contentCounter++;
    1121                             mySettings.contentcounter = contentCounter;
    1122                         }
    1123                        
     979                            AddIdToElement(this._contentCounter + elem.Name);
     980                            encElement.Id = _idTable[this._contentCounter + elem.Name].ToString();
     981                            encryptedDataReference.Uri = "#" + this._idTable[_contentCounter + elem.Name].ToString();
     982                            this._contentCounter++;
     983                            mySettings.contentcounter = this._contentCounter;
     984                        }
     985
    1124986                        encElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
    1125987                        encElement.CipherData.CipherValue = encryptedElement;
    1126                        
    1127                        
    1128                         ek.AddReference(ekRef);
    1129                         string s = securedSOAP.GetElementsByTagName(elem.Name)[0].ParentNode.Name;
     988                        encryptedKey.AddReference(encryptedDataReference);
     989                        string s = this._securedSOAP.GetElementsByTagName(elem.Name)[0].ParentNode.Name;
    1130990
    1131991                        if (!content)
    1132992                        {
    1133                             securedSOAP.GetElementsByTagName(s)[0].ReplaceChild(securedSOAP.ImportNode(encElement.GetXml(), true), securedSOAP.GetElementsByTagName(elem.Name)[0]);
     993                            this._securedSOAP.GetElementsByTagName(s)[0].ReplaceChild(this._securedSOAP.ImportNode(encElement.GetXml(), true), this._securedSOAP.GetElementsByTagName(elem.Name)[0]);
    1134994                        }
    1135995                        else
    1136996                        {
    1137                             securedSOAP.GetElementsByTagName(elem.Name)[0].RemoveAll();
    1138                             securedSOAP.GetElementsByTagName(elem.Name)[0].AppendChild(securedSOAP.ImportNode(encElement.GetXml(), true));
     997                            this._securedSOAP.GetElementsByTagName(elem.Name)[0].RemoveAll();
     998                            this._securedSOAP.GetElementsByTagName(elem.Name)[0].AppendChild(this._securedSOAP.ImportNode(encElement.GetXml(), true));
    1139999                        }
    11401000                        if (elem.Name.Equals("s:Body"))
    11411001                        {
    1142                             bodyEncrypted = true;
     1002                            this._bodyEncrypted = true;
    11431003                            mySettings.bodyencrypted = true;
    11441004                        }
    1145                         if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
    1146                         {
    1147                             methodNameEncrypted = true;
    1148                             mySettings.methodnameencrypted = methodNameEncrypted;
     1005                        if (elem.Name.Equals(_soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
     1006                        {
     1007                            this._methodNameEncrypted = true;
     1008                            mySettings.methodnameencrypted = this._methodNameEncrypted;
    11491009                        }
    11501010                        if (elem.Name.Equals("wsse:Security"))
    11511011                        {
    1152                             secHeaderEnc = true;
     1012                            this._secHeaderEnc = true;
    11531013                            mySettings.secheaderEnc = true;
    11541014                        }
     
    11561016
    11571017                }
    1158                 secHeader.InsertBefore(securedSOAP.ImportNode(ek.GetXml(), true), secHeader.ChildNodes[0]);
    1159                 prefixesToEncryptedElement();
    1160        
    1161                 mySettings.securedsoap = xmlToString(securedSOAP);
     1018                securityHeader.InsertBefore(this._securedSOAP.ImportNode(encryptedKey.GetXml(), true), securityHeader.ChildNodes[0]);
     1019                this.PrefixesToEncryptedElement();
     1020                mySettings.securedsoap = CopyXmlToString(_securedSOAP);
    11621021            }
    11631022            else
    11641023            {
    1165                 createErrorMessage("No key for encryption available");
    1166             }
    1167         }
    1168 
    1169         private void prefixesToEncryptedElement()
    1170         {
    1171             XmlNodeList encKeyElems = securedSOAP.GetElementsByTagName("EncryptedKey");
    1172             foreach (XmlNode child in encKeyElems)
    1173             {
    1174                 addPrefixesToNodeAndChildNode("xenc", child);
    1175             }
    1176             XmlNodeList encDataElemns = securedSOAP.GetElementsByTagName("EncryptedData");
    1177             foreach(XmlNode child in encDataElemns)
    1178             {
    1179                 addPrefixesToNodeAndChildNode("xenc", child);
    1180             }
    1181         }
    1182 
    1183         private void addPrefixesToNodeAndChildNode(string prefix ,XmlNode node)
    1184         {
    1185             if(node.Name.Equals("KeyInfo"))
    1186         {
    1187             node.Prefix = "ds";
    1188             prefix = "ds";
    1189         }
     1024                CreateErrorMessage("No key for encryption available");
     1025            }
     1026        }
     1027
     1028        private void PrefixesToEncryptedElement()
     1029        {
     1030            XmlNodeList encryptedKeys = _securedSOAP.GetElementsByTagName("EncryptedKey");
     1031            foreach (XmlNode encryptedKey in encryptedKeys)
     1032            {
     1033                AddPrefixesToNodeAndChildNode("xenc", encryptedKey);
     1034            }
     1035            XmlNodeList encryptedDataElements = this._securedSOAP.GetElementsByTagName("EncryptedData");
     1036            foreach (XmlNode encryptedDataElement in encryptedDataElements)
     1037            {
     1038                AddPrefixesToNodeAndChildNode("xenc", encryptedDataElement);
     1039            }
     1040        }
     1041
     1042        private void AddPrefixesToNodeAndChildNode(string prefix, XmlNode node)
     1043        {
     1044            if (node.Name.Equals("KeyInfo"))
     1045            {
     1046                node.Prefix = "ds";
     1047                prefix = "ds";
     1048            }
    11901049            else
    1191         {
    1192             node.Prefix = prefix;
    1193         }
     1050            {
     1051                node.Prefix = prefix;
     1052            }
    11941053            foreach (XmlNode child in node.ChildNodes)
    11951054            {
    1196                 addPrefixesToNodeAndChildNode(prefix, child);
    1197             }
    1198         }
    1199 
    1200         public void decrypt()
    1201         {
    1202             XmlElement securityHeader = (XmlElement)securedSOAP.GetElementsByTagName("Security")[0];
    1203             XmlElement encKeyXml = (XmlElement) securedSOAP.GetElementsByTagName("EncryptedKey")[0];
    1204             XmlElement encData = (XmlElement)securedSOAP.GetElementsByTagName("EncryptedData")[0];
    1205             XmlElement KeyInfo = securedSOAP.CreateElement("KeyInfo",SignedXml.XmlDsigNamespaceUrl);
    1206 
    1207             securityHeader.RemoveChild(encKeyXml);
    1208             KeyInfo.AppendChild(encKeyXml);
    1209 
    1210             encData.InsertAfter(KeyInfo, encData.GetElementsByTagName("EncryptionMethod")[0]);
    1211             this.showsecuredSoap();
    1212             EncryptedXml encXml = new EncryptedXml(this.securedSOAP);
    1213             encXml.AddKeyNameMapping("RSA-Key", rsaKey);
     1055                this.AddPrefixesToNodeAndChildNode(prefix, child);
     1056            }
     1057        }
     1058
     1059        public void DecryptDocument()
     1060        {
     1061            XmlElement securityHeader = (XmlElement)this._securedSOAP.GetElementsByTagName("Security")[0];
     1062            XmlElement encryptedKey = (XmlElement)this._securedSOAP.GetElementsByTagName("EncryptedKey")[0];
     1063            XmlElement encryptedData = (XmlElement)this._securedSOAP.GetElementsByTagName("EncryptedData")[0];
     1064            XmlElement keyInfo = this._securedSOAP.CreateElement("KeyInfo", SignedXml.XmlDsigNamespaceUrl);
     1065            securityHeader.RemoveChild(encryptedKey);
     1066            keyInfo.AppendChild(encryptedKey);
     1067            encryptedData.InsertAfter(keyInfo, encryptedData.GetElementsByTagName("EncryptionMethod")[0]);
     1068            this.ShowSecuredSoap();
     1069            EncryptedXml encXml = new EncryptedXml(this._securedSOAP);
     1070            encXml.AddKeyNameMapping("RSA-Key", this._rsaKey);
    12141071            encXml.DecryptDocument();
    12151072        }
    1216        
    1217         public void signElements(XmlElement[] elements)
    1218         {
    1219                 String sigAlgo = sigset.sigAlg;
    1220                 XmlNode secHeader = securedSOAP.GetElementsByTagName("Security")[0];
    1221                 if (secHeader == null)
    1222                 {
    1223                     XmlNode head = securedSOAP.CreateElement("s","Header", "http://www.w3.org/2003/05/soap-envelope");
    1224 
    1225                     string wssenamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
    1226 
    1227                     secHeader = securedSOAP.CreateElement("Security", wssenamespace);
    1228 
    1229                     head.AppendChild(secHeader);
    1230                     XmlNode env = securedSOAP.GetElementsByTagName("Envelope")[0];
    1231                     XmlNode soapbody = securedSOAP.GetElementsByTagName("Body")[0];
    1232                     env.InsertBefore(head, soapbody);
    1233                 }
    1234                 SignedXml signedXML = new SignedXml(this.securedSOAP);
    1235                 foreach (XmlElement elem in elements)
    1236                 {
    1237                     XmlAttribute idAttribute = securedSOAP.CreateAttribute("Id");
    1238                     idAttribute.Value = idTable[elem.Name].ToString();
    1239                     elem.Attributes.Append(idAttribute);
    1240                     XmlAttributeCollection attributes = elem.Attributes;
    1241                     XmlAttribute id = attributes["Id"];
    1242                     Reference reference = new Reference("#" + id.Value);
    1243                     //   Reference reference = new Reference("");
    1244                     XmlElement xpathElement = securedSOAP.CreateElement("XPath");
    1245                     string Xpath = "ancestor-or-self::Body";
    1246                     XmlElement root = this.securedSOAP.DocumentElement;
    1247                     XmlElement b = (XmlElement)securedSOAP.GetElementsByTagName("Body")[0];
    1248                     XmlNamespaceManager manager = new XmlNamespaceManager(securedSOAP.NameTable);
    1249 
    1250                     manager.AddNamespace("s", b.NamespaceURI);
    1251                     xpathElement.InnerText = Xpath;
    1252                     XmlDsigXPathTransform xpathTrans = new XmlDsigXPathTransform();
    1253                     XmlNodeList list = root.SelectNodes("/s:Envelope/s:Body", manager);
    1254                     XmlNodeList list2 = root.SelectNodes("//. | //@* | //namespace::*");
    1255                     xpathTrans.LoadInnerXml(xpathElement.SelectNodes("."));
    1256                     XmlDsigExcC14NTransform trans = new XmlDsigExcC14NTransform();
    1257                     reference.AddTransform(trans);
    1258                     XmlElement boo = xpathTrans.GetXml();
    1259                     Type xmlDocumentType = typeof(System.Xml.XmlDocument);
    1260 
    1261                     signedXML.AddReference(reference);
    1262                     if (elem.Name.Equals("s:Body"))
    1263                     {
    1264                         bodySigned = true;
    1265                         mySettings.bodysigned = true;
    1266                     }
    1267                     if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
    1268                     {
    1269                         methodNameSigned = true;
    1270                         mySettings.methodnameSigned = true;
    1271                     }
    1272 
    1273                 }
    1274                 if (sigAlgo.Equals("1"))
    1275                 {
    1276                     CspParameters parameter = new CspParameters();
    1277 
    1278                     parameter.KeyContainerName = "Container";
    1279                     RSACryptoServiceProvider provider = new RSACryptoServiceProvider(parameter);
    1280                     signedXML.SigningKey = provider;
    1281                     signedXML.ComputeSignature();
    1282 
    1283                     KeyInfo keyInfo = new KeyInfo();
    1284                     keyInfo.AddClause(new RSAKeyValue(provider));
    1285                     signedXML.KeyInfo = keyInfo;
    1286                     Reference t = (Reference)signedXML.SignedInfo.References[0];
    1287                     IEnumerator enumerator = t.TransformChain.GetEnumerator();
    1288                     enumerator.MoveNext();
    1289                     XmlElement root = (XmlElement)this.securedSOAP.GetElementsByTagName("Envelope")[0];
    1290                     Transform tran = (Transform)enumerator.Current;
    1291                     XmlNodeList list2 = root.SelectNodes("//. | //@* | //namespace::*");
    1292 
    1293                 }
    1294                 if (sigAlgo.Equals("0"))
    1295                 {
    1296                     DSA dsa = DSA.Create();
    1297                     dsa.ToXmlString(false);
    1298                     signedXML.SigningKey = dsa;
    1299                     signedXML.ComputeSignature();
    1300                 }
    1301 
    1302                 XmlElement signaturElement = signedXML.GetXml();
    1303                 secHeader.InsertBefore(securedSOAP.ImportNode(signaturElement, true),secHeader.ChildNodes[0]);
    1304            
    1305         }
    1306 
    1307         public bool checkSecurityHeader()
     1073
     1074        public void SignElements(XmlElement[] elements)
     1075        {
     1076            String sigAlgo = this._signatureSettings.sigAlg;
     1077            XmlNode securityHeader = this._securedSOAP.GetElementsByTagName("Security")[0];
     1078            if (securityHeader == null)
     1079            {
     1080                XmlNode header = this._securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2003/05/soap-envelope");
     1081                string wsseNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
     1082                securityHeader = this._securedSOAP.CreateElement("Security", wsseNamespace);
     1083                header.AppendChild(securityHeader);
     1084                XmlNode envelope = this._securedSOAP.GetElementsByTagName("Envelope")[0];
     1085                XmlNode soapBody = this._securedSOAP.GetElementsByTagName("Body")[0];
     1086                envelope.InsertBefore(header, soapBody);
     1087            }
     1088            SignedXml signedXML = new SignedXml(this._securedSOAP);
     1089            foreach (XmlElement elementToSign in elements)
     1090            {
     1091                XmlAttribute idAttribute = this._securedSOAP.CreateAttribute("Id");
     1092                idAttribute.Value = this._idTable[elementToSign.Name].ToString();
     1093                elementToSign.Attributes.Append(idAttribute);
     1094                XmlAttributeCollection attributes = elementToSign.Attributes;
     1095                XmlAttribute id = attributes["Id"];
     1096                Reference reference = new Reference("#" + id.Value);
     1097                //   Reference reference = new Reference("");
     1098                XmlElement xpathElement = _securedSOAP.CreateElement("XPath");
     1099                string Xpath = "ancestor-or-self::Body";
     1100                XmlElement root = this._securedSOAP.DocumentElement;
     1101                XmlElement body = (XmlElement)this._securedSOAP.GetElementsByTagName("Body")[0];
     1102                XmlNamespaceManager namespaceManager = new XmlNamespaceManager(this._securedSOAP.NameTable);
     1103                namespaceManager.AddNamespace("s", body.NamespaceURI);
     1104                xpathElement.InnerText = Xpath;
     1105                XmlDsigXPathTransform xpathTrans = new XmlDsigXPathTransform();
     1106                xpathTrans.LoadInnerXml(xpathElement.SelectNodes("."));
     1107                XmlDsigExcC14NTransform transform = new XmlDsigExcC14NTransform();
     1108                reference.AddTransform(transform);
     1109                signedXML.AddReference(reference);
     1110                if (elementToSign.Name.Equals("s:Body"))
     1111                {
     1112                    this._bodySigned = true;
     1113                    mySettings.bodysigned = true;
     1114                }
     1115                if (elementToSign.Name.Equals(this._soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
     1116                {
     1117                    this._methodNameSigned = true;
     1118                    mySettings.methodnameSigned = true;
     1119                }
     1120
     1121            }
     1122            if (sigAlgo.Equals("1"))
     1123            {
     1124                CspParameters parameter = new CspParameters();
     1125                parameter.KeyContainerName = "Container";
     1126                RSACryptoServiceProvider provider = new RSACryptoServiceProvider(parameter);
     1127                signedXML.SigningKey = provider;
     1128                signedXML.ComputeSignature();
     1129                KeyInfo keyInfo = new KeyInfo();
     1130                keyInfo.AddClause(new RSAKeyValue(provider));
     1131                signedXML.KeyInfo = keyInfo;
     1132                Reference reference = (Reference)signedXML.SignedInfo.References[0];
     1133                IEnumerator enumerator = reference.TransformChain.GetEnumerator();
     1134                enumerator.MoveNext();
     1135                XmlElement envelope = (XmlElement)this._securedSOAP.GetElementsByTagName("Envelope")[0];
     1136                Transform tran = (Transform)enumerator.Current;
     1137                XmlNodeList list2 = envelope.SelectNodes("//. | //@* | //namespace::*");
     1138
     1139            }
     1140            if (sigAlgo.Equals("0"))
     1141            {
     1142                DSA dsa = DSA.Create();
     1143                dsa.ToXmlString(false);
     1144                signedXML.SigningKey = dsa;
     1145                signedXML.ComputeSignature();
     1146            }
     1147
     1148            XmlElement signaturElement = signedXML.GetXml();
     1149            securityHeader.InsertBefore(this._securedSOAP.ImportNode(signaturElement, true), securityHeader.ChildNodes[0]);
     1150
     1151        }
     1152
     1153        public bool CheckSecurityHeader()
    13081154        {
    13091155            bool securityheader = false;
    1310             XmlNodeList list = securedSOAP.GetElementsByTagName("wsse:Security");
    1311             if (!(list.Count == 0))
     1156            XmlNodeList securityElements = this._securedSOAP.GetElementsByTagName("wsse:Security");
     1157            if (!(securityElements.Count == 0))
    13121158            {
    13131159                securityheader = true;
     
    13161162        }
    13171163
    1318         public void createSecurityHeaderAndSoapHeader()
    1319         {
    1320             if (!checkSecurityHeader())
    1321             {
    1322                 XmlElement env= (XmlElement) securedSOAP.GetElementsByTagName("s:Envelope")[0];
    1323                 XmlElement Header = securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
    1324                 XmlElement secHead = securedSOAP.CreateElement("wsse", "Security", "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd");
    1325                 env.InsertBefore(Header,env.FirstChild);
    1326                 Header.AppendChild(secHead);
    1327                 mySettings.securedsoap = xmlToString(securedSOAP);
    1328             }
    1329         }
    1330 
    1331         private string getXPathValue(XmlElement elem)
     1164        public void CreateSecurityHeaderAndSoapHeader()
     1165        {
     1166            if (!CheckSecurityHeader())
     1167            {
     1168                XmlElement envelope = (XmlElement)this._securedSOAP.GetElementsByTagName("s:Envelope")[0];
     1169                XmlElement header = this._securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
     1170                XmlElement securityHeader = this._securedSOAP.CreateElement("wsse", "Security", "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd");
     1171                envelope.InsertBefore(header, envelope.FirstChild);
     1172                header.AppendChild(securityHeader);
     1173                mySettings.securedsoap = CopyXmlToString(_securedSOAP);
     1174            }
     1175        }
     1176
     1177        private string GetXPathValue(XmlElement element)
    13321178        {
    13331179            string xPathValue = "/s:Envelope";
    1334             if (elem.Name.Equals("wsse:Security"))
     1180            if (element.Name.Equals("wsse:Security"))
    13351181            {
    13361182                xPathValue = xPathValue + "/wsse:Security";
     
    13381184            }
    13391185            xPathValue = xPathValue + "/s:Body";
    1340             if (elem.Name.Equals("s:Body"))
     1186            if (element.Name.Equals("s:Body"))
    13411187            {
    13421188                return xPathValue;
    13431189            }
    1344             xPathValue = xPathValue + "/" + securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name;
    1345             if (elem.Name.Equals(securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name))
     1190            xPathValue = xPathValue + "/" + this._securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name;
     1191            if (element.Name.Equals(this._securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name))
    13461192            {
    13471193                return xPathValue;
    13481194            }
    1349             xPathValue = xPathValue + "/"+elem.Name;
     1195            xPathValue = xPathValue + "/" + element.Name;
    13501196            return xPathValue;
    13511197        }
    13521198
    1353         public void createErrorMessage(string text)
     1199        public void CreateErrorMessage(string text)
    13541200        {
    13551201            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Error));
    13561202        }
    13571203
    1358         public void createInfoMessage(string text)
     1204        public void CreateInfoMessage(string text)
    13591205        {
    13601206            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Info));
    13611207        }
    13621208
    1363         public void signElementsManual(XmlElement[] elementsToSign)
    1364         {
    1365            
    1366                 string dsNs = "http://www.w3.org/2000/09/xmldsig#";
    1367                 XmlElement Signature = securedSOAP.CreateElement("ds", "Signature", dsNs);
    1368                 XmlElement SignedInfo = securedSOAP.CreateElement("ds", "SignedInfo", dsNs);
    1369                 XmlElement CanonicalizationMethod = securedSOAP.CreateElement("ds", "CanonicalizationMethod", dsNs);
    1370                 XmlAttribute canMeth = securedSOAP.CreateAttribute("Algorithm");
    1371                 canMeth.Value = SignedXml.XmlDsigExcC14NTransformUrl;
    1372                 CanonicalizationMethod.Attributes.Append(canMeth);
    1373                 XmlElement SignatureMethod = securedSOAP.CreateElement("ds", "SignatureMethod", dsNs);
    1374                 XmlAttribute sigMeth = securedSOAP.CreateAttribute("Algorithm");
    1375 
    1376                 if (sigset.sigAlg.Equals("0"))
    1377                 {
    1378                     sigMeth.Value = SignedXml.XmlDsigDSAUrl;
    1379                 }
    1380                 if (sigset.sigAlg.Equals("1"))
    1381                 {
    1382                     sigMeth.Value = SignedXml.XmlDsigRSASHA1Url;
    1383                 }
    1384 
    1385                 SignatureMethod.Attributes.Append(sigMeth);
    1386                 XmlNode securityHead = securedSOAP.GetElementsByTagName("wsse:Security")[0];
    1387                 securityHead.InsertBefore(Signature,securityHead.FirstChild);
    1388                 Signature.AppendChild(SignedInfo);
    1389                 SignedInfo.AppendChild(CanonicalizationMethod);
    1390                 SignedInfo.AppendChild(SignatureMethod);
    1391 
    1392                 foreach (XmlElement tempElem in elementsToSign)
    1393                 {
    1394                     addIdToElement(tempElem.Name);
    1395                     XmlAttribute idAttribute = securedSOAP.CreateAttribute("Id");
    1396                     idAttribute.Value = idTable[tempElem.Name].ToString();
    1397                     tempElem.Attributes.Append(idAttribute);
    1398                     XmlElement ReferenceElement = securedSOAP.CreateElement("ds", "Reference", dsNs);
    1399                     XmlAttribute uri = securedSOAP.CreateAttribute("URI");
    1400                     XmlElement Transforms = securedSOAP.CreateElement("ds", "Transforms", dsNs);
    1401                     ReferenceElement.AppendChild(Transforms);
    1402 
    1403                     if (sigset.Xpath)
    1404                     {
    1405                         uri.Value = "";
    1406                         XmlElement xPathTransform = securedSOAP.CreateElement("ds", "Transform", dsNs);
    1407                         XmlAttribute xPathTransAtt = securedSOAP.CreateAttribute("Algorithm");
    1408                         xPathTransAtt.Value = SignedXml.XmlDsigXPathTransformUrl;
    1409                         xPathTransform.Attributes.Append(xPathTransAtt);
    1410                         XmlElement xPathValue = securedSOAP.CreateElement("ds", "XPath", dsNs);
    1411                         xPathValue.InnerXml = getXPathValue(tempElem);
    1412                         xPathTransform.AppendChild(xPathValue);
    1413                         Transforms.AppendChild(xPathTransform);
    1414                     }
    1415                     else
    1416                     {
    1417                         uri.Value = "#" + idTable[tempElem.Name].ToString();
    1418                     }
    1419                     ReferenceElement.Attributes.Append(uri);
    1420 
    1421                     XmlElement c14nTransform = securedSOAP.CreateElement("ds", "Transform", dsNs);
    1422                     XmlAttribute c14Url = securedSOAP.CreateAttribute("Algorithm");
    1423                     c14Url.Value = SignedXml.XmlDsigExcC14NTransformUrl;
    1424                     c14nTransform.Attributes.Append(c14Url);
    1425                     Transforms.AppendChild(c14nTransform);
    1426                     XmlElement digestMethod = securedSOAP.CreateElement("ds", "DigestMethod", dsNs);
    1427                     XmlAttribute digMethAtt = securedSOAP.CreateAttribute("Algorithm");
    1428                     digMethAtt.Value = SignedXml.XmlDsigSHA1Url;
    1429                     digestMethod.Attributes.Append(digMethAtt);
    1430                     ReferenceElement.AppendChild(digestMethod);
    1431                     XmlElement digestValue = securedSOAP.CreateElement("ds", "DigestValue", dsNs);
    1432                     digestValue.InnerText = Convert.ToBase64String(getDigestValueForElement(tempElem));
    1433                     ReferenceElement.AppendChild(digestValue);
    1434                     SignedInfo.AppendChild(ReferenceElement);
    1435                     if (tempElem.Name.Equals("s:Body"))
    1436                     {
    1437                         bodySigned = true;
    1438                         mySettings.bodysigned = true;
    1439                     }
    1440                     if (tempElem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
    1441                     {
    1442                         methodNameSigned = true;
    1443                         mySettings.methodnameSigned = true;
    1444                     }
    1445                     if (tempElem.Name.Equals("wsse:Security"))
    1446                     {
    1447                         secHeaderSigned = true;
    1448                         mySettings.secheaderSigned = true;
    1449                     }
    1450 
    1451                 }
    1452                 XmlElement SignatureValue = securedSOAP.CreateElement("ds", "SignatureValue", dsNs);
    1453                 KeyInfo keyInfo = new KeyInfo();
    1454                 if (sigset.sigAlg.Equals("1"))
    1455                 {
    1456                     SignatureValue.InnerXml = Convert.ToBase64String(rsaCryptoProv.SignHash(getDigestValueForElement(SignedInfo), CryptoConfig.MapNameToOID("SHA1")));
    1457                     keyInfo.AddClause(new RSAKeyValue(rsaCryptoProv));
    1458                    
    1459                 }
    1460                 if (sigset.sigAlg.Equals("0"))
    1461                 {
    1462                     SignatureValue.InnerXml = Convert.ToBase64String(dsaCryptoProv.SignHash(getDigestValueForElement(SignedInfo), CryptoConfig.MapNameToOID("SHA1")));
    1463                     keyInfo.AddClause(new DSAKeyValue(dsaCryptoProv));
    1464                 }
    1465                 Signature.AppendChild(SignatureValue);
    1466                 XmlElement xmlKeyInfo = keyInfo.GetXml();
    1467                 xmlKeyInfo.Prefix = "ds";
    1468                 foreach(XmlNode childNode in xmlKeyInfo.ChildNodes)
    1469                 {
    1470                     childNode.Prefix = "ds";
    1471                 }
    1472                 Signature.AppendChild(securedSOAP.ImportNode(xmlKeyInfo, true));
    1473                 XmlElement secHead = (XmlElement)securedSOAP.GetElementsByTagName("wsse:Security")[0];
    1474                 mySettings.securedsoap = xmlToString(securedSOAP);
    1475         }
    1476 
    1477         public string getIdToElement(string ElemName)
    1478         {
    1479             string retString = idTable[ElemName].ToString();
    1480             return retString;
    1481         }
    1482 
    1483         public bool getxPathTrans()
    1484         {
    1485             return sigset.Xpath;
    1486         }
    1487 
    1488         public byte[] getDigestValueForElement(XmlElement elem)
    1489         {
    1490             Stream canonicalized = canonicalizeNodeWithExcC14n(elem);
     1209        public void SignElementsManual(XmlElement[] elementsToSign)
     1210        {
     1211
     1212            string dsNamespace = "http://www.w3.org/2000/09/xmldsig#";
     1213            XmlElement signature = this._securedSOAP.CreateElement("ds", "Signature", dsNamespace);
     1214            XmlElement signedInfo = this._securedSOAP.CreateElement("ds", "SignedInfo", dsNamespace);
     1215            XmlElement canonicalizationMethod = _securedSOAP.CreateElement("ds", "CanonicalizationMethod", dsNamespace);
     1216            XmlAttribute canMeth = this._securedSOAP.CreateAttribute("Algorithm");
     1217            canMeth.Value = SignedXml.XmlDsigExcC14NTransformUrl;
     1218            canonicalizationMethod.Attributes.Append(canMeth);
     1219            XmlElement signatureMethod = this._securedSOAP.CreateElement("ds", "SignatureMethod", dsNamespace);
     1220            XmlAttribute sigMeth = this._securedSOAP.CreateAttribute("Algorithm");
     1221
     1222            if (this._signatureSettings.sigAlg.Equals("0"))
     1223            {
     1224                sigMeth.Value = SignedXml.XmlDsigDSAUrl;
     1225            }
     1226            if (this._signatureSettings.sigAlg.Equals("1"))
     1227            {
     1228                sigMeth.Value = SignedXml.XmlDsigRSASHA1Url;
     1229            }
     1230
     1231            signatureMethod.Attributes.Append(sigMeth);
     1232            XmlNode securityHeader = this._securedSOAP.GetElementsByTagName("wsse:Security")[0];
     1233            securityHeader.InsertBefore(signature, securityHeader.FirstChild);
     1234            signature.AppendChild(signedInfo);
     1235            signedInfo.AppendChild(canonicalizationMethod);
     1236            signedInfo.AppendChild(signatureMethod);
     1237
     1238            foreach (XmlElement elementToSign in elementsToSign)
     1239            {
     1240                this.AddIdToElement(elementToSign.Name);
     1241                XmlAttribute idAttribute = this._securedSOAP.CreateAttribute("Id");
     1242                idAttribute.Value = this._idTable[elementToSign.Name].ToString();
     1243                elementToSign.Attributes.Append(idAttribute);
     1244                XmlElement referenceElement = this._securedSOAP.CreateElement("ds", "Reference", dsNamespace);
     1245                XmlAttribute uri = this._securedSOAP.CreateAttribute("URI");
     1246                XmlElement transforms = _securedSOAP.CreateElement("ds", "Transforms", dsNamespace);
     1247                referenceElement.AppendChild(transforms);
     1248
     1249                if (this._signatureSettings.Xpath)
     1250                {
     1251                    uri.Value = "";
     1252                    XmlElement xPathTransform = this._securedSOAP.CreateElement("ds", "Transform", dsNamespace);
     1253                    XmlAttribute xPathTransAtt = this._securedSOAP.CreateAttribute("Algorithm");
     1254                    xPathTransAtt.Value = SignedXml.XmlDsigXPathTransformUrl;
     1255                    xPathTransform.Attributes.Append(xPathTransAtt);
     1256                    XmlElement xPathValue = this._securedSOAP.CreateElement("ds", "XPath", dsNamespace);
     1257                    xPathValue.InnerXml = this.GetXPathValue(elementToSign);
     1258                    xPathTransform.AppendChild(xPathValue);
     1259                    transforms.AppendChild(xPathTransform);
     1260                }
     1261                else
     1262                {
     1263                    uri.Value = "#" + this._idTable[elementToSign.Name].ToString();
     1264                }
     1265                referenceElement.Attributes.Append(uri);
     1266                XmlElement c14nTransform = this._securedSOAP.CreateElement("ds", "Transform", dsNamespace);
     1267                XmlAttribute c14Url = this._securedSOAP.CreateAttribute("Algorithm");
     1268                c14Url.Value = SignedXml.XmlDsigExcC14NTransformUrl;
     1269                c14nTransform.Attributes.Append(c14Url);
     1270                transforms.AppendChild(c14nTransform);
     1271                XmlElement digestMethod = this._securedSOAP.CreateElement("ds", "DigestMethod", dsNamespace);
     1272                XmlAttribute digMethodAttribute = this._securedSOAP.CreateAttribute("Algorithm");
     1273                digMethodAttribute.Value = SignedXml.XmlDsigSHA1Url;
     1274                digestMethod.Attributes.Append(digMethodAttribute);
     1275                referenceElement.AppendChild(digestMethod);
     1276                XmlElement digestValue = this._securedSOAP.CreateElement("ds", "DigestValue", dsNamespace);
     1277                digestValue.InnerText = Convert.ToBase64String(this.GetDigestValueForElementWithSha1(elementToSign));
     1278                referenceElement.AppendChild(digestValue);
     1279                signedInfo.AppendChild(referenceElement);
     1280                if (elementToSign.Name.Equals("s:Body"))
     1281                {
     1282                    this._bodySigned = true;
     1283                    mySettings.bodysigned = true;
     1284                }
     1285                if (elementToSign.Name.Equals(this._soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
     1286                {
     1287                    this._methodNameSigned = true;
     1288                     mySettings.methodnameSigned = true;
     1289                }
     1290                if (elementToSign.Name.Equals("wsse:Security"))
     1291                {
     1292                    this._secHeaderSigned = true;
     1293                    mySettings.secheaderSigned = true;
     1294                }
     1295
     1296            }
     1297            XmlElement signatureValue = this._securedSOAP.CreateElement("ds", "SignatureValue", dsNamespace);
     1298            KeyInfo keyInfo = new KeyInfo();
     1299            if (this._signatureSettings.sigAlg.Equals("1"))
     1300            {
     1301                signatureValue.InnerXml = Convert.ToBase64String(this._rsaCryptoProv.SignHash(this.GetDigestValueForElementWithSha1(signedInfo), CryptoConfig.MapNameToOID("SHA1")));
     1302                keyInfo.AddClause(new RSAKeyValue(this._rsaCryptoProv));
     1303
     1304            }
     1305            if (this._signatureSettings.sigAlg.Equals("0"))
     1306            {
     1307                signatureValue.InnerXml = Convert.ToBase64String(this._dsaCryptoProv.SignHash(this.GetDigestValueForElementWithSha1(signedInfo), CryptoConfig.MapNameToOID("SHA1")));
     1308                keyInfo.AddClause(new DSAKeyValue(this._dsaCryptoProv));
     1309            }
     1310            signature.AppendChild(signatureValue);
     1311            XmlElement xmlKeyInfo = keyInfo.GetXml();
     1312            xmlKeyInfo.Prefix = "ds";
     1313            foreach (XmlNode childNode in xmlKeyInfo.ChildNodes)
     1314            {
     1315                childNode.Prefix = "ds";
     1316            }
     1317            signature.AppendChild(this._securedSOAP.ImportNode(xmlKeyInfo, true));
     1318            XmlElement secHead = (XmlElement)this._securedSOAP.GetElementsByTagName("wsse:Security")[0];
     1319            mySettings.securedsoap = this.CopyXmlToString(this._securedSOAP);
     1320        }
     1321
     1322        public string GetIdToElement(string elementName)
     1323        {
     1324            if (elementName != null && this._idTable.ContainsKey(elementName))
     1325            {
     1326                string id = this._idTable[elementName].ToString();
     1327                return id;
     1328            }
     1329            return null;
     1330        }
     1331
     1332        public bool GetXPathTransForm()
     1333        {
     1334            return this._signatureSettings.Xpath;
     1335        }
     1336
     1337        public byte[] GetDigestValueForElementWithSha1(XmlElement element)
     1338        {
     1339            Stream canonicalized = this.CanonicalizeNodeWithExcC14n(element);
    14911340            SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
    14921341            byte[] byteValue = sha1.ComputeHash(canonicalized);
     
    14941343        }
    14951344
    1496         public Stream canonicalizeNodeWithExcC14n(XmlElement nodeToCanon)
     1345        public Stream CanonicalizeNodeWithExcC14n(XmlElement nodeToCanon)
    14971346        {
    14981347            XmlNode node = (XmlNode)nodeToCanon;
    14991348            XmlNodeReader reader = new XmlNodeReader(node);
    1500             Stream stream = new MemoryStream();
    1501             XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
     1349            Stream inputStream = new MemoryStream();
     1350            XmlWriter writer = new XmlTextWriter(inputStream, Encoding.UTF8);
    15021351            writer.WriteNode(reader, false);
    15031352            writer.Flush();
    1504             stream.Position = 0;
    1505             XmlDsigExcC14NTransform trans = new XmlDsigExcC14NTransform();
    1506             trans.LoadInput(stream);
    1507             Stream stream2 = (Stream)trans.GetOutput();
    1508             return stream2;
    1509         }
    1510    
    1511         public void showsecuredSoap()
     1353            inputStream.Position = 0;
     1354            XmlDsigExcC14NTransform transformation = new XmlDsigExcC14NTransform();
     1355            transformation.LoadInput(inputStream);
     1356            Stream outputStream = (Stream)transformation.GetOutput();
     1357            return outputStream;
     1358        }
     1359
     1360        public void ShowSecuredSoap()
    15121361        {
    15131362            presentation.treeView.Items.Clear();
    15141363            presentation.namespacesTable.Clear();
    15151364            this.presentation.securedSoapItem = null;
    1516 
    15171365            this.presentation.securedSoapItem = new System.Windows.Controls.TreeViewItem();
    1518 
    15191366            presentation.securedSoapItem.IsExpanded = true;
    1520 
    15211367            StackPanel panel1 = new StackPanel();
    1522        
    1523 
    15241368            panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
    1525 
    15261369            TextBlock elem1 = new TextBlock();
    1527             elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"; 
     1370            elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
    15281371            panel1.Children.Insert(0, elem1);
    15291372            presentation.securedSoapItem.Header = panel1;
    1530             XmlNode rootElement = securedSOAP.SelectSingleNode("/*");
     1373            XmlNode rootElement = _securedSOAP.SelectSingleNode("/*");
    15311374            this.presentation.CopyXmlToTreeView(rootElement, ref presentation.securedSoapItem);
    15321375            this.presentation.treeView.Items.Add(presentation.securedSoapItem);
    15331376        }
    1534        
    1535         public XmlDocument soap2
    1536         {get{return this.soap;}
    1537            
    1538        }
    15391377
    15401378        public void OnPropertyChanged(string name)
     
    15431381        }
    15441382
    1545         public SoapSettings settings2()
    1546         {
    1547             return (SoapSettings) this.Settings;
    1548         }
    1549              
     1383        public Object XmlOutputConverter(Object Data)
     1384        {
     1385            string test = Data.ToString();
     1386
     1387            if (test.StartsWith("<"))
     1388            {
     1389                string test1 = Data.GetType().ToString();
     1390                test1 = test1 + " " + test;
     1391                XmlDocument doc = (XmlDocument)Data;
     1392                StringWriter t = new StringWriter();
     1393                Object obj = new Object();
     1394                try
     1395                {
     1396                    XmlTextWriter j = new XmlTextWriter(t);
     1397                    j.Formatting = Formatting.Indented;
     1398                    doc.WriteContentTo(j);
     1399                    obj = (Object)t.ToString();
     1400                }
     1401                catch (Exception e)
     1402                {
     1403                    Console.WriteLine(e.ToString());
     1404
     1405                }
     1406                return obj;
     1407            }
     1408            return null;
     1409
     1410        }
     1411
     1412        public Object XmlConverter(Object Data)
     1413        {
     1414            string test = Data.ToString();
     1415            if (test.StartsWith("<"))
     1416            {
     1417                XmlDocument doc = (XmlDocument)this._securedSOAP;
     1418                StringWriter t = new StringWriter();
     1419                Object obj = new Object();
     1420                try
     1421                {
     1422                    XmlTextWriter j = new XmlTextWriter(t);
     1423                    j.Formatting = Formatting.Indented;
     1424                    doc.WriteContentTo(j);
     1425                    obj = (Object)t.ToString();
     1426                }
     1427                catch (Exception e)
     1428                {
     1429                    Console.WriteLine(e.ToString());
     1430
     1431                }
     1432                return obj;
     1433            }
     1434            return null;
     1435        }
     1436
     1437        #endregion
     1438
    15501439        #region IPlugin Member
    15511440
    15521441        public void Dispose()
    15531442        {
    1554            
     1443
    15551444        }
    15561445
     
    15611450        public void Initialize()
    15621451        {
    1563            
     1452
    15641453        }
    15651454
     
    15721461        public void Pause()
    15731462        {
    1574            
     1463
    15751464        }
    15761465
    15771466        public void PostExecution()
    15781467        {
    1579            
     1468
    15801469        }
    15811470
    15821471        public void PreExecution()
    15831472        {
    1584            
     1473
    15851474        }
    15861475
     
    15971486        public ISettings Settings
    15981487        {
    1599             get { return (SoapSettings) this.settings; }
     1488            get { return (SoapSettings)this._settings; }
    16001489        }
    16011490
    16021491        public SoapSettings mySettings
    16031492        {
    1604             get { return (SoapSettings)this.settings; }
     1493            get { return (SoapSettings)this._settings; }
    16051494        }
    16061495
     
    16121501        #endregion
    16131502
     1503        #region EventHandlers
     1504
     1505        private void SettingsPropertyChangedEventHandler(object sender, System.ComponentModel.PropertyChangedEventArgs e)
     1506        {
     1507            SoapSettings settings = sender as SoapSettings;
     1508
     1509            switch (e.PropertyName)
     1510            {
     1511                case "SignatureAlg":
     1512                    this._signatureSettings.sigAlg = settings.SignatureAlg;
     1513                    break;
     1514
     1515                case "SigXPathRef":
     1516                    this._signatureSettings.Xpath = settings.SigXPathRef;
     1517                    break;
     1518
     1519                case "SigShowSteps":
     1520                    this._signatureSettings.showsteps = settings.SigShowSteps;
     1521                    break;
     1522                case "EncContentRadio":
     1523                    if (settings.EncContentRadio == 0)
     1524                    {
     1525                        this._encryptionSettings.content = false;
     1526                    }
     1527                    if (settings.EncContentRadio == 1)
     1528                    {
     1529                        this._encryptionSettings.content = true;
     1530                    }
     1531                    break;
     1532
     1533                case "EncShowSteps":
     1534                    this._encryptionSettings.showsteps = settings.EncShowSteps;
     1535                    break;
     1536                case "gotkey":
     1537                    this._gotKey = settings.gotkey;
     1538                    break;
     1539                case "wspublicKey":
     1540                    this._wsPublicKey = settings.wspublicKey;
     1541                    break;
     1542                case "dsacryptoProv":
     1543                    this._dsaCryptoProv.FromXmlString(settings.dsacryptoProv);
     1544                    break;
     1545                case "rsacryptoProv":
     1546                    this._rsaCryptoProv.FromXmlString(settings.rsacryptoProv);
     1547                    break;
     1548                case "wsRSAcryptoProv":
     1549                    this._wsRSACryptoProv.FromXmlString(settings.wsRSAcryptoProv);
     1550                    break;
     1551                case "contentcounter":
     1552                    this._contentCounter = settings.contentcounter;
     1553                    break;
     1554                case "secheaderSigned":
     1555                    this._secHeaderSigned = settings.secheaderSigned;
     1556                    break;
     1557                case "secheaderEnc":
     1558                    this._secHeaderEnc = settings.secheaderEnc;
     1559                    break;
     1560                case "methodnameencrypted":
     1561                    this._methodNameEncrypted = settings.methodnameencrypted;
     1562                    break;
     1563                case "bodyencrypted":
     1564                    this._bodyEncrypted = settings.bodyencrypted;
     1565                    break;
     1566                case "methodnameSigned":
     1567                    this._methodNameSigned = settings.methodnameSigned;
     1568                    break;
     1569                case "bodysigned":
     1570                    this._bodySigned = settings.bodysigned;
     1571                    break;
     1572                case "idtable":
     1573                    this._idTable = settings.idtable;
     1574                    break;
     1575                case "securedsoap":
     1576                    if (settings.securedsoap != null)
     1577                    {
     1578                        if (!this._loaded)
     1579                        {
     1580                            this._securedSOAP = (CopyStringToXml(settings.securedsoap));
     1581                            ShowSecuredSoap();
     1582                            this._loaded = true;
     1583                        }
     1584                        else
     1585                        {
     1586                            this._loaded = true;
     1587                        }
     1588                    }
     1589                    break;
     1590                case "soapelement":
     1591                    if (settings.soapelement != null)
     1592                    {
     1593                        this._soap = CopyStringToXml(settings.soapelement);
     1594                    }
     1595                    break;
     1596                case "wsdlloaded":
     1597                    this._wsdlLoaded = settings.wsdlloaded;
     1598                    break;
     1599                case "sendSoap":
     1600                    if (!send)
     1601                    {
     1602                        OnPropertyChanged("OutputString");
     1603                        send = true;
     1604                    }
     1605                    break;
     1606                case "resetSoap":
     1607                    if (this._soap != null)
     1608                    {
     1609                        this._securedSOAP = (XmlDocument)this._soap.Clone();
     1610                        mySettings.securedsoap = CopyXmlToString(_securedSOAP);
     1611                        ShowSecuredSoap();
     1612                    }
     1613                    break;
     1614                case "AnimationSpeed":
     1615                    presentation.setAnimationSpeed(settings.AnimationSpeed);
     1616                    break;
     1617                case "playPause":
     1618                    presentation.startstopanimation();
     1619                    break;
     1620                case "endAnimation":
     1621                    presentation.endAnimation();
     1622                    break;
     1623
     1624            }
     1625        }
     1626
    16141627        #region INotifyPropertyChanged Member
    16151628
    16161629        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    1617      
     1630
     1631        #endregion
     1632
    16181633        #endregion
    16191634    }
  • trunk/CrypPlugins/Soap/SoapPresentation.xaml.cs

    r641 r2551  
    6969            else
    7070            {
    71                 soap.createInfoMessage("No animation running");
     71                soap.CreateInfoMessage("No animation running");
    7272            }
    7373        }
     
    146146                    if (!animationRunning)
    147147                    {
    148                         XmlNode[] ElementsToEnc = soap.getElementsToEnc();
     148                        XmlNode[] ElementsToEnc = soap.GetElementsToEncrypt();
    149149                       
    150150                        foreach (XmlNode node in ElementsToEnc)
     
    155155                            }
    156156                        }
    157                         XmlNode[] EncryptedElements = soap.getEncryptedElements();
     157                        XmlNode[] EncryptedElements = soap.GetEncryptedElements();
    158158                        foreach (XmlNode node in EncryptedElements)
    159159                        {
     
    163163                            }
    164164                        }
    165                         XmlNode[] signedElements = soap.getSignedElements();
     165                        XmlNode[] signedElements = soap.GetSignedElements();
    166166                        foreach (XmlNode node in signedElements)
    167167                        {
     
    179179                            }
    180180                        }
    181                         XmlNode[] elementsToSign = soap.getElementsToSign();
     181                        XmlNode[] elementsToSign = soap.GetElementsToSign();
    182182                        foreach (XmlNode node in elementsToSign)
    183183                        {
     
    187187                            }
    188188                        }
    189                         XmlNode[] parameters = soap.getParameterToEdit();
     189                        XmlNode[] parameters = soap.GetParameterToEdit();
    190190                        foreach (XmlNode node in parameters)
    191191                        {
     
    346346                string[] name = signIcon.Name.Split(new char[] { '_' });
    347347                string id = name[2];
    348                 soap.removeSignature(id);
     348                soap.RemoveSignature(id);
    349349            }
    350350        }
     
    412412            {
    413413
    414                 if (soap.getSignatureAlg() == null)
    415                 {
    416                     soap.createErrorMessage("You have to select a signature algorithm before you can sign parts of the message");
     414                if (soap.GetSignatureAlgorithm() == null)
     415                {
     416                    soap.CreateErrorMessage("You have to select a signature algorithm before you can sign parts of the message");
    417417                }
    418418                else
     
    423423                    string name = test[0] + ":" + test[1];
    424424                    XmlElement[] array = new XmlElement[1];
    425                     array[0] = (XmlElement)soap.securedSOAP.GetElementsByTagName(name)[0];
    426                     if (!soap.getxPathTrans())
    427                     {
    428                         soap.addIdToElement(name);
    429                     }
    430                     if (!soap.getshowSteps())
    431                     {
    432                         if (!soap.checkSecurityHeader())
     425                    array[0] = (XmlElement)soap.SecuredSoap.GetElementsByTagName(name)[0];
     426                    if (!soap.GetXPathTransForm())
     427                    {
     428                        soap.AddIdToElement(name);
     429                    }
     430                    if (!soap.GetShowSteps())
     431                    {
     432                        if (!soap.CheckSecurityHeader())
    433433                        {
    434                             soap.createSecurityHeaderAndSoapHeader();
     434                            soap.CreateSecurityHeaderAndSoapHeader();
    435435                        }
    436                         soap.signElementsManual(array);
    437                         soap.showsecuredSoap();
     436                        soap.SignElementsManual(array);
     437                        soap.ShowSecuredSoap();
    438438                    }
    439439                    else
     
    443443                        sigAnimator = new SignatureAnimator(ref this.treeView, ref this.soap);
    444444                        sigAnimator.startAnimation(array);
    445                         soap.createInfoMessage("Signature animation started");
     445                        soap.CreateInfoMessage("Signature animation started");
    446446                    }
    447447                }
     
    464464            else
    465465            {
    466                 soap.createInfoMessage("No animation running");
     466                soap.CreateInfoMessage("No animation running");
    467467            }
    468468        }
     
    498498                }
    499499                XmlElement[] array = new XmlElement[1];
    500                 array[0] = (XmlElement)soap.securedSOAP.GetElementsByTagName(name)[0];
    501                 soap.addIdToElement(name);
     500                array[0] = (XmlElement)soap.SecuredSoap.GetElementsByTagName(name)[0];
     501                soap.AddIdToElement(name);
    502502               
    503                 if (soap.gotKey)
    504                 {
    505                     soap.encElements(array);
    506                     if (!soap.getShowEncSteps())
    507                     {
    508                         soap.showsecuredSoap();
     503                if (soap.GotKey)
     504                {
     505                    soap.EncryptElements(array);
     506                    if (!soap.GetIsShowEncryptionsSteps())
     507                    {
     508                        soap.ShowSecuredSoap();
    509509                    }
    510510                    else
     
    517517                else
    518518                {
    519                     soap.createErrorMessage("No key for encryption available. Create one in a Web Service Plugin");
     519                    soap.CreateErrorMessage("No key for encryption available. Create one in a Web Service Plugin");
    520520                }
    521521            }
     
    703703           {
    704704             
    705                if (soap.wsdlLoaded)
     705               if (soap.WSDLLoaded)
    706706               {
    707707                   clearBoxes(securedSoapItem);
     
    716716                       if (type.Equals("System.Windows.Controls.TextBlock"))
    717717                       {
    718                            XmlNode[] parameter = soap.getParameterToEdit();
     718                           XmlNode[] parameter = soap.GetParameterToEdit();
    719719
    720720                           string name = getNameFromPanel(tempPanel, true);
     
    740740                                   box.Height = 23;
    741741                                   box.Width = 80;
    742                                    box.Text = soap.securedSOAP.GetElementsByTagName(name)[0].InnerXml.ToString(); ;
     742                                   box.Text = soap.SecuredSoap.GetElementsByTagName(name)[0].InnerXml.ToString(); ;
    743743                                   box.IsEnabled = true;
    744744
     
    774774           {
    775775               clearBoxes(securedSoapItem);
    776                soap.showsecuredSoap();
     776               soap.ShowSecuredSoap();
    777777           }
    778778
     
    801801                                           {
    802802                                               TextBlock block = (TextBlock)parentPanel.Children[1];
    803                                                soap.securedSOAP.GetElementsByTagName(block.Text)[0].InnerText = box.Text;
    804                                                soap.saveSoap();
     803                                               soap.SecuredSoap.GetElementsByTagName(block.Text)[0].InnerText = box.Text;
     804                                               soap.SaveSoap();
    805805                                               text = box.Text;
    806806                                               childIsTextBox = true;
Note: See TracChangeset for help on using the changeset viewer.