source: trunk/CrypPlugins/Soap/Soap.cs @ 1489

Last change on this file since 1489 was 1489, checked in by Matthäus Wander, 12 years ago

Soap + WebService:

  • migrated to VS2010
  • replaced Control properties with regular Data properties
File size: 61.9 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using Cryptool.PluginBase;
6using Cryptool.PluginBase.IO;
7using Cryptool.PluginBase.Miscellaneous;
8using System.Xml;
9using System.Xml.Schema;
10using System.Web;
11using System.Web.Services.Description;
12using System.Web.Services.Protocols;
13using System.Data;
14using System.IO;
15using System.ComponentModel;
16using System.Security.Cryptography;
17using System.Security.Cryptography.Xml;
18using System.Windows.Controls;
19using System.Collections;
20using System.Windows.Threading;
21using System.Threading;
22using Cryptool.PluginBase.Control;
23
24
25namespace Soap
26{
27    [Author("Tim Podeszwa", "tim.podeszwa@student.uni-siegen.de", "Uni Siegen", "http://www.uni-siegen.de")]
28    [PluginInfo(true, "SoapMessage", "Represents a SoapMessage", "", "Soap/soap.png")]
29    public class Soap:IThroughput
30    {
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;
42
43        public RSACryptoServiceProvider WsRSACryptoProv
44        {
45            get { return wsRSACryptoProv; }
46            set { wsRSACryptoProv = value; }
47        }
48        private DSACryptoServiceProvider dsaCryptoProv;
49        private string wsPublicKey;
50
51        public string WsPublicKey
52        {
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;
69
70        private struct EncryptionSettings
71        {
72            public string key;
73            public bool content;
74            public bool showsteps;
75        }
76        private struct SignatureSettings
77        {
78            public string sigAlg;
79            public bool Xpath;
80            public bool showsteps;
81        }
82        private EncryptionSettings encset;
83        private SignatureSettings sigset;
84       
85       
86        public Soap()
87        {   
88            soap = new XmlDocument();
89            gotKey = false;
90            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);
112            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, DisplayLevel.Beginner)]
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, DisplayLevel.Beginner)]
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, DisplayLevel.Beginner, 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, DisplayLevel.Beginner, 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;
221            }
222            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()
329        {
330            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))
342                {
343                    list.Add(node);
344                }
345            }
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];
356
357            for (int i = 0; i < list.Count; i++)
358            {
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           
379            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)
397                            {
398                                bool Signed = false;
399                                XmlNode[] signedElement = this.getSignedElements();
400                                foreach(XmlNode sigElem in signedElement)
401                                {
402                                    if (childNode.Name.Equals(sigElem.Name))
403                                    {
404                                        Signed = true;
405                                    }
406                                }
407                                if(!Signed)
408                                {
409                                    list.Add(childNode);
410                                }
411                            }
412                        }
413                    }
414                }
415
416           
417            XmlNode[] retArray1 = new XmlNode[list.Count];
418
419            for (int i = 0; i < list.Count; i++)
420            {
421                retArray1[i] = (XmlNode)list[i];
422            }
423            return retArray1;
424        }
425
426        public bool hasEncryptedContent(XmlNode node)
427        {
428            bool value = false;
429            if (node.HasChildNodes)
430            {
431                if (node.ChildNodes[0].Name.Equals("xenc:EncryptedData"))
432                {
433                    foreach (XmlAttribute att in node.ChildNodes[0].Attributes)
434                    {
435                        if (att.Value.Equals(EncryptedXml.XmlEncElementContentUrl))
436                        {
437                            value = true;
438                        }
439                    }
440                }
441            }
442            return value;
443        }
444
445        public XmlNode[] getEncryptedElements()
446        {
447            ArrayList list = new ArrayList();
448
449
450            XmlNode header = securedSOAP.GetElementsByTagName("s:Header")[0];
451            if (header != null)
452            {
453                foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
454                {
455                    if (node.Name.Equals("wsse:Security"))
456                    {
457                        if (hasEncryptedContent(node))
458                        {
459                            list.Add(node);
460                        }
461                    }
462                }
463            }
464
465            XmlElement body = (XmlElement)securedSOAP.GetElementsByTagName("s:Body")[0];
466
467
468            if (hasEncryptedContent(body))
469            {
470                list.Add(body);
471            }
472            else
473            {
474                foreach (XmlNode node in body.ChildNodes)
475                {
476                    if (node.Name.Equals("xenc:EncryptedData"))
477                    {
478                        list.Add(node);
479                    }
480                    else
481                    {
482                        if(hasEncryptedContent(node))
483                        {list.Add(node);
484                        }
485                        foreach (XmlNode nod in node.ChildNodes)
486                        {
487                            if (nod.Name.Equals("xenc:EncryptedData"))
488                            {
489                                list.Add(nod);
490                            }
491                            else
492                            {
493                                if (hasEncryptedContent(nod))
494                                {
495                                    list.Add(nod);
496                                }
497                            }
498                        }
499                    }
500                }
501            }
502
503
504            XmlNode[] retArray = new XmlNode[list.Count];
505
506            for (int i = 0; i < list.Count; i++)
507            {
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;
525            }
526            else
527            {
528
529                ArrayList list = new ArrayList();
530                XmlNode header = securedSOAP.GetElementsByTagName("s:Header")[0];
531                if (header != null)
532                {
533                    foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
534                    {
535                        if (node.Name.Equals("wsse:Security") && (!hasEncryptedContent(node)))
536                        {
537                            list.Add(node);
538                        }
539                    }
540                }
541                XmlElement body = (XmlElement)securedSOAP.GetElementsByTagName("s:Body")[0];
542
543
544                if (!hasEncryptedContent(body))
545                {
546                    list.Add(body);
547                    if (!bodySigned)
548                    {
549                        foreach (XmlNode node in body.ChildNodes)
550                        {
551                            if (!hasEncryptedContent(node) && (!node.Name.Equals("xenc:EncryptedData")))
552                            {
553                                list.Add(node);
554                                if (!methodNameSigned)
555                                {
556                                    foreach (XmlNode nod in node.ChildNodes)
557                                    {
558                                        if (!hasEncryptedContent(nod) && (!nod.Name.Equals("xenc:EncryptedData")))
559                                        {
560                                            list.Add(nod);
561                                        }
562                                    }
563                                }
564                            }
565                        }
566                    }
567                }
568                XmlNode[] retArray = new XmlNode[list.Count];
569
570                for (int i = 0; i < list.Count; i++)
571                {
572                    retArray[i] = (XmlNode)list[i];
573                }
574                return retArray;
575            }
576           
577        }
578
579        private bool isSigned(XmlNode node)
580        {
581            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"))
591                            {
592                                if (refAtt.Value.Equals("#"+att.Value))
593                                {
594                                    return true;
595                                }
596                            }
597                        }
598                    }
599                }
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;
607                }
608            }
609            return signed;
610        }
611
612        public XmlNode[] getParameterToEdit()
613        {
614            ArrayList list = new ArrayList();
615            if(bodyEncrypted ||bodySigned || methodNameEncrypted || methodNameSigned)
616            {
617                XmlNode[] emptySet = new XmlNode[0];
618                return emptySet;
619            }
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];
641            for (int i = 0; i < list.Count; i++)
642            {
643                nodeset[i] = (XmlNode)list[i];
644            }
645            return nodeset;
646        }
647
648        public XmlNode[] getParameter()
649        {
650            ArrayList list = new ArrayList();
651            foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Body")[0].ChildNodes[0].ChildNodes)
652            {
653                XmlNode[] signedNodes = getSignedElements();
654                bool isSigned = false;
655                foreach (XmlNode signedElement in signedNodes)
656                {
657                    if (signedElement.Name.Equals(node.Name))
658                    {
659                        isSigned = true;
660                    }
661
662                }
663                XmlNode[] encryptedNodes = getEncryptedElements();
664                bool isEncrypted=false;
665                foreach (XmlNode encryptedNode in encryptedNodes)
666                {
667                    if(encryptedNode.Equals(node))
668                    {
669                        isEncrypted = true;
670                    }
671                }
672                if (!isSigned && !isEncrypted)
673                {
674                    list.Add(node);
675                }
676            }
677            XmlNode[] nodeset = new XmlNode[list.Count];
678            for (int i = 0; i < list.Count; i++)
679            {
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;
826                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);
842                DataSet set = new DataSet();
843                StringReader sreader = new StringReader(twriter.ToString());
844                XmlTextReader xmlreader = new XmlTextReader(sreader);
845                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);
854                DataTable table = set.Tables[0];
855                foreach (DataColumn tempColumn in table.Columns)
856                {
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("/*");
867                presentation.origSoapItem = new System.Windows.Controls.TreeViewItem();
868                presentation.origSoapItem.IsExpanded = true;
869                StackPanel panel1 = new StackPanel();
870                StackPanel origSoapPanel = new StackPanel();
871                StackPanel origSoapPanel2 = new StackPanel();
872                panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
873                origSoapPanel.Orientation = System.Windows.Controls.Orientation.Horizontal;
874                origSoapPanel2.Orientation = System.Windows.Controls.Orientation.Horizontal;
875                TextBlock elem1 = new TextBlock();
876                elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
877                TextBlock origSoapElem = new TextBlock();
878                origSoapElem.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
879                TextBlock origSoapElem2 = new TextBlock();
880                origSoapElem2.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
881                panel1.Children.Insert(0, elem1);
882                origSoapPanel.Children.Insert(0, origSoapElem);
883                origSoapPanel2.Children.Insert(0, origSoapElem2);
884                presentation.origSoapItem.Header = panel1;
885                loaded = false;
886                securedSOAP = (XmlDocument)soap.Clone();
887                mySettings.soapelement = xmlToString(soap);
888                mySettings.securedsoap = xmlToString(securedSOAP);
889                this.presentation.CopyXmlToTreeView(rootElement, ref presentation.origSoapItem);
890                this.presentation.treeView.Items.Add(presentation.origSoapItem);
891                presentation.treeView.Items.Refresh();
892                showsecuredSoap();
893                loaded = true;
894                this.InputString = this.soap;
895                wsdlLoaded = true;
896                mySettings.wsdlloaded = true;
897                OnPropertyChanged("OutputString");
898            }
899        }
900
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)
912        {
913            if (doc != null)
914            {
915                StringWriter sw = new StringWriter();
916                doc.Normalize();
917                XmlTextWriter tx = new XmlTextWriter(sw);
918                tx.Formatting = Formatting.Indented;
919                doc.WriteContentTo(tx);
920                return sw.ToString();
921            }
922            else
923            {
924                return "";
925            }
926        }
927
928        public XmlDocument stringToXml(string s)
929        {
930            XmlDocument doc = new XmlDocument();
931            if (!s.Equals(""))
932            {
933                StringReader sr = new StringReader(s);
934                XmlTextReader tx = new XmlTextReader(sr);
935                doc.Load(tx);
936            }
937            return doc;
938        }
939
940        public void addSignedElement(string newElement)
941        {
942            bool isSigned = false;
943            foreach (string s in signedElements)
944            {
945                if (s != null)
946                {
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                {
976                    if (s.Equals(Element))
977                    {
978                        issigned = true;
979                    }
980                }
981            }
982            return issigned;
983        }
984
985        public void removeSignature(string Id)
986        {
987            XmlNodeList SignatureElements = securedSOAP.GetElementsByTagName("ds:Signature");
988            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)
1017                        {
1018                            if (att.Name.Equals("URI"))
1019                            {
1020                                if (!att.Value.Equals("#" + Id))
1021                                {
1022                                    string[] id = att.Value.Split(new char[]{'#'});
1023                                    XmlNode elem = getElementById(id[0]);
1024                                    list.Add(elem);
1025                                }
1026                            }
1027                        }
1028                    }
1029                }
1030            }
1031            XmlElement[] signArray = new XmlElement[list.Count];
1032
1033            for (int i = 0; i < list.Count; i++)
1034            {
1035                signArray[i] = (XmlElement)list[i];
1036            }
1037
1038            if (toDelete != null)
1039            {
1040                securedSOAP.GetElementsByTagName("wsse:Security")[0].RemoveChild(toDelete);
1041            }
1042
1043            if (signArray.Length > 0)
1044            {
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);
1069                }
1070                else
1071                {
1072                    hadHeader = true;
1073                }
1074                RijndaelManaged sessionKey = new RijndaelManaged();
1075                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
1091                foreach (XmlElement elem in elements)
1092                {
1093                    if (elem != null)
1094                    {
1095                        //Check if Security Header or Body. Only content encryption is allowed by WS-Security
1096                        if (elem.Name.Equals("s:Body") || elem.Name.Equals("wsse:Security"))
1097                        {
1098                            if (content == false)
1099                            {
1100                                createErrorMessage("Only the content of the  "+elem.Name+" element can be encrypted");
1101                            }
1102                            content = true;
1103                        }
1104                        lastSessionKey = Convert.ToBase64String(sessionKey.Key);
1105                        byte[] encryptedElement = encXML.EncryptData(elem, sessionKey, content);
1106                        EncryptedData encElement = new EncryptedData();
1107                        DataReference ekRef = new DataReference();
1108                        if (!content)
1109                        {
1110                            encElement.Type = EncryptedXml.XmlEncElementUrl;
1111                            encElement.Id = idTable[elem.Name].ToString();
1112                            ekRef.Uri = "#" + idTable[elem.Name].ToString();
1113                        }
1114                        else
1115                        {
1116                            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                       
1124                        encElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
1125                        encElement.CipherData.CipherValue = encryptedElement;
1126                       
1127                       
1128                        ek.AddReference(ekRef);
1129                        string s = securedSOAP.GetElementsByTagName(elem.Name)[0].ParentNode.Name;
1130
1131                        if (!content)
1132                        {
1133                            securedSOAP.GetElementsByTagName(s)[0].ReplaceChild(securedSOAP.ImportNode(encElement.GetXml(), true), securedSOAP.GetElementsByTagName(elem.Name)[0]);
1134                        }
1135                        else
1136                        {
1137                            securedSOAP.GetElementsByTagName(elem.Name)[0].RemoveAll();
1138                            securedSOAP.GetElementsByTagName(elem.Name)[0].AppendChild(securedSOAP.ImportNode(encElement.GetXml(), true));
1139                        }
1140                        if (elem.Name.Equals("s:Body"))
1141                        {
1142                            bodyEncrypted = true;
1143                            mySettings.bodyencrypted = true;
1144                        }
1145                        if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1146                        {
1147                            methodNameEncrypted = true;
1148                            mySettings.methodnameencrypted = methodNameEncrypted;
1149                        }
1150                        if (elem.Name.Equals("wsse:Security"))
1151                        {
1152                            secHeaderEnc = true;
1153                            mySettings.secheaderEnc = true;
1154                        }
1155                    }
1156
1157                }
1158                secHeader.InsertBefore(securedSOAP.ImportNode(ek.GetXml(), true), secHeader.ChildNodes[0]);
1159                prefixesToEncryptedElement();
1160       
1161                mySettings.securedsoap = xmlToString(securedSOAP);
1162            }
1163            else
1164            {
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        }
1190            else
1191        {
1192            node.Prefix = prefix;
1193        }
1194            foreach (XmlNode child in node.ChildNodes)
1195            {
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);
1214            encXml.DecryptDocument();
1215        }
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()
1308        {
1309            bool securityheader = false;
1310            XmlNodeList list = securedSOAP.GetElementsByTagName("wsse:Security");
1311            if (!(list.Count == 0))
1312            {
1313                securityheader = true;
1314            }
1315            return securityheader;
1316        }
1317
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)
1332        {
1333            string xPathValue = "/s:Envelope";
1334            if (elem.Name.Equals("wsse:Security"))
1335            {
1336                xPathValue = xPathValue + "/wsse:Security";
1337                return xPathValue;
1338            }
1339            xPathValue = xPathValue + "/s:Body";
1340            if (elem.Name.Equals("s:Body"))
1341            {
1342                return xPathValue;
1343            }
1344            xPathValue = xPathValue + "/" + securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name;
1345            if (elem.Name.Equals(securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name))
1346            {
1347                return xPathValue;
1348            }
1349            xPathValue = xPathValue + "/"+elem.Name;
1350            return xPathValue;
1351        }
1352
1353        public void createErrorMessage(string text)
1354        {
1355            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Error));
1356        }
1357
1358        public void createInfoMessage(string text)
1359        {
1360            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Info));
1361        }
1362
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);
1491            SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
1492            byte[] byteValue = sha1.ComputeHash(canonicalized);
1493            return byteValue;
1494        }
1495
1496        public Stream canonicalizeNodeWithExcC14n(XmlElement nodeToCanon)
1497        {
1498            XmlNode node = (XmlNode)nodeToCanon;
1499            XmlNodeReader reader = new XmlNodeReader(node);
1500            Stream stream = new MemoryStream();
1501            XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
1502            writer.WriteNode(reader, false);
1503            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()
1512        {
1513            presentation.treeView.Items.Clear();
1514            presentation.namespacesTable.Clear();
1515            this.presentation.securedSoapItem = null;
1516
1517            this.presentation.securedSoapItem = new System.Windows.Controls.TreeViewItem();
1518
1519            presentation.securedSoapItem.IsExpanded = true;
1520
1521            StackPanel panel1 = new StackPanel();
1522       
1523
1524            panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
1525
1526            TextBlock elem1 = new TextBlock();
1527            elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"; 
1528            panel1.Children.Insert(0, elem1);
1529            presentation.securedSoapItem.Header = panel1;
1530            XmlNode rootElement = securedSOAP.SelectSingleNode("/*");
1531            this.presentation.CopyXmlToTreeView(rootElement, ref presentation.securedSoapItem);
1532            this.presentation.treeView.Items.Add(presentation.securedSoapItem);
1533        }
1534       
1535        public XmlDocument soap2
1536        {get{return this.soap;}
1537           
1538       }
1539
1540        public void OnPropertyChanged(string name)
1541        {
1542            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
1543        }
1544
1545        public SoapSettings settings2()
1546        {
1547            return (SoapSettings) this.Settings;
1548        }
1549             
1550        #region IPlugin Member
1551
1552        public void Dispose()
1553        {
1554           
1555        }
1556
1557        public void Execute()
1558        {
1559        }
1560
1561        public void Initialize()
1562        {
1563           
1564        }
1565
1566        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
1567
1568        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
1569
1570        public event StatusChangedEventHandler OnPluginStatusChanged;
1571
1572        public void Pause()
1573        {
1574           
1575        }
1576
1577        public void PostExecution()
1578        {
1579           
1580        }
1581
1582        public void PreExecution()
1583        {
1584           
1585        }
1586
1587        public System.Windows.Controls.UserControl Presentation
1588        {
1589            get { return this.presentation; }
1590        }
1591
1592        public System.Windows.Controls.UserControl QuickWatchPresentation
1593        {
1594            get { return null; }
1595        }
1596
1597        public ISettings Settings
1598        {
1599            get { return (SoapSettings) this.settings; }
1600        }
1601
1602        public SoapSettings mySettings
1603        {
1604            get { return (SoapSettings)this.settings; }
1605        }
1606
1607        public void Stop()
1608        {
1609            send = false;
1610        }
1611
1612        #endregion
1613
1614        #region INotifyPropertyChanged Member
1615
1616        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
1617     
1618        #endregion
1619    }
1620
1621}
Note: See TracBrowser for help on using the repository browser.