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

Last change on this file since 1219 was 1219, checked in by Tim Podeszwa, 12 years ago

controller poperty added

File size: 64.4 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.ControlSlave, "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        private ControlProxy control;
146[PropertyInfo(Direction.ControlSlave, "WSDL Input", "WSDL to create the soap message",null, DisplayLevel.Beginner)]
147        public IControlWsdl Control
148{
149 get
150 { 
151 if (control == null)
152    control = new ControlProxy (this);
153  return control;
154 }
155}
156
157private ControlPublicKeyProxy controlPublicKeyProxy;
158        [PropertyInfo(Direction.ControlSlave, "Public-Key input", "Encryption Key",null, DisplayLevel.Beginner)]
159        public IControlPublicKey publicKey
160        {
161            get
162            {
163                {
164                    if (controlPublicKeyProxy == null)
165                        controlPublicKeyProxy = new ControlPublicKeyProxy(this);
166                    return controlPublicKeyProxy;
167                }
168            }
169        }
170        private XmlDocument outputString;
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 "resetSoap":
785                    if (this.soap != null)
786                    {
787                        securedSOAP = (XmlDocument)this.soap.Clone();
788                        mySettings.securedsoap = xmlToString(securedSOAP);
789                        showsecuredSoap();
790                    }
791                    break;
792                case "AnimationSpeed":
793                    presentation.setAnimationSpeed(s.AnimationSpeed);
794                    break;
795                case "playPause":
796                    presentation.startstopanimation();
797                    break;
798                case "endAnimation":
799                    presentation.endAnimation();
800                    break;
801
802            }
803        }
804
805        public void saveSoap()
806        {
807            mySettings.securedsoap = xmlToString(this.securedSOAP);
808        }
809
810        public void loadWSDL(string wsdlString)
811        {
812            if (!wsdlString.Equals(""))
813            {
814                StringReader sr = new StringReader(wsdlString);
815                XmlTextReader tx = new XmlTextReader(sr);
816
817                ServiceDescription t = ServiceDescription.Read(tx);
818                ServiceDescription serviceDescription = t.Services[0].ServiceDescription;
819                Types types = serviceDescription.Types;
820                PortTypeCollection portTypes = serviceDescription.PortTypes;
821                MessageCollection messages = serviceDescription.Messages;
822                XmlSchema schema = types.Schemas[0];
823                PortType porttype = portTypes[0];
824                Operation operation = porttype.Operations[0];
825                OperationInput input = operation.Messages[0].Operation.Messages.Input;
826                Message message = messages[input.Message.Name];
827                MessagePart messagePart = message.Parts[0];
828                XmlSchema fsdf = types.Schemas[0];
829                if (fsdf == null)
830                {
831                    Console.WriteLine("Test");
832                }
833                StringWriter twriter = new StringWriter();
834                fsdf.Write(twriter);
835                DataSet set = new DataSet();
836                StringReader sreader = new StringReader(twriter.ToString());
837                XmlTextReader xmlreader = new XmlTextReader(sreader);
838                set.ReadXmlSchema(xmlreader);
839                this.setSignedElements(set);
840                soap = new XmlDocument();
841                node = soap.CreateXmlDeclaration("1.0", "ISO-8859-1", "yes");
842                soap.AppendChild(node);
843                envelope = soap.CreateElement("s", "Envelope", "http://www.w3.org/2003/05/soap-envelope");
844                soap.AppendChild(envelope);
845                body = soap.CreateElement("s", "Body", "http://www.w3.org/2003/05/soap-envelope");
846                XmlNode eingabe = soap.CreateElement("tns", set.Tables[0].ToString(), set.Tables[0].Namespace);
847                DataTable table = set.Tables[0];
848                foreach (DataColumn tempColumn in table.Columns)
849                {
850                    XmlNode neu = soap.CreateElement("tns", tempColumn.ColumnName, set.Tables[0].Namespace);
851                    eingabe.AppendChild(neu);
852                }
853                body.AppendChild(eingabe);
854                envelope.AppendChild(body);
855                StringWriter ti = new StringWriter();
856                XmlTextWriter j = new XmlTextWriter(ti);
857                j.Formatting = Formatting.Indented;
858                soap.WriteContentTo(j);
859                XmlNode rootElement = soap.SelectSingleNode("/*");
860                presentation.origSoapItem = new System.Windows.Controls.TreeViewItem();
861                presentation.origSoapItem.IsExpanded = true;
862                StackPanel panel1 = new StackPanel();
863                StackPanel origSoapPanel = new StackPanel();
864                StackPanel origSoapPanel2 = new StackPanel();
865                panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
866                origSoapPanel.Orientation = System.Windows.Controls.Orientation.Horizontal;
867                origSoapPanel2.Orientation = System.Windows.Controls.Orientation.Horizontal;
868                TextBlock elem1 = new TextBlock();
869                elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
870                TextBlock origSoapElem = new TextBlock();
871                origSoapElem.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
872                TextBlock origSoapElem2 = new TextBlock();
873                origSoapElem2.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
874                panel1.Children.Insert(0, elem1);
875                origSoapPanel.Children.Insert(0, origSoapElem);
876                origSoapPanel2.Children.Insert(0, origSoapElem2);
877                presentation.origSoapItem.Header = panel1;
878                loaded = false;
879                securedSOAP = (XmlDocument)soap.Clone();
880                mySettings.soapelement = xmlToString(soap);
881                mySettings.securedsoap = xmlToString(securedSOAP);
882                this.presentation.CopyXmlToTreeView(rootElement, ref presentation.origSoapItem);
883                this.presentation.treeView.Items.Add(presentation.origSoapItem);
884                presentation.treeView.Items.Refresh();
885                showsecuredSoap();
886                loaded = true;
887                this.InputString = this.soap;
888                wsdlLoaded = true;
889                mySettings.wsdlloaded = true;
890                OnPropertyChanged("OutputString");
891            }
892        }
893
894        public bool getShowEncSteps()
895        {
896            return encset.showsteps;
897        }
898
899        public bool getEncContent()
900        {
901            return encset.content;
902        }
903
904        public string xmlToString(XmlDocument doc)
905        {
906            if (doc != null)
907            {
908                StringWriter sw = new StringWriter();
909                doc.Normalize();
910                XmlTextWriter tx = new XmlTextWriter(sw);
911                tx.Formatting = Formatting.Indented;
912                doc.WriteContentTo(tx);
913                return sw.ToString();
914            }
915            else
916            {
917                return "";
918            }
919        }
920
921        public XmlDocument stringToXml(string s)
922        {
923            XmlDocument doc = new XmlDocument();
924            if (!s.Equals(""))
925            {
926                StringReader sr = new StringReader(s);
927                XmlTextReader tx = new XmlTextReader(sr);
928                doc.Load(tx);
929            }
930            return doc;
931        }
932
933        public void addSignedElement(string newElement)
934        {
935            bool isSigned = false;
936            foreach (string s in signedElements)
937            {
938                if (s != null)
939                {
940                    if (s.Equals(newElement))
941                    {
942                        isSigned = true;
943                    }
944                }
945            }
946            if (!isSigned)
947            {
948                int count = -1;
949                foreach (string s in signedElements)
950                {
951                    count++;
952                    if(s==null)
953                    {
954                        break;
955                    }
956               
957                }
958                signedElements[count] = newElement;
959            }
960        }
961
962        public bool isSigned(string Element)
963        {
964            bool issigned = false;
965            foreach(string s in signedElements)
966            {
967                if (s != null)
968                {
969                    if (s.Equals(Element))
970                    {
971                        issigned = true;
972                    }
973                }
974            }
975            return issigned;
976        }
977
978        public void removeSignature(string Id)
979        {
980            XmlNodeList SignatureElements = securedSOAP.GetElementsByTagName("ds:Signature");
981            ArrayList list = new ArrayList();
982            XmlNode toDelete=null;
983            foreach(XmlNode node in SignatureElements)
984            {
985               
986                foreach(XmlNode child in node.FirstChild.ChildNodes)
987                {
988                if (child.Name.Equals("ds:Reference"))
989                {
990                    foreach(XmlAttribute att in child.Attributes)
991                    {
992                        if (att.Name.Equals("URI"))
993                        {
994                            if (att.Value.Equals("#" + Id))
995                            {
996                                toDelete = node;
997                            }
998                        }
999                    }
1000                }
1001            }
1002            }
1003            if (toDelete != null)
1004            {
1005                foreach (XmlNode node in toDelete.ChildNodes)
1006                {
1007                    if(node.Name.Equals("ds:Reference"))
1008                    {
1009                        foreach (XmlAttribute att in node.Attributes)
1010                        {
1011                            if (att.Name.Equals("URI"))
1012                            {
1013                                if (!att.Value.Equals("#" + Id))
1014                                {
1015                                    string[] id = att.Value.Split(new char[]{'#'});
1016                                    XmlNode elem = getElementById(id[0]);
1017                                    list.Add(elem);
1018                                }
1019                            }
1020                        }
1021                    }
1022                }
1023            }
1024            XmlElement[] signArray = new XmlElement[list.Count];
1025
1026            for (int i = 0; i < list.Count; i++)
1027            {
1028                signArray[i] = (XmlElement)list[i];
1029            }
1030
1031            if (toDelete != null)
1032            {
1033                securedSOAP.GetElementsByTagName("wsse:Security")[0].RemoveChild(toDelete);
1034            }
1035
1036            if (signArray.Length > 0)
1037            {
1038                signElements(signArray);
1039            }
1040            showsecuredSoap();
1041        }
1042
1043        public void encElements(XmlElement[] elements)
1044        {
1045            if (gotKey)
1046            {
1047                bool content = encset.content;
1048                XmlNode secHeader = this.securedSOAP.GetElementsByTagName("wsse:Security")[0];
1049                if (secHeader == null)
1050                {
1051                    hadHeader = false;
1052                    XmlNode head = this.securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
1053
1054                    string wssenamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
1055
1056                    secHeader = this.securedSOAP.CreateElement("wsse", "Security", wssenamespace);
1057
1058                    head.AppendChild(secHeader);
1059                    XmlNode env = this.securedSOAP.GetElementsByTagName("s:Envelope")[0];
1060                    XmlNode soapbody = this.securedSOAP.GetElementsByTagName("s:Body")[0];
1061                    env.InsertBefore(head, soapbody);
1062                }
1063                else
1064                {
1065                    hadHeader = true;
1066                }
1067                RijndaelManaged sessionKey = new RijndaelManaged();
1068                sessionKey.KeySize = 256;
1069
1070
1071                EncryptedXml encXML = new EncryptedXml();
1072
1073                EncryptedKey ek = new EncryptedKey();
1074
1075                byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, wsRSACryptoProv, false);
1076                ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
1077                ek.CipherData = new CipherData(encryptedKey);
1078                //ek.KeyInfo = new KeyInfo();
1079
1080                KeyInfoName name = new KeyInfoName();
1081                name.Value = "Web Service Public Key";
1082                ek.KeyInfo.AddClause(name);
1083
1084                foreach (XmlElement elem in elements)
1085                {
1086                    if (elem != null)
1087                    {
1088                        //Check if Security Header or Body. Only content encryption is allowed by WS-Security
1089                        if (elem.Name.Equals("s:Body") || elem.Name.Equals("wsse:Security"))
1090                        {
1091                            if (content == false)
1092                            {
1093                                createErrorMessage("Only the content of the  "+elem.Name+" element can be encrypted");
1094                            }
1095                            content = true;
1096                        }
1097                        lastSessionKey = Convert.ToBase64String(sessionKey.Key);
1098                        byte[] encryptedElement = encXML.EncryptData(elem, sessionKey, content);
1099                        EncryptedData encElement = new EncryptedData();
1100                        DataReference ekRef = new DataReference();
1101                        if (!content)
1102                        {
1103                            encElement.Type = EncryptedXml.XmlEncElementUrl;
1104                            encElement.Id = idTable[elem.Name].ToString();
1105                            ekRef.Uri = "#" + idTable[elem.Name].ToString();
1106                        }
1107                        else
1108                        {
1109                            encElement.Type = EncryptedXml.XmlEncElementContentUrl;
1110                            addIdToElement(contentCounter+elem.Name);
1111                            encElement.Id = idTable[contentCounter+elem.Name].ToString();
1112                            ekRef.Uri = "#" + idTable[contentCounter+elem.Name].ToString();
1113                            contentCounter++;
1114                            mySettings.contentcounter = contentCounter;
1115                        }
1116                       
1117                        encElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
1118                        encElement.CipherData.CipherValue = encryptedElement;
1119                       
1120                       
1121                        ek.AddReference(ekRef);
1122                        string s = securedSOAP.GetElementsByTagName(elem.Name)[0].ParentNode.Name;
1123
1124                        if (!content)
1125                        {
1126                            securedSOAP.GetElementsByTagName(s)[0].ReplaceChild(securedSOAP.ImportNode(encElement.GetXml(), true), securedSOAP.GetElementsByTagName(elem.Name)[0]);
1127                        }
1128                        else
1129                        {
1130                            securedSOAP.GetElementsByTagName(elem.Name)[0].RemoveAll();
1131                            securedSOAP.GetElementsByTagName(elem.Name)[0].AppendChild(securedSOAP.ImportNode(encElement.GetXml(), true));
1132                        }
1133                        if (elem.Name.Equals("s:Body"))
1134                        {
1135                            bodyEncrypted = true;
1136                            mySettings.bodyencrypted = true;
1137                        }
1138                        if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1139                        {
1140                            methodNameEncrypted = true;
1141                            mySettings.methodnameencrypted = methodNameEncrypted;
1142                        }
1143                        if (elem.Name.Equals("wsse:Security"))
1144                        {
1145                            secHeaderEnc = true;
1146                            mySettings.secheaderEnc = true;
1147                        }
1148                    }
1149
1150                }
1151                secHeader.InsertBefore(securedSOAP.ImportNode(ek.GetXml(), true), secHeader.ChildNodes[0]);
1152                prefixesToEncryptedElement();
1153       
1154                mySettings.securedsoap = xmlToString(securedSOAP);
1155            }
1156            else
1157            {
1158                createErrorMessage("No key for encryption available");
1159            }
1160        }
1161
1162        private void prefixesToEncryptedElement()
1163        {
1164            XmlNodeList encKeyElems = securedSOAP.GetElementsByTagName("EncryptedKey");
1165            foreach (XmlNode child in encKeyElems)
1166            {
1167                addPrefixesToNodeAndChildNode("xenc", child);
1168            }
1169            XmlNodeList encDataElemns = securedSOAP.GetElementsByTagName("EncryptedData");
1170            foreach(XmlNode child in encDataElemns)
1171            {
1172                addPrefixesToNodeAndChildNode("xenc", child);
1173            }
1174        }
1175
1176        private void addPrefixesToNodeAndChildNode(string prefix ,XmlNode node)
1177        {
1178            if(node.Name.Equals("KeyInfo"))
1179        {
1180            node.Prefix = "ds";
1181            prefix = "ds";
1182        }
1183            else
1184        {
1185            node.Prefix = prefix;
1186        }
1187            foreach (XmlNode child in node.ChildNodes)
1188            {
1189                addPrefixesToNodeAndChildNode(prefix, child);
1190            }
1191        }
1192
1193        public void decrypt()
1194        {
1195            XmlElement securityHeader = (XmlElement)securedSOAP.GetElementsByTagName("Security")[0];
1196            XmlElement encKeyXml = (XmlElement) securedSOAP.GetElementsByTagName("EncryptedKey")[0];
1197            XmlElement encData = (XmlElement)securedSOAP.GetElementsByTagName("EncryptedData")[0];
1198            XmlElement KeyInfo = securedSOAP.CreateElement("KeyInfo",SignedXml.XmlDsigNamespaceUrl);
1199
1200            securityHeader.RemoveChild(encKeyXml);
1201            KeyInfo.AppendChild(encKeyXml);
1202
1203            encData.InsertAfter(KeyInfo, encData.GetElementsByTagName("EncryptionMethod")[0]);
1204            this.showsecuredSoap();
1205            EncryptedXml encXml = new EncryptedXml(this.securedSOAP);
1206            encXml.AddKeyNameMapping("RSA-Key", rsaKey);
1207            encXml.DecryptDocument();
1208        }
1209       
1210        public void signElements(XmlElement[] elements)
1211        { 
1212                String sigAlgo = sigset.sigAlg;
1213                XmlNode secHeader = securedSOAP.GetElementsByTagName("Security")[0];
1214                if (secHeader == null)
1215                {
1216                    XmlNode head = securedSOAP.CreateElement("s","Header", "http://www.w3.org/2003/05/soap-envelope");
1217
1218                    string wssenamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
1219
1220                    secHeader = securedSOAP.CreateElement("Security", wssenamespace);
1221
1222                    head.AppendChild(secHeader);
1223                    XmlNode env = securedSOAP.GetElementsByTagName("Envelope")[0];
1224                    XmlNode soapbody = securedSOAP.GetElementsByTagName("Body")[0];
1225                    env.InsertBefore(head, soapbody);
1226                }
1227                SignedXml signedXML = new SignedXml(this.securedSOAP);
1228                foreach (XmlElement elem in elements)
1229                {
1230                    XmlAttribute idAttribute = securedSOAP.CreateAttribute("Id");
1231                    idAttribute.Value = idTable[elem.Name].ToString();
1232                    elem.Attributes.Append(idAttribute);
1233                    XmlAttributeCollection attributes = elem.Attributes;
1234                    XmlAttribute id = attributes["Id"];
1235                    Reference reference = new Reference("#" + id.Value);
1236                    //   Reference reference = new Reference("");
1237                    XmlElement xpathElement = securedSOAP.CreateElement("XPath");
1238                    string Xpath = "ancestor-or-self::Body";
1239                    XmlElement root = this.securedSOAP.DocumentElement;
1240                    XmlElement b = (XmlElement)securedSOAP.GetElementsByTagName("Body")[0];
1241                    XmlNamespaceManager manager = new XmlNamespaceManager(securedSOAP.NameTable);
1242
1243                    manager.AddNamespace("s", b.NamespaceURI);
1244                    xpathElement.InnerText = Xpath;
1245                    XmlDsigXPathTransform xpathTrans = new XmlDsigXPathTransform();
1246                    XmlNodeList list = root.SelectNodes("/s:Envelope/s:Body", manager);
1247                    XmlNodeList list2 = root.SelectNodes("//. | //@* | //namespace::*");
1248                    xpathTrans.LoadInnerXml(xpathElement.SelectNodes("."));
1249                    XmlDsigExcC14NTransform trans = new XmlDsigExcC14NTransform();
1250                    reference.AddTransform(trans);
1251                    XmlElement boo = xpathTrans.GetXml();
1252                    Type xmlDocumentType = typeof(System.Xml.XmlDocument);
1253
1254                    signedXML.AddReference(reference);
1255                    if (elem.Name.Equals("s:Body"))
1256                    {
1257                        bodySigned = true;
1258                        mySettings.bodysigned = true;
1259                    }
1260                    if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1261                    {
1262                        methodNameSigned = true;
1263                        mySettings.methodnameSigned = true;
1264                    }
1265
1266                }
1267                if (sigAlgo.Equals("1"))
1268                {
1269                    CspParameters parameter = new CspParameters();
1270
1271                    parameter.KeyContainerName = "Container";
1272                    RSACryptoServiceProvider provider = new RSACryptoServiceProvider(parameter);
1273                    signedXML.SigningKey = provider;
1274                    signedXML.ComputeSignature();
1275
1276                    KeyInfo keyInfo = new KeyInfo();
1277                    keyInfo.AddClause(new RSAKeyValue(provider));
1278                    signedXML.KeyInfo = keyInfo;
1279                    Reference t = (Reference)signedXML.SignedInfo.References[0];
1280                    IEnumerator enumerator = t.TransformChain.GetEnumerator();
1281                    enumerator.MoveNext();
1282                    XmlElement root = (XmlElement)this.securedSOAP.GetElementsByTagName("Envelope")[0];
1283                    Transform tran = (Transform)enumerator.Current;
1284                    XmlNodeList list2 = root.SelectNodes("//. | //@* | //namespace::*");
1285
1286                }
1287                if (sigAlgo.Equals("0"))
1288                {
1289                    DSA dsa = DSA.Create();
1290                    dsa.ToXmlString(false);
1291                    signedXML.SigningKey = dsa;
1292                    signedXML.ComputeSignature();
1293                }
1294
1295                XmlElement signaturElement = signedXML.GetXml();
1296                secHeader.InsertBefore(securedSOAP.ImportNode(signaturElement, true),secHeader.ChildNodes[0]);
1297           
1298        } 
1299
1300        public bool checkSecurityHeader()
1301        {
1302            bool securityheader = false;
1303            XmlNodeList list = securedSOAP.GetElementsByTagName("wsse:Security");
1304            if (!(list.Count == 0))
1305            {
1306                securityheader = true;
1307            }
1308            return securityheader;
1309        }
1310
1311        public void createSecurityHeaderAndSoapHeader()
1312        {
1313            if (!checkSecurityHeader()) 
1314            {
1315                XmlElement env= (XmlElement) securedSOAP.GetElementsByTagName("s:Envelope")[0];
1316                XmlElement Header = securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
1317                XmlElement secHead = securedSOAP.CreateElement("wsse", "Security", "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd");
1318                env.InsertBefore(Header,env.FirstChild);
1319                Header.AppendChild(secHead);
1320                mySettings.securedsoap = xmlToString(securedSOAP);
1321            }
1322        }
1323
1324        private string getXPathValue(XmlElement elem)
1325        {
1326            string xPathValue = "/s:Envelope";
1327            if (elem.Name.Equals("wsse:Security"))
1328            {
1329                xPathValue = xPathValue + "/wsse:Security";
1330                return xPathValue;
1331            }
1332            xPathValue = xPathValue + "/s:Body";
1333            if (elem.Name.Equals("s:Body"))
1334            {
1335                return xPathValue;
1336            }
1337            xPathValue = xPathValue + "/" + securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name;
1338            if (elem.Name.Equals(securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name))
1339            {
1340                return xPathValue;
1341            }
1342            xPathValue = xPathValue + "/"+elem.Name;
1343            return xPathValue;
1344        }
1345
1346        public void createErrorMessage(string text)
1347        {
1348            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Error));
1349        }
1350
1351        public void createInfoMessage(string text)
1352        {
1353            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Info));
1354        }
1355
1356        public void signElementsManual(XmlElement[] elementsToSign)
1357        {
1358           
1359                string dsNs = "http://www.w3.org/2000/09/xmldsig#";
1360                XmlElement Signature = securedSOAP.CreateElement("ds", "Signature", dsNs);
1361                XmlElement SignedInfo = securedSOAP.CreateElement("ds", "SignedInfo", dsNs);
1362                XmlElement CanonicalizationMethod = securedSOAP.CreateElement("ds", "CanonicalizationMethod", dsNs);
1363                XmlAttribute canMeth = securedSOAP.CreateAttribute("Algorithm");
1364                canMeth.Value = SignedXml.XmlDsigExcC14NTransformUrl;
1365                CanonicalizationMethod.Attributes.Append(canMeth);
1366                XmlElement SignatureMethod = securedSOAP.CreateElement("ds", "SignatureMethod", dsNs);
1367                XmlAttribute sigMeth = securedSOAP.CreateAttribute("Algorithm");
1368
1369                if (sigset.sigAlg.Equals("0"))
1370                {
1371                    sigMeth.Value = SignedXml.XmlDsigDSAUrl;
1372                }
1373                if (sigset.sigAlg.Equals("1"))
1374                {
1375                    sigMeth.Value = SignedXml.XmlDsigRSASHA1Url;
1376                }
1377
1378                SignatureMethod.Attributes.Append(sigMeth);
1379                XmlNode securityHead = securedSOAP.GetElementsByTagName("wsse:Security")[0];
1380                securityHead.InsertBefore(Signature,securityHead.FirstChild);
1381                Signature.AppendChild(SignedInfo);
1382                SignedInfo.AppendChild(CanonicalizationMethod);
1383                SignedInfo.AppendChild(SignatureMethod);
1384
1385                foreach (XmlElement tempElem in elementsToSign)
1386                {
1387                    addIdToElement(tempElem.Name);
1388                    XmlAttribute idAttribute = securedSOAP.CreateAttribute("Id");
1389                    idAttribute.Value = idTable[tempElem.Name].ToString();
1390                    tempElem.Attributes.Append(idAttribute);
1391                    XmlElement ReferenceElement = securedSOAP.CreateElement("ds", "Reference", dsNs);
1392                    XmlAttribute uri = securedSOAP.CreateAttribute("URI");
1393                    XmlElement Transforms = securedSOAP.CreateElement("ds", "Transforms", dsNs);
1394                    ReferenceElement.AppendChild(Transforms);
1395
1396                    if (sigset.Xpath)
1397                    {
1398                        uri.Value = "";
1399                        XmlElement xPathTransform = securedSOAP.CreateElement("ds", "Transform", dsNs);
1400                        XmlAttribute xPathTransAtt = securedSOAP.CreateAttribute("Algorithm");
1401                        xPathTransAtt.Value = SignedXml.XmlDsigXPathTransformUrl;
1402                        xPathTransform.Attributes.Append(xPathTransAtt);
1403                        XmlElement xPathValue = securedSOAP.CreateElement("ds", "XPath", dsNs);
1404                        xPathValue.InnerXml = getXPathValue(tempElem);
1405                        xPathTransform.AppendChild(xPathValue);
1406                        Transforms.AppendChild(xPathTransform);
1407                    }
1408                    else
1409                    {
1410                        uri.Value = "#" + idTable[tempElem.Name].ToString();
1411                    }
1412                    ReferenceElement.Attributes.Append(uri);
1413
1414                    XmlElement c14nTransform = securedSOAP.CreateElement("ds", "Transform", dsNs);
1415                    XmlAttribute c14Url = securedSOAP.CreateAttribute("Algorithm");
1416                    c14Url.Value = SignedXml.XmlDsigExcC14NTransformUrl;
1417                    c14nTransform.Attributes.Append(c14Url);
1418                    Transforms.AppendChild(c14nTransform);
1419                    XmlElement digestMethod = securedSOAP.CreateElement("ds", "DigestMethod", dsNs);
1420                    XmlAttribute digMethAtt = securedSOAP.CreateAttribute("Algorithm");
1421                    digMethAtt.Value = SignedXml.XmlDsigSHA1Url;
1422                    digestMethod.Attributes.Append(digMethAtt);
1423                    ReferenceElement.AppendChild(digestMethod);
1424                    XmlElement digestValue = securedSOAP.CreateElement("ds", "DigestValue", dsNs);
1425                    digestValue.InnerText = Convert.ToBase64String(getDigestValueForElement(tempElem));
1426                    ReferenceElement.AppendChild(digestValue);
1427                    SignedInfo.AppendChild(ReferenceElement);
1428                    if (tempElem.Name.Equals("s:Body"))
1429                    {
1430                        bodySigned = true;
1431                        mySettings.bodysigned = true;
1432                    }
1433                    if (tempElem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1434                    {
1435                        methodNameSigned = true;
1436                        mySettings.methodnameSigned = true;
1437                    }
1438                    if (tempElem.Name.Equals("wsse:Security"))
1439                    {
1440                        secHeaderSigned = true;
1441                        mySettings.secheaderSigned = true;
1442                    }
1443
1444                }
1445                XmlElement SignatureValue = securedSOAP.CreateElement("ds", "SignatureValue", dsNs);
1446                KeyInfo keyInfo = new KeyInfo();
1447                if (sigset.sigAlg.Equals("1"))
1448                {
1449                    SignatureValue.InnerXml = Convert.ToBase64String(rsaCryptoProv.SignHash(getDigestValueForElement(SignedInfo), CryptoConfig.MapNameToOID("SHA1")));
1450                    keyInfo.AddClause(new RSAKeyValue(rsaCryptoProv));
1451                   
1452                }
1453                if (sigset.sigAlg.Equals("0"))
1454                {
1455                    SignatureValue.InnerXml = Convert.ToBase64String(dsaCryptoProv.SignHash(getDigestValueForElement(SignedInfo), CryptoConfig.MapNameToOID("SHA1")));
1456                    keyInfo.AddClause(new DSAKeyValue(dsaCryptoProv));
1457                }
1458                Signature.AppendChild(SignatureValue);
1459                XmlElement xmlKeyInfo = keyInfo.GetXml();
1460                xmlKeyInfo.Prefix = "ds";
1461                foreach(XmlNode childNode in xmlKeyInfo.ChildNodes)
1462                {
1463                    childNode.Prefix = "ds"; 
1464                }
1465                Signature.AppendChild(securedSOAP.ImportNode(xmlKeyInfo, true));
1466                XmlElement secHead = (XmlElement)securedSOAP.GetElementsByTagName("wsse:Security")[0];
1467                mySettings.securedsoap = xmlToString(securedSOAP);
1468        }
1469
1470        public string getIdToElement(string ElemName)
1471        {
1472            string retString = idTable[ElemName].ToString();
1473            return retString;
1474        }
1475
1476        public bool getxPathTrans()
1477        {
1478            return sigset.Xpath;
1479        }
1480
1481        public byte[] getDigestValueForElement(XmlElement elem)
1482        {
1483            Stream canonicalized = canonicalizeNodeWithExcC14n(elem);
1484            SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
1485            byte[] byteValue = sha1.ComputeHash(canonicalized);
1486            return byteValue;
1487        }
1488
1489        public Stream canonicalizeNodeWithExcC14n(XmlElement nodeToCanon)
1490        {
1491            XmlNode node = (XmlNode)nodeToCanon;
1492            XmlNodeReader reader = new XmlNodeReader(node);
1493            Stream stream = new MemoryStream();
1494            XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
1495            writer.WriteNode(reader, false);
1496            writer.Flush();
1497            stream.Position = 0;
1498            XmlDsigExcC14NTransform trans = new XmlDsigExcC14NTransform();
1499            trans.LoadInput(stream);
1500            Stream stream2 = (Stream)trans.GetOutput();
1501            return stream2;
1502        }
1503   
1504        public void showsecuredSoap()
1505        {
1506            presentation.treeView.Items.Clear();
1507            presentation.namespacesTable.Clear();
1508            this.presentation.securedSoapItem = null;
1509
1510            this.presentation.securedSoapItem = new System.Windows.Controls.TreeViewItem();
1511
1512            presentation.securedSoapItem.IsExpanded = true;
1513
1514            StackPanel panel1 = new StackPanel();
1515       
1516
1517            panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
1518
1519            TextBlock elem1 = new TextBlock();
1520            elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"; 
1521            panel1.Children.Insert(0, elem1);
1522            presentation.securedSoapItem.Header = panel1;
1523            XmlNode rootElement = securedSOAP.SelectSingleNode("/*");
1524            this.presentation.CopyXmlToTreeView(rootElement, ref presentation.securedSoapItem);
1525            this.presentation.treeView.Items.Add(presentation.securedSoapItem);
1526        }
1527       
1528        public XmlDocument soap2
1529        {get{return this.soap;}
1530           
1531       }
1532
1533        public void OnPropertyChanged(string name)
1534        {
1535            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
1536        }
1537
1538        public SoapSettings settings2()
1539        {
1540            return (SoapSettings) this.Settings;
1541        }
1542             
1543        #region IPlugin Member
1544
1545        public void Dispose()
1546        {
1547           
1548        }
1549
1550        public void Execute()
1551        {
1552            if (!send)
1553            {
1554                OnPropertyChanged("OutputString");
1555                send = true;
1556            }
1557        }
1558
1559        public void Initialize()
1560        {
1561           
1562        }
1563
1564        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
1565
1566        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
1567
1568        public event StatusChangedEventHandler OnPluginStatusChanged;
1569
1570        public void Pause()
1571        {
1572           
1573        }
1574
1575        public void PostExecution()
1576        {
1577           
1578        }
1579
1580        public void PreExecution()
1581        {
1582           
1583        }
1584
1585        public System.Windows.Controls.UserControl Presentation
1586        {
1587            get { return this.presentation; }
1588        }
1589
1590        public System.Windows.Controls.UserControl QuickWatchPresentation
1591        {
1592            get { return null; }
1593        }
1594
1595        public ISettings Settings
1596        {
1597            get { return (SoapSettings) this.settings; }
1598        }
1599
1600        public SoapSettings mySettings
1601        {
1602            get { return (SoapSettings)this.settings; }
1603        }
1604
1605        public void Stop()
1606        {
1607            send = false;
1608        }
1609
1610        #endregion
1611
1612        #region INotifyPropertyChanged Member
1613
1614        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
1615     
1616        #endregion
1617    }
1618    public class ControlProxy : IControlWsdl
1619    {
1620        private Soap plugin;
1621
1622        // Konstruktor
1623        public ControlProxy(Soap plugin)
1624        {
1625            this.plugin = plugin;
1626        }
1627        #region IControlWsdl Member
1628
1629        public XmlDocument Wsdl
1630        {
1631            get
1632            {
1633                return null;
1634            }
1635            set
1636            {
1637
1638            }
1639        }
1640
1641        public void setWsdl(XmlDocument wsdlDocument)
1642        {
1643           plugin.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1644            {
1645                string s = plugin.xmlToString(wsdlDocument);
1646                plugin.loadWSDL(s);
1647                plugin.wsdlLoaded = true;
1648
1649                plugin.OnPropertyChanged("wsdl");
1650               plugin.createInfoMessage("Received WSDL File");
1651                plugin.createInfoMessage("Created SOAP Message");
1652            }, null);
1653        }
1654
1655        #endregion
1656
1657        #region IControl Member
1658
1659        public event IControlStatusChangedEventHandler OnStatusChanged;
1660
1661        #endregion
1662    }
1663    public class ControlPublicKeyProxy : IControlPublicKey
1664    {
1665        private Soap plugin;
1666        public ControlPublicKeyProxy(Soap plugin)
1667        {
1668            this.plugin = plugin;
1669        }
1670
1671        #region IControlPublicKey Member
1672     
1673        public string publicKey
1674        {
1675            get
1676            {
1677                return null;
1678            }
1679            set
1680            {
1681         
1682            }
1683        }
1684
1685        public void setPublicKey(string publicKey)
1686        {
1687            try
1688            {
1689                if (publicKey == null)
1690                    return;
1691                plugin.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1692                {
1693
1694
1695                    {
1696                        plugin.WsPublicKey = publicKey;
1697
1698                        plugin.WsRSACryptoProv.FromXmlString(plugin.WsPublicKey);
1699                        plugin.gotKey = true;
1700                        plugin.mySettings.gotkey = true;
1701                        plugin.mySettings.wsRSAcryptoProv = plugin.WsRSACryptoProv.ToXmlString(false);
1702                        plugin.OnPropertyChanged("publicKey");
1703                        plugin.createInfoMessage("Public Key Received");
1704                    }
1705                }, null);
1706            }
1707            catch (Exception exc)
1708            {
1709            }
1710        }
1711
1712
1713        #endregion
1714
1715        #region IControl Member
1716
1717        public event IControlStatusChangedEventHandler OnStatusChanged;
1718
1719        #endregion
1720    }
1721
1722}
Note: See TracBrowser for help on using the repository browser.