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

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

minor changes (assembly version etc.)

File size: 61.2 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;
22
23
24namespace Soap
25{
26    [Author("Tim Podeszwa", "tim.podeszwa@student.uni-siegen.de", "Uni Siegen", "http://www.uni-siegen.de")]
27    [PluginInfo(true, "SoapMessage", "Represents a SoapMessage", "", "Soap/soap.png")]
28    public class Soap:IThroughput
29    {
30        private ISettings settings = new SoapSettings();
31        private SoapPresentation presentation; 
32     
33        private XmlNode node, envelope, body;
34        public XmlDocument soap, inputDocument, outputString;
35        public XmlDocument securedSOAP;
36        private string[] signedElements;
37        public Hashtable idTable;
38        private bool bodySigned, methodNameSigned, bodyEncrypted, methodNameEncrypted ,secHeaderEnc,secHeaderSigned;
39        private int contentCounter;
40        private RSACryptoServiceProvider wsRSACryptoProv,rsaCryptoProv;
41        private DSACryptoServiceProvider dsaCryptoProv;
42        private string wsPublicKey;
43        public bool gotKey;
44        public bool wsdlLoaded,loaded;
45        public string lastSessionKey;
46        public bool hadHeader;
47        public bool send = false;
48
49
50
51        /// <summary>
52        /// Encryption Variablen rausnehmen
53        /// </summary>
54        private CspParameters cspParams;
55        private RSACryptoServiceProvider rsaKey;
56
57        private struct EncryptionSettings
58        {
59            public string key;
60            public bool content;
61            public bool showsteps;
62        }
63        private struct SignatureSettings
64        {
65            public string sigAlg;
66            public bool Xpath;
67            public bool showsteps;
68        }
69        private EncryptionSettings encset;
70        private SignatureSettings sigset;
71       
72       
73        public Soap()
74        {   
75            soap = new XmlDocument();
76            gotKey = false;
77            this.presentation = new SoapPresentation(this);
78            settings.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(settings_PropertyChanged);
79            wsdlLoaded = false;
80            idTable = new Hashtable();
81            soap = new XmlDocument();
82            encset = new EncryptionSettings();
83            sigset = new SignatureSettings();
84            cspParams = new CspParameters();
85            cspParams.KeyContainerName = "XML_ENC_RSA_KEY";
86            rsaKey = new RSACryptoServiceProvider(cspParams);
87            rsaCryptoProv = new RSACryptoServiceProvider();
88            dsaCryptoProv = new DSACryptoServiceProvider();
89            wsRSACryptoProv = new RSACryptoServiceProvider();
90            securedSOAP = new XmlDocument();
91            soap = new XmlDocument();
92            mySettings.idtable = idTable;
93            rsaCryptoProv.ToXmlString(false);
94            mySettings.rsacryptoProv = rsaCryptoProv.ToXmlString(true);
95            mySettings.dsacryptoProv = dsaCryptoProv.ToXmlString(true);
96            mySettings.wsRSAcryptoProv = wsRSACryptoProv.ToXmlString(false);
97            contentCounter = 0;
98            mySettings.securedsoap = xmlToString(securedSOAP);
99            this.InputString = new XmlDocument();
100            loaded = false;
101            sigset.sigAlg = "1";
102           
103        }
104
105        public bool getshowSteps()
106        {
107            return sigset.showsteps;
108        }
109
110
111        [PropertyInfo(Direction.ControlSlave, "WSDL Input", "WSDL to create the soap message",null, DisplayLevel.Beginner)]
112        public XmlDocument wsdl
113        {
114            set
115            {
116                 presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
117                    {
118                string s = xmlToString(value);
119                loadWSDL(s);
120                wsdlLoaded = true;
121                       
122                  OnPropertyChanged("wsdl");
123                  createInfoMessage("Received WSDL File");
124                  createInfoMessage("Created SOAP Message");
125                    }, null);
126            }
127            get
128            {
129                return null;
130            }
131        }
132
133        [PropertyInfo(Direction.ControlSlave, "Public-Key input", "Encryption Key",null, DisplayLevel.Beginner)]
134        public string publicKey
135        {
136            set
137            {
138                this.wsPublicKey = value;
139
140                wsRSACryptoProv.FromXmlString(wsPublicKey);
141                gotKey = true;
142                mySettings.gotkey = true;
143                mySettings.wsRSAcryptoProv = wsRSACryptoProv.ToXmlString(false);
144                OnPropertyChanged("publicKey");
145                createInfoMessage("Public Key Received");
146            }
147            get
148            {
149                return this.wsPublicKey;
150            }
151        }
152
153       [PropertyInfo(Direction.OutputData, "SOAP output", "Send a SOAP Message", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, "XmlConverter")]
154        public XmlDocument OutputString                                                                                                 
155        {
156            get {  return this.securedSOAP;  }
157            set
158            {
159
160                this.securedSOAP = value;
161                OnPropertyChanged("OutputString");
162                send = true;
163
164            }
165        }
166   
167       [PropertyInfo(Direction.InputData, "SOAP input", "Input a SOAP message to be processed by the Web Service", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, "XmlOutputConverter")]
168        public XmlDocument InputString       
169        {
170            get { return this.inputDocument; }
171            set
172            {
173            this.inputDocument = value;
174
175             OnPropertyChanged("InputString");
176            }
177        }
178
179        public Object XmlOutputConverter(Object Data)
180        {
181            string test = Data.ToString();
182
183            if (test.StartsWith("<"))
184            {
185                string test1 = Data.GetType().ToString();
186                test1 = test1 + " " + test;
187                XmlDocument doc = (XmlDocument)Data;
188                StringWriter t = new StringWriter();
189                Object obj = new Object();
190                try
191                {
192                    XmlTextWriter j = new XmlTextWriter(t);
193                    j.Formatting = Formatting.Indented;
194                    doc.WriteContentTo(j);
195                    obj = (Object)t.ToString();
196                }
197                catch (Exception e)
198                {
199                    Console.WriteLine(e.ToString());
200
201                }
202                return obj;
203            }
204            return null;
205         
206        }
207
208        public Object XmlConverter(Object Data)
209        {
210            string test = Data.ToString();
211            if (test.StartsWith("<"))
212            {
213                XmlDocument doc = (XmlDocument)this.securedSOAP;
214                StringWriter t = new StringWriter();
215                Object obj = new Object();
216                try
217                {
218                    XmlTextWriter j = new XmlTextWriter(t);
219                    j.Formatting = Formatting.Indented;
220                    doc.WriteContentTo(j);
221                    obj = (Object)t.ToString();
222                }
223                catch (Exception e)
224                {
225                    Console.WriteLine(e.ToString());
226
227                }
228                return obj;
229            }
230            return null;
231        }
232
233        public void setSignedElements(DataSet ds)
234        {
235            DataTable table = ds.Tables[0];
236            signedElements = new string[table.Columns.Count];
237        }
238
239        public void clearSoap()
240        {
241            this.soap.RemoveAll();
242            this.soap = new XmlDocument();
243     
244            this.node = null;   
245        }
246
247        public void addIdToElement(string element)
248        {
249            if(!idTable.ContainsKey(element))
250            {
251            System.Random r = new Random();
252            int zufallszahl = r.Next(100000000);
253                if(!idTable.ContainsValue(zufallszahl))
254                {
255                    System.Threading.Thread.Sleep(500);
256                    zufallszahl = r.Next(100000000);
257                }
258                idTable.Add(element, zufallszahl);
259                mySettings.idtable = idTable;
260            }
261        }
262
263        private XmlNode getElementById(string id)
264        {
265
266            XmlNodeList securityHeader = securedSOAP.GetElementsByTagName("wsse:Security");
267            foreach(XmlNode node in securityHeader)
268            {
269                foreach (XmlAttribute att in node.Attributes)
270                {
271                    if(att.Name.Equals("Id") && ("#"+att.Value).Equals(id))
272                    {
273                        return node;
274                    }
275                }
276            }
277
278            XmlNode body = securedSOAP.GetElementsByTagName("s:Body")[0];
279            foreach (XmlAttribute att in body.Attributes)
280            {
281                if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
282                {
283                    return body;
284                }
285            }
286 
287            foreach (XmlNode node in body.ChildNodes)
288            {
289                foreach (XmlAttribute att in node.Attributes)
290                {
291                    if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
292                    {
293                        return node;
294                    }
295                }
296                foreach(XmlNode child in node.ChildNodes)
297                {
298                    foreach (XmlAttribute att in child.Attributes)
299                    {
300                        if (att.Name.Equals("Id") && ("#" + att.Value).Equals(id))
301                        {
302                            return child;
303                        }
304                    }
305                }
306            }
307            return null;
308        }
309     
310        public XmlNode[] getSignedElements()
311        {
312            ArrayList list = new ArrayList();
313            if (bodySigned)
314            {
315                list.Add(securedSOAP.GetElementsByTagName("s:Body")[0]);
316            }
317            if (methodNameSigned)
318            {
319                list.Add(securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild);
320            }
321            foreach(XmlNode node in securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.ChildNodes)
322            {
323                if(isSigned(node))
324                {
325                    list.Add(node);
326                }
327            }
328            if(secHeaderSigned)
329            {
330                if (isSigned(securedSOAP.GetElementsByTagName("wsse:Security")[0]));
331             {
332                list.Add(securedSOAP.GetElementsByTagName("wsse:Security")[0]);
333            }
334            }
335
336
337            XmlNode[] retArray = new XmlNode[list.Count];
338
339            for (int i = 0; i < list.Count; i++)
340            {
341                retArray[i] = (XmlNode)list[i];
342            }
343            return retArray;
344        }
345
346        public XmlNode[] getElementsToSign()
347        {
348            if (secHeaderEnc && secHeaderSigned)
349            {
350                XmlNode[] retArray = new XmlNode[0];
351                return retArray;
352            }
353            if (secHeaderEnc)
354            {
355                XmlNode[] retArray = new XmlNode[1];
356                retArray[0] = securedSOAP.GetElementsByTagName("wsse:Security")[0];
357                return retArray;
358            }
359
360           
361            ArrayList list = new ArrayList();
362            if (!secHeaderSigned && (securedSOAP.GetElementsByTagName("wsse:Security").Count>0))
363            {
364                list.Add(securedSOAP.GetElementsByTagName("wsse:Security")[0]);
365            }
366            XmlNode Body = securedSOAP.GetElementsByTagName("s:Body")[0];
367            XmlNode BodysChild = Body.ChildNodes[0];
368            if (!bodySigned)
369            {
370                list.Add(Body);
371                if (!bodyEncrypted)
372               
373                    if (!methodNameSigned) 
374                    {
375                        list.Add(BodysChild);
376                        if(!methodNameEncrypted)
377                        {
378                            foreach(XmlNode childNode in BodysChild.ChildNodes)
379                            {
380                                bool Signed = false;
381                                XmlNode[] signedElement = this.getSignedElements();
382                                foreach(XmlNode sigElem in signedElement)
383                                {
384                                    if (childNode.Name.Equals(sigElem.Name))
385                                    {
386                                        Signed = true;
387                                    }
388                                }
389                                if(!Signed)
390                                {
391                                    list.Add(childNode);
392                                }
393                            }
394                        }
395                    }
396                }
397
398           
399            XmlNode[] retArray1 = new XmlNode[list.Count];
400
401            for (int i = 0; i < list.Count; i++)
402            {
403                retArray1[i] = (XmlNode)list[i];
404            }
405            return retArray1;
406        }
407
408        public bool hasEncryptedContent(XmlNode node)
409        {
410            bool value = false;
411            if (node.HasChildNodes)
412            {
413                if (node.ChildNodes[0].Name.Equals("xenc:EncryptedData"))
414                {
415                    foreach (XmlAttribute att in node.ChildNodes[0].Attributes)
416                    {
417                        if (att.Value.Equals(EncryptedXml.XmlEncElementContentUrl))
418                        {
419                            value = true;
420                        }
421                    }
422                }
423            }
424            return value;
425        }
426
427        public XmlNode[] getEncryptedElements()
428        {
429            ArrayList list = new ArrayList();
430
431
432            XmlNode header = securedSOAP.GetElementsByTagName("s:Header")[0];
433            if (header != null)
434            {
435                foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
436                {
437                    if (node.Name.Equals("wsse:Security"))
438                    {
439                        if (hasEncryptedContent(node))
440                        {
441                            list.Add(node);
442                        }
443                    }
444                }
445            }
446
447            XmlElement body = (XmlElement)securedSOAP.GetElementsByTagName("s:Body")[0];
448
449
450            if (hasEncryptedContent(body))
451            {
452                list.Add(body);
453            }
454            else
455            {
456                foreach (XmlNode node in body.ChildNodes)
457                {
458                    if (node.Name.Equals("xenc:EncryptedData"))
459                    {
460                        list.Add(node);
461                    }
462                    else
463                    {
464                        if(hasEncryptedContent(node))
465                        {list.Add(node);
466                        }
467                        foreach (XmlNode nod in node.ChildNodes)
468                        {
469                            if (nod.Name.Equals("xenc:EncryptedData"))
470                            {
471                                list.Add(nod);
472                            }
473                            else
474                            {
475                                if (hasEncryptedContent(nod))
476                                {
477                                    list.Add(nod);
478                                }
479                            }
480                        }
481                    }
482                }
483            }
484
485
486            XmlNode[] retArray = new XmlNode[list.Count];
487
488            for (int i = 0; i < list.Count; i++)
489            {
490                retArray[i] = (XmlNode)list[i];
491            }
492            return retArray;
493        }
494
495        public XmlNode[] getElementsToEnc()
496        {
497            if (secHeaderEnc && secHeaderSigned)
498            {
499                XmlNode[] retArray = new XmlNode[0];
500                return retArray;
501            }
502            if (secHeaderSigned)
503            {
504                XmlNode[] retArray = new XmlNode[1];
505                retArray[0] = securedSOAP.GetElementsByTagName("wsse:Security")[0];
506                return retArray;
507            }
508            else
509            {
510
511                ArrayList list = new ArrayList();
512                XmlNode header = securedSOAP.GetElementsByTagName("s:Header")[0];
513                if (header != null)
514                {
515                    foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Header")[0].ChildNodes)
516                    {
517                        if (node.Name.Equals("wsse:Security") && (!hasEncryptedContent(node)))
518                        {
519                            list.Add(node);
520                        }
521                    }
522                }
523                XmlElement body = (XmlElement)securedSOAP.GetElementsByTagName("s:Body")[0];
524
525
526                if (!hasEncryptedContent(body))
527                {
528                    list.Add(body);
529                    if (!bodySigned)
530                    {
531                        foreach (XmlNode node in body.ChildNodes)
532                        {
533                            if (!hasEncryptedContent(node) && (!node.Name.Equals("xenc:EncryptedData")))
534                            {
535                                list.Add(node);
536                                if (!methodNameSigned)
537                                {
538                                    foreach (XmlNode nod in node.ChildNodes)
539                                    {
540                                        if (!hasEncryptedContent(nod) && (!nod.Name.Equals("xenc:EncryptedData")))
541                                        {
542                                            list.Add(nod);
543                                        }
544                                    }
545                                }
546                            }
547                        }
548                    }
549                }
550                XmlNode[] retArray = new XmlNode[list.Count];
551
552                for (int i = 0; i < list.Count; i++)
553                {
554                    retArray[i] = (XmlNode)list[i];
555                }
556                return retArray;
557            }
558           
559        }
560
561        private bool isSigned(XmlNode node)
562        {
563            bool signed = false;
564            foreach(XmlAttribute att in node.Attributes )
565            {
566                if (att.Name.Equals("Id"))
567                {
568                    foreach (XmlNode refElem in securedSOAP.GetElementsByTagName("ds:Reference"))
569                    {
570                        foreach(XmlAttribute refAtt in refElem.Attributes)
571                        {
572                            if(refAtt.Name.Equals("URI"))
573                            {
574                                if (refAtt.Value.Equals("#"+att.Value))
575                                {
576                                    return true;
577                                }
578                            }
579                        }
580                    }
581                }
582            }
583            foreach (XmlNode xPath in securedSOAP.GetElementsByTagName("ds:XPath"))
584            {
585                string[] splitter = xPath.InnerText.Split(new char[]{'/'});
586                if(splitter[splitter.Length-1].Equals(node.Name))
587                {
588                   return true;
589                }
590            }
591            return signed;
592        }
593
594        public XmlNode[] getParameterToEdit()
595        {
596            ArrayList list = new ArrayList();
597            if(bodyEncrypted ||bodySigned || methodNameEncrypted || methodNameSigned)
598            {
599                XmlNode[] emptySet = new XmlNode[0];
600                return emptySet;
601            }
602            if (secHeaderEnc || secHeaderSigned)
603            {
604                XmlNode[] retArray = new XmlNode[0];
605                return retArray;
606            }
607
608            if (!secHeaderEnc)
609            {
610                foreach (XmlNode param in securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.ChildNodes)
611                {
612                    if (!isSigned(param))
613                    {
614                        if (!hasEncryptedContent(param))
615                        {
616                            if (!param.Name.Equals("xenc:EncryptedData"))
617                                list.Add(param);
618                        }
619                    }
620                }
621            }
622            XmlNode[] nodeset = new XmlNode[list.Count];
623            for (int i = 0; i < list.Count; i++)
624            {
625                nodeset[i] = (XmlNode)list[i];
626            }
627            return nodeset;
628        }
629
630        public XmlNode[] getParameter()
631        {
632            ArrayList list = new ArrayList();
633            foreach (XmlNode node in securedSOAP.GetElementsByTagName("s:Body")[0].ChildNodes[0].ChildNodes)
634            {
635                XmlNode[] signedNodes = getSignedElements();
636                bool isSigned = false;
637                foreach (XmlNode signedElement in signedNodes)
638                {
639                    if (signedElement.Name.Equals(node.Name))
640                    {
641                        isSigned = true;
642                    }
643
644                }
645                XmlNode[] encryptedNodes = getEncryptedElements();
646                bool isEncrypted=false;
647                foreach (XmlNode encryptedNode in encryptedNodes)
648                {
649                    if(encryptedNode.Equals(node))
650                    {
651                        isEncrypted = true;
652                    }
653                }
654                if (!isSigned && !isEncrypted)
655                {
656                    list.Add(node);
657                }
658            }
659            XmlNode[] nodeset = new XmlNode[list.Count];
660            for (int i = 0; i < list.Count; i++)
661            {
662                nodeset[i] = (XmlNode)list[i];
663            }
664            return nodeset;
665        }
666
667        public string getSignatureAlg()
668        {
669            return sigset.sigAlg;
670        }
671
672        void settings_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
673        {
674            SoapSettings s = (SoapSettings)sender;
675
676            switch (e.PropertyName)
677            {
678                case "SignatureAlg":
679                    sigset.sigAlg = s.SignatureAlg;
680                    break;
681
682                case "SigXPathRef":
683                    sigset.Xpath = s.SigXPathRef;
684                    break;
685
686                case "SigShowSteps":
687                    sigset.showsteps = s.SigShowSteps;
688                    break;
689                case "EncContentRadio":
690                    if (s.EncContentRadio == 0)
691                    {
692                        encset.content = false;
693                    }
694                    if (s.EncContentRadio == 1)
695                    {
696                        encset.content = true;
697                    }
698                    break;
699
700                case "EncShowSteps":
701                    encset.showsteps = s.EncShowSteps;
702                    break;
703                case "gotkey":
704                    this.gotKey = s.gotkey;
705                    break;
706                case "wspublicKey":
707                   this.wsPublicKey =s.wspublicKey;
708                    break;
709                case "dsacryptoProv":
710                    this.dsaCryptoProv.FromXmlString( s.dsacryptoProv);
711                    break;
712                case "rsacryptoProv":
713                    this.rsaCryptoProv.FromXmlString( s.rsacryptoProv);
714                    break;
715                case "wsRSAcryptoProv":
716                    this.wsRSACryptoProv.FromXmlString(s.wsRSAcryptoProv);
717                    break;
718                case "contentcounter":
719                    this.contentCounter = s.contentcounter;
720                    break;
721                case "secheaderSigned":
722                    this.secHeaderSigned = s.secheaderSigned;
723                    break;
724                case "secheaderEnc":
725                    this.secHeaderEnc = s.secheaderEnc;
726                    break;
727                case "methodnameencrypted":
728                    this.methodNameEncrypted = s.methodnameencrypted;
729                    break;
730                case "bodyencrypted":
731                    this.bodyEncrypted = s.bodyencrypted;
732                    break;
733                case "methodnameSigned":
734                    this.methodNameSigned = s.methodnameSigned;
735                    break;
736                case "bodysigned":
737                    this.bodySigned= s.bodysigned;
738                    break;
739                case "idtable": 
740                    this.idTable = s.idtable;
741                    break;
742                case "securedsoap":
743                    if (s.securedsoap != null)
744                    {
745                        if (!loaded)
746                        {
747                            securedSOAP = (stringToXml(s.securedsoap));
748                            showsecuredSoap();
749                            loaded = true;
750                        }
751                        else
752                        {
753                            loaded = true;
754                        }
755                    }
756                    break;
757                case "soapelement":
758                    if (s.soapelement != null)
759                    {
760                        this.soap = stringToXml(s.soapelement);
761                    }
762                   break;
763                case "wsdlloaded":
764                    this.wsdlLoaded = s.wsdlloaded ;
765                    break;
766                case "resetSoap":
767                    if (this.soap != null)
768                    {
769                        securedSOAP = (XmlDocument)this.soap.Clone();
770                        mySettings.securedsoap = xmlToString(securedSOAP);
771                        showsecuredSoap();
772                    }
773                    break;
774                case "AnimationSpeed":
775                    presentation.setAnimationSpeed(s.AnimationSpeed);
776                    break;
777                case "playPause":
778                    presentation.startstopanimation();
779                    break;
780                case "endAnimation":
781                    presentation.endAnimation();
782                    break;
783
784            }
785        }
786
787        public void saveSoap()
788        {
789            mySettings.securedsoap = xmlToString(this.securedSOAP);
790        }
791
792        public void loadWSDL(string wsdlString)
793        {
794            if (!wsdlString.Equals(""))
795            {
796                StringReader sr = new StringReader(wsdlString);
797                XmlTextReader tx = new XmlTextReader(sr);
798
799                ServiceDescription t = ServiceDescription.Read(tx);
800                ServiceDescription serviceDescription = t.Services[0].ServiceDescription;
801                Types types = serviceDescription.Types;
802                PortTypeCollection portTypes = serviceDescription.PortTypes;
803                MessageCollection messages = serviceDescription.Messages;
804                XmlSchema schema = types.Schemas[0];
805                PortType porttype = portTypes[0];
806                Operation operation = porttype.Operations[0];
807                OperationInput input = operation.Messages[0].Operation.Messages.Input;
808                Message message = messages[input.Message.Name];
809                MessagePart messagePart = message.Parts[0];
810                XmlSchema fsdf = types.Schemas[0];
811                if (fsdf == null)
812                {
813                    Console.WriteLine("Test");
814                }
815                StringWriter twriter = new StringWriter();
816                fsdf.Write(twriter);
817                DataSet set = new DataSet();
818                StringReader sreader = new StringReader(twriter.ToString());
819                XmlTextReader xmlreader = new XmlTextReader(sreader);
820                set.ReadXmlSchema(xmlreader);
821                this.setSignedElements(set);
822                soap = new XmlDocument();
823                node = soap.CreateXmlDeclaration("1.0", "ISO-8859-1", "yes");
824                soap.AppendChild(node);
825                envelope = soap.CreateElement("s", "Envelope", "http://www.w3.org/2003/05/soap-envelope");
826                soap.AppendChild(envelope);
827                body = soap.CreateElement("s", "Body", "http://www.w3.org/2003/05/soap-envelope");
828                XmlNode eingabe = soap.CreateElement("tns", set.Tables[0].ToString(), set.Tables[0].Namespace);
829                DataTable table = set.Tables[0];
830                foreach (DataColumn tempColumn in table.Columns)
831                {
832                    XmlNode neu = soap.CreateElement("tns", tempColumn.ColumnName, set.Tables[0].Namespace);
833                    eingabe.AppendChild(neu);
834                }
835                body.AppendChild(eingabe);
836                envelope.AppendChild(body);
837                StringWriter ti = new StringWriter();
838                XmlTextWriter j = new XmlTextWriter(ti);
839                j.Formatting = Formatting.Indented;
840                soap.WriteContentTo(j);
841                XmlNode rootElement = soap.SelectSingleNode("/*");
842                presentation.origSoapItem = new System.Windows.Controls.TreeViewItem();
843                presentation.origSoapItem.IsExpanded = true;
844                StackPanel panel1 = new StackPanel();
845                StackPanel origSoapPanel = new StackPanel();
846                StackPanel origSoapPanel2 = new StackPanel();
847                panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
848                origSoapPanel.Orientation = System.Windows.Controls.Orientation.Horizontal;
849                origSoapPanel2.Orientation = System.Windows.Controls.Orientation.Horizontal;
850                TextBlock elem1 = new TextBlock();
851                elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
852                TextBlock origSoapElem = new TextBlock();
853                origSoapElem.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
854                TextBlock origSoapElem2 = new TextBlock();
855                origSoapElem2.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
856                panel1.Children.Insert(0, elem1);
857                origSoapPanel.Children.Insert(0, origSoapElem);
858                origSoapPanel2.Children.Insert(0, origSoapElem2);
859                presentation.origSoapItem.Header = panel1;
860                loaded = false;
861                securedSOAP = (XmlDocument)soap.Clone();
862                mySettings.soapelement = xmlToString(soap);
863                mySettings.securedsoap = xmlToString(securedSOAP);
864                this.presentation.CopyXmlToTreeView(rootElement, ref presentation.origSoapItem);
865                this.presentation.treeView.Items.Add(presentation.origSoapItem);
866                presentation.treeView.Items.Refresh();
867                showsecuredSoap();
868                loaded = true;
869                this.InputString = this.soap;
870                wsdlLoaded = true;
871                mySettings.wsdlloaded = true;
872                OnPropertyChanged("OutputString");
873            }
874        }
875
876        public bool getShowEncSteps()
877        {
878            return encset.showsteps;
879        }
880
881        public bool getEncContent()
882        {
883            return encset.content;
884        }
885
886        public string xmlToString(XmlDocument doc)
887        {
888            if (doc != null)
889            {
890                StringWriter sw = new StringWriter();
891                doc.Normalize();
892                XmlTextWriter tx = new XmlTextWriter(sw);
893                tx.Formatting = Formatting.Indented;
894                doc.WriteContentTo(tx);
895                return sw.ToString();
896            }
897            else
898            {
899                return "";
900            }
901        }
902
903        public XmlDocument stringToXml(string s)
904        {
905            XmlDocument doc = new XmlDocument();
906            if (!s.Equals(""))
907            {
908                StringReader sr = new StringReader(s);
909                XmlTextReader tx = new XmlTextReader(sr);
910                doc.Load(tx);
911            }
912            return doc;
913        }
914
915        public void addSignedElement(string newElement)
916        {
917            bool isSigned = false;
918            foreach (string s in signedElements)
919            {
920                if (s != null)
921                {
922                    if (s.Equals(newElement))
923                    {
924                        isSigned = true;
925                    }
926                }
927            }
928            if (!isSigned)
929            {
930                int count = -1;
931                foreach (string s in signedElements)
932                {
933                    count++;
934                    if(s==null)
935                    {
936                        break;
937                    }
938               
939                }
940                signedElements[count] = newElement;
941            }
942        }
943
944        public bool isSigned(string Element)
945        {
946            bool issigned = false;
947            foreach(string s in signedElements)
948            {
949                if (s != null)
950                {
951                    if (s.Equals(Element))
952                    {
953                        issigned = true;
954                    }
955                }
956            }
957            return issigned;
958        }
959
960        public void removeSignature(string Id)
961        {
962            XmlNodeList SignatureElements = securedSOAP.GetElementsByTagName("ds:Signature");
963            ArrayList list = new ArrayList();
964            XmlNode toDelete=null;
965            foreach(XmlNode node in SignatureElements)
966            {
967               
968                foreach(XmlNode child in node.FirstChild.ChildNodes)
969                {
970                if (child.Name.Equals("ds:Reference"))
971                {
972                    foreach(XmlAttribute att in child.Attributes)
973                    {
974                        if (att.Name.Equals("URI"))
975                        {
976                            if (att.Value.Equals("#" + Id))
977                            {
978                                toDelete = node;
979                            }
980                        }
981                    }
982                }
983            }
984            }
985            if (toDelete != null)
986            {
987                foreach (XmlNode node in toDelete.ChildNodes)
988                {
989                    if(node.Name.Equals("ds:Reference"))
990                    {
991                        foreach (XmlAttribute att in node.Attributes)
992                        {
993                            if (att.Name.Equals("URI"))
994                            {
995                                if (!att.Value.Equals("#" + Id))
996                                {
997                                    string[] id = att.Value.Split(new char[]{'#'});
998                                    XmlNode elem = getElementById(id[0]);
999                                    list.Add(elem);
1000                                }
1001                            }
1002                        }
1003                    }
1004                }
1005            }
1006            XmlElement[] signArray = new XmlElement[list.Count];
1007
1008            for (int i = 0; i < list.Count; i++)
1009            {
1010                signArray[i] = (XmlElement)list[i];
1011            }
1012
1013            if (toDelete != null)
1014            {
1015                securedSOAP.GetElementsByTagName("wsse:Security")[0].RemoveChild(toDelete);
1016            }
1017
1018            if (signArray.Length > 0)
1019            {
1020                signElements(signArray);
1021            }
1022            showsecuredSoap();
1023        }
1024
1025        public void encElements(XmlElement[] elements)
1026        {
1027            if (gotKey)
1028            {
1029                bool content = encset.content;
1030                XmlNode secHeader = this.securedSOAP.GetElementsByTagName("wsse:Security")[0];
1031                if (secHeader == null)
1032                {
1033                    hadHeader = false;
1034                    XmlNode head = this.securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
1035
1036                    string wssenamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
1037
1038                    secHeader = this.securedSOAP.CreateElement("wsse", "Security", wssenamespace);
1039
1040                    head.AppendChild(secHeader);
1041                    XmlNode env = this.securedSOAP.GetElementsByTagName("s:Envelope")[0];
1042                    XmlNode soapbody = this.securedSOAP.GetElementsByTagName("s:Body")[0];
1043                    env.InsertBefore(head, soapbody);
1044                }
1045                else
1046                {
1047                    hadHeader = true;
1048                }
1049                RijndaelManaged sessionKey = new RijndaelManaged();
1050                sessionKey.KeySize = 256;
1051
1052
1053                EncryptedXml encXML = new EncryptedXml();
1054
1055                EncryptedKey ek = new EncryptedKey();
1056
1057                byte[] encryptedKey = EncryptedXml.EncryptKey(sessionKey.Key, wsRSACryptoProv, false);
1058                ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);
1059                ek.CipherData = new CipherData(encryptedKey);
1060                //ek.KeyInfo = new KeyInfo();
1061
1062                KeyInfoName name = new KeyInfoName();
1063                name.Value = "Web Service Public Key";
1064                ek.KeyInfo.AddClause(name);
1065
1066                foreach (XmlElement elem in elements)
1067                {
1068                    if (elem != null)
1069                    {
1070                        //Check if Security Header or Body. Only content encryption is allowed by WS-Security
1071                        if (elem.Name.Equals("s:Body") || elem.Name.Equals("wsse:Security"))
1072                        {
1073                            if (content == false)
1074                            {
1075                                createErrorMessage("Only the content of the  "+elem.Name+" element can be encrypted");
1076                            }
1077                            content = true;
1078                        }
1079                        lastSessionKey = Convert.ToBase64String(sessionKey.Key);
1080                        byte[] encryptedElement = encXML.EncryptData(elem, sessionKey, content);
1081                        EncryptedData encElement = new EncryptedData();
1082                        DataReference ekRef = new DataReference();
1083                        if (!content)
1084                        {
1085                            encElement.Type = EncryptedXml.XmlEncElementUrl;
1086                            encElement.Id = idTable[elem.Name].ToString();
1087                            ekRef.Uri = "#" + idTable[elem.Name].ToString();
1088                        }
1089                        else
1090                        {
1091                            encElement.Type = EncryptedXml.XmlEncElementContentUrl;
1092                            addIdToElement(contentCounter+elem.Name);
1093                            encElement.Id = idTable[contentCounter+elem.Name].ToString();
1094                            ekRef.Uri = "#" + idTable[contentCounter+elem.Name].ToString();
1095                            contentCounter++;
1096                            mySettings.contentcounter = contentCounter;
1097                        }
1098                       
1099                        encElement.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
1100                        encElement.CipherData.CipherValue = encryptedElement;
1101                       
1102                       
1103                        ek.AddReference(ekRef);
1104                        string s = securedSOAP.GetElementsByTagName(elem.Name)[0].ParentNode.Name;
1105
1106                        if (!content)
1107                        {
1108                            securedSOAP.GetElementsByTagName(s)[0].ReplaceChild(securedSOAP.ImportNode(encElement.GetXml(), true), securedSOAP.GetElementsByTagName(elem.Name)[0]);
1109                        }
1110                        else
1111                        {
1112                            securedSOAP.GetElementsByTagName(elem.Name)[0].RemoveAll();
1113                            securedSOAP.GetElementsByTagName(elem.Name)[0].AppendChild(securedSOAP.ImportNode(encElement.GetXml(), true));
1114                        }
1115                        if (elem.Name.Equals("s:Body"))
1116                        {
1117                            bodyEncrypted = true;
1118                            mySettings.bodyencrypted = true;
1119                        }
1120                        if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1121                        {
1122                            methodNameEncrypted = true;
1123                            mySettings.methodnameencrypted = methodNameEncrypted;
1124                        }
1125                        if (elem.Name.Equals("wsse:Security"))
1126                        {
1127                            secHeaderEnc = true;
1128                            mySettings.secheaderEnc = true;
1129                        }
1130                    }
1131
1132                }
1133                secHeader.InsertBefore(securedSOAP.ImportNode(ek.GetXml(), true), secHeader.ChildNodes[0]);
1134                prefixesToEncryptedElement();
1135       
1136                mySettings.securedsoap = xmlToString(securedSOAP);
1137            }
1138            else
1139            {
1140                createErrorMessage("No key for encryption available");
1141            }
1142        }
1143
1144        private void prefixesToEncryptedElement()
1145        {
1146            XmlNodeList encKeyElems = securedSOAP.GetElementsByTagName("EncryptedKey");
1147            foreach (XmlNode child in encKeyElems)
1148            {
1149                addPrefixesToNodeAndChildNode("xenc", child);
1150            }
1151            XmlNodeList encDataElemns = securedSOAP.GetElementsByTagName("EncryptedData");
1152            foreach(XmlNode child in encDataElemns)
1153            {
1154                addPrefixesToNodeAndChildNode("xenc", child);
1155            }
1156        }
1157
1158        private void addPrefixesToNodeAndChildNode(string prefix ,XmlNode node)
1159        {
1160            if(node.Name.Equals("KeyInfo"))
1161        {
1162            node.Prefix = "ds";
1163            prefix = "ds";
1164        }
1165            else
1166        {
1167            node.Prefix = prefix;
1168        }
1169            foreach (XmlNode child in node.ChildNodes)
1170            {
1171                addPrefixesToNodeAndChildNode(prefix, child);
1172            }
1173        }
1174
1175        public void decrypt()
1176        {
1177            XmlElement securityHeader = (XmlElement)securedSOAP.GetElementsByTagName("Security")[0];
1178            XmlElement encKeyXml = (XmlElement) securedSOAP.GetElementsByTagName("EncryptedKey")[0];
1179            XmlElement encData = (XmlElement)securedSOAP.GetElementsByTagName("EncryptedData")[0];
1180            XmlElement KeyInfo = securedSOAP.CreateElement("KeyInfo",SignedXml.XmlDsigNamespaceUrl);
1181
1182            securityHeader.RemoveChild(encKeyXml);
1183            KeyInfo.AppendChild(encKeyXml);
1184
1185            encData.InsertAfter(KeyInfo, encData.GetElementsByTagName("EncryptionMethod")[0]);
1186            this.showsecuredSoap();
1187            EncryptedXml encXml = new EncryptedXml(this.securedSOAP);
1188            encXml.AddKeyNameMapping("RSA-Key", rsaKey);
1189            encXml.DecryptDocument();
1190        }
1191       
1192        public void signElements(XmlElement[] elements)
1193        { 
1194                String sigAlgo = sigset.sigAlg;
1195                XmlNode secHeader = securedSOAP.GetElementsByTagName("Security")[0];
1196                if (secHeader == null)
1197                {
1198                    XmlNode head = securedSOAP.CreateElement("s","Header", "http://www.w3.org/2003/05/soap-envelope");
1199
1200                    string wssenamespace = "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd";
1201
1202                    secHeader = securedSOAP.CreateElement("Security", wssenamespace);
1203
1204                    head.AppendChild(secHeader);
1205                    XmlNode env = securedSOAP.GetElementsByTagName("Envelope")[0];
1206                    XmlNode soapbody = securedSOAP.GetElementsByTagName("Body")[0];
1207                    env.InsertBefore(head, soapbody);
1208                }
1209                SignedXml signedXML = new SignedXml(this.securedSOAP);
1210                foreach (XmlElement elem in elements)
1211                {
1212                    XmlAttribute idAttribute = securedSOAP.CreateAttribute("Id");
1213                    idAttribute.Value = idTable[elem.Name].ToString();
1214                    elem.Attributes.Append(idAttribute);
1215                    XmlAttributeCollection attributes = elem.Attributes;
1216                    XmlAttribute id = attributes["Id"];
1217                    Reference reference = new Reference("#" + id.Value);
1218                    //   Reference reference = new Reference("");
1219                    XmlElement xpathElement = securedSOAP.CreateElement("XPath");
1220                    string Xpath = "ancestor-or-self::Body";
1221                    XmlElement root = this.securedSOAP.DocumentElement;
1222                    XmlElement b = (XmlElement)securedSOAP.GetElementsByTagName("Body")[0];
1223                    XmlNamespaceManager manager = new XmlNamespaceManager(securedSOAP.NameTable);
1224
1225                    manager.AddNamespace("s", b.NamespaceURI);
1226                    xpathElement.InnerText = Xpath;
1227                    XmlDsigXPathTransform xpathTrans = new XmlDsigXPathTransform();
1228                    XmlNodeList list = root.SelectNodes("/s:Envelope/s:Body", manager);
1229                    XmlNodeList list2 = root.SelectNodes("//. | //@* | //namespace::*");
1230                    xpathTrans.LoadInnerXml(xpathElement.SelectNodes("."));
1231                    XmlDsigExcC14NTransform trans = new XmlDsigExcC14NTransform();
1232                    reference.AddTransform(trans);
1233                    XmlElement boo = xpathTrans.GetXml();
1234                    Type xmlDocumentType = typeof(System.Xml.XmlDocument);
1235
1236                    signedXML.AddReference(reference);
1237                    if (elem.Name.Equals("s:Body"))
1238                    {
1239                        bodySigned = true;
1240                        mySettings.bodysigned = true;
1241                    }
1242                    if (elem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1243                    {
1244                        methodNameSigned = true;
1245                        mySettings.methodnameSigned = true;
1246                    }
1247
1248                }
1249                if (sigAlgo.Equals("1"))
1250                {
1251                    CspParameters parameter = new CspParameters();
1252
1253                    parameter.KeyContainerName = "Container";
1254                    RSACryptoServiceProvider provider = new RSACryptoServiceProvider(parameter);
1255                    signedXML.SigningKey = provider;
1256                    signedXML.ComputeSignature();
1257
1258                    KeyInfo keyInfo = new KeyInfo();
1259                    keyInfo.AddClause(new RSAKeyValue(provider));
1260                    signedXML.KeyInfo = keyInfo;
1261                    Reference t = (Reference)signedXML.SignedInfo.References[0];
1262                    IEnumerator enumerator = t.TransformChain.GetEnumerator();
1263                    enumerator.MoveNext();
1264                    XmlElement root = (XmlElement)this.securedSOAP.GetElementsByTagName("Envelope")[0];
1265                    Transform tran = (Transform)enumerator.Current;
1266                    XmlNodeList list2 = root.SelectNodes("//. | //@* | //namespace::*");
1267
1268                }
1269                if (sigAlgo.Equals("0"))
1270                {
1271                    DSA dsa = DSA.Create();
1272                    dsa.ToXmlString(false);
1273                    signedXML.SigningKey = dsa;
1274                    signedXML.ComputeSignature();
1275                }
1276
1277                XmlElement signaturElement = signedXML.GetXml();
1278                secHeader.InsertBefore(securedSOAP.ImportNode(signaturElement, true),secHeader.ChildNodes[0]);
1279           
1280        } 
1281
1282        public bool checkSecurityHeader()
1283        {
1284            bool securityheader = false;
1285            XmlNodeList list = securedSOAP.GetElementsByTagName("wsse:Security");
1286            if (!(list.Count == 0))
1287            {
1288                securityheader = true;
1289            }
1290            return securityheader;
1291        }
1292
1293        public void createSecurityHeaderAndSoapHeader()
1294        {
1295            if (!checkSecurityHeader()) 
1296            {
1297                XmlElement env= (XmlElement) securedSOAP.GetElementsByTagName("s:Envelope")[0];
1298                XmlElement Header = securedSOAP.CreateElement("s", "Header", "http://www.w3.org/2001/12/soap-envelope");
1299                XmlElement secHead = securedSOAP.CreateElement("wsse", "Security", "http://docs.oasis-open.org/wss/2004/01/oasis -200401-wss-wssecurity-secext-1.0.xsd");
1300                env.InsertBefore(Header,env.FirstChild);
1301                Header.AppendChild(secHead);
1302                mySettings.securedsoap = xmlToString(securedSOAP);
1303            }
1304        }
1305
1306        private string getXPathValue(XmlElement elem)
1307        {
1308            string xPathValue = "/s:Envelope";
1309            if (elem.Name.Equals("wsse:Security"))
1310            {
1311                xPathValue = xPathValue + "/wsse:Security";
1312                return xPathValue;
1313            }
1314            xPathValue = xPathValue + "/s:Body";
1315            if (elem.Name.Equals("s:Body"))
1316            {
1317                return xPathValue;
1318            }
1319            xPathValue = xPathValue + "/" + securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name;
1320            if (elem.Name.Equals(securedSOAP.GetElementsByTagName("s:Body")[0].FirstChild.Name))
1321            {
1322                return xPathValue;
1323            }
1324            xPathValue = xPathValue + "/"+elem.Name;
1325            return xPathValue;
1326        }
1327
1328        public void createErrorMessage(string text)
1329        {
1330            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Error));
1331        }
1332
1333        public void createInfoMessage(string text)
1334        {
1335            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(text, this, NotificationLevel.Info));
1336        }
1337
1338        public void signElementsManual(XmlElement[] elementsToSign)
1339        {
1340           
1341                string dsNs = "http://www.w3.org/2000/09/xmldsig#";
1342                XmlElement Signature = securedSOAP.CreateElement("ds", "Signature", dsNs);
1343                XmlElement SignedInfo = securedSOAP.CreateElement("ds", "SignedInfo", dsNs);
1344                XmlElement CanonicalizationMethod = securedSOAP.CreateElement("ds", "CanonicalizationMethod", dsNs);
1345                XmlAttribute canMeth = securedSOAP.CreateAttribute("Algorithm");
1346                canMeth.Value = SignedXml.XmlDsigExcC14NTransformUrl;
1347                CanonicalizationMethod.Attributes.Append(canMeth);
1348                XmlElement SignatureMethod = securedSOAP.CreateElement("ds", "SignatureMethod", dsNs);
1349                XmlAttribute sigMeth = securedSOAP.CreateAttribute("Algorithm");
1350
1351                if (sigset.sigAlg.Equals("0"))
1352                {
1353                    sigMeth.Value = SignedXml.XmlDsigDSAUrl;
1354                }
1355                if (sigset.sigAlg.Equals("1"))
1356                {
1357                    sigMeth.Value = SignedXml.XmlDsigRSASHA1Url;
1358                }
1359
1360                SignatureMethod.Attributes.Append(sigMeth);
1361                XmlNode securityHead = securedSOAP.GetElementsByTagName("wsse:Security")[0];
1362                securityHead.InsertBefore(Signature,securityHead.FirstChild);
1363                Signature.AppendChild(SignedInfo);
1364                SignedInfo.AppendChild(CanonicalizationMethod);
1365                SignedInfo.AppendChild(SignatureMethod);
1366
1367                foreach (XmlElement tempElem in elementsToSign)
1368                {
1369                    addIdToElement(tempElem.Name);
1370                    XmlAttribute idAttribute = securedSOAP.CreateAttribute("Id");
1371                    idAttribute.Value = idTable[tempElem.Name].ToString();
1372                    tempElem.Attributes.Append(idAttribute);
1373                    XmlElement ReferenceElement = securedSOAP.CreateElement("ds", "Reference", dsNs);
1374                    XmlAttribute uri = securedSOAP.CreateAttribute("URI");
1375                    XmlElement Transforms = securedSOAP.CreateElement("ds", "Transforms", dsNs);
1376                    ReferenceElement.AppendChild(Transforms);
1377
1378                    if (sigset.Xpath)
1379                    {
1380                        uri.Value = "";
1381                        XmlElement xPathTransform = securedSOAP.CreateElement("ds", "Transform", dsNs);
1382                        XmlAttribute xPathTransAtt = securedSOAP.CreateAttribute("Algorithm");
1383                        xPathTransAtt.Value = SignedXml.XmlDsigXPathTransformUrl;
1384                        xPathTransform.Attributes.Append(xPathTransAtt);
1385                        XmlElement xPathValue = securedSOAP.CreateElement("ds", "XPath", dsNs);
1386                        xPathValue.InnerXml = getXPathValue(tempElem);
1387                        xPathTransform.AppendChild(xPathValue);
1388                        Transforms.AppendChild(xPathTransform);
1389                    }
1390                    else
1391                    {
1392                        uri.Value = "#" + idTable[tempElem.Name].ToString();
1393                    }
1394                    ReferenceElement.Attributes.Append(uri);
1395
1396                    XmlElement c14nTransform = securedSOAP.CreateElement("ds", "Transform", dsNs);
1397                    XmlAttribute c14Url = securedSOAP.CreateAttribute("Algorithm");
1398                    c14Url.Value = SignedXml.XmlDsigExcC14NTransformUrl;
1399                    c14nTransform.Attributes.Append(c14Url);
1400                    Transforms.AppendChild(c14nTransform);
1401                    XmlElement digestMethod = securedSOAP.CreateElement("ds", "DigestMethod", dsNs);
1402                    XmlAttribute digMethAtt = securedSOAP.CreateAttribute("Algorithm");
1403                    digMethAtt.Value = SignedXml.XmlDsigSHA1Url;
1404                    digestMethod.Attributes.Append(digMethAtt);
1405                    ReferenceElement.AppendChild(digestMethod);
1406                    XmlElement digestValue = securedSOAP.CreateElement("ds", "DigestValue", dsNs);
1407                    digestValue.InnerText = Convert.ToBase64String(getDigestValueForElement(tempElem));
1408                    ReferenceElement.AppendChild(digestValue);
1409                    SignedInfo.AppendChild(ReferenceElement);
1410                    if (tempElem.Name.Equals("s:Body"))
1411                    {
1412                        bodySigned = true;
1413                        mySettings.bodysigned = true;
1414                    }
1415                    if (tempElem.Name.Equals(soap.GetElementsByTagName("s:Body")[0].ChildNodes[0].Name))
1416                    {
1417                        methodNameSigned = true;
1418                        mySettings.methodnameSigned = true;
1419                    }
1420                    if (tempElem.Name.Equals("wsse:Security"))
1421                    {
1422                        secHeaderSigned = true;
1423                        mySettings.secheaderSigned = true;
1424                    }
1425
1426                }
1427                XmlElement SignatureValue = securedSOAP.CreateElement("ds", "SignatureValue", dsNs);
1428                KeyInfo keyInfo = new KeyInfo();
1429                if (sigset.sigAlg.Equals("1"))
1430                {
1431                    SignatureValue.InnerXml = Convert.ToBase64String(rsaCryptoProv.SignHash(getDigestValueForElement(SignedInfo), CryptoConfig.MapNameToOID("SHA1")));
1432                    keyInfo.AddClause(new RSAKeyValue(rsaCryptoProv));
1433                   
1434                }
1435                if (sigset.sigAlg.Equals("0"))
1436                {
1437                    SignatureValue.InnerXml = Convert.ToBase64String(dsaCryptoProv.SignHash(getDigestValueForElement(SignedInfo), CryptoConfig.MapNameToOID("SHA1")));
1438                    keyInfo.AddClause(new DSAKeyValue(dsaCryptoProv));
1439                }
1440                Signature.AppendChild(SignatureValue);
1441                XmlElement xmlKeyInfo = keyInfo.GetXml();
1442                xmlKeyInfo.Prefix = "ds";
1443                foreach(XmlNode childNode in xmlKeyInfo.ChildNodes)
1444                {
1445                    childNode.Prefix = "ds"; 
1446                }
1447                Signature.AppendChild(securedSOAP.ImportNode(xmlKeyInfo, true));
1448                XmlElement secHead = (XmlElement)securedSOAP.GetElementsByTagName("wsse:Security")[0];
1449                mySettings.securedsoap = xmlToString(securedSOAP);
1450        }
1451
1452        public string getIdToElement(string ElemName)
1453        {
1454            string retString = idTable[ElemName].ToString();
1455            return retString;
1456        }
1457
1458        public bool getxPathTrans()
1459        {
1460            return sigset.Xpath;
1461        }
1462
1463        public byte[] getDigestValueForElement(XmlElement elem)
1464        {
1465            Stream canonicalized = canonicalizeNodeWithExcC14n(elem);
1466            SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
1467            byte[] byteValue = sha1.ComputeHash(canonicalized);
1468            return byteValue;
1469        }
1470
1471        public Stream canonicalizeNodeWithExcC14n(XmlElement nodeToCanon)
1472        {
1473            XmlNode node = (XmlNode)nodeToCanon;
1474            XmlNodeReader reader = new XmlNodeReader(node);
1475            Stream stream = new MemoryStream();
1476            XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
1477            writer.WriteNode(reader, false);
1478            writer.Flush();
1479            stream.Position = 0;
1480            XmlDsigExcC14NTransform trans = new XmlDsigExcC14NTransform();
1481            trans.LoadInput(stream);
1482            Stream stream2 = (Stream)trans.GetOutput();
1483            return stream2;
1484        }
1485   
1486        public void showsecuredSoap()
1487        {
1488            presentation.treeView.Items.Clear();
1489            presentation.namespacesTable.Clear();
1490            this.presentation.securedSoapItem = null;
1491
1492            this.presentation.securedSoapItem = new System.Windows.Controls.TreeViewItem();
1493
1494            presentation.securedSoapItem.IsExpanded = true;
1495
1496            StackPanel panel1 = new StackPanel();
1497       
1498
1499            panel1.Orientation = System.Windows.Controls.Orientation.Horizontal;
1500
1501            TextBlock elem1 = new TextBlock();
1502            elem1.Text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"; 
1503            panel1.Children.Insert(0, elem1);
1504            presentation.securedSoapItem.Header = panel1;
1505            XmlNode rootElement = securedSOAP.SelectSingleNode("/*");
1506            this.presentation.CopyXmlToTreeView(rootElement, ref presentation.securedSoapItem);
1507            this.presentation.treeView.Items.Add(presentation.securedSoapItem);
1508        }
1509       
1510        public XmlDocument soap2
1511        {get{return this.soap;}
1512           
1513       }
1514
1515        protected void OnPropertyChanged(string name)
1516        {
1517            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
1518        }
1519
1520        public SoapSettings settings2()
1521        {
1522            return (SoapSettings) this.Settings;
1523        }
1524             
1525        #region IPlugin Member
1526
1527        public void Dispose()
1528        {
1529           
1530        }
1531
1532        public void Execute()
1533        {
1534            if (!send)
1535            {
1536                OnPropertyChanged("OutputString");
1537                send = true;
1538            }
1539        }
1540
1541        public void Initialize()
1542        {
1543           
1544        }
1545
1546        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
1547
1548        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
1549
1550        public event StatusChangedEventHandler OnPluginStatusChanged;
1551
1552        public void Pause()
1553        {
1554           
1555        }
1556
1557        public void PostExecution()
1558        {
1559           
1560        }
1561
1562        public void PreExecution()
1563        {
1564           
1565        }
1566
1567        public System.Windows.Controls.UserControl Presentation
1568        {
1569            get { return this.presentation; }
1570        }
1571
1572        public System.Windows.Controls.UserControl QuickWatchPresentation
1573        {
1574            get { return null; }
1575        }
1576
1577        public ISettings Settings
1578        {
1579            get { return (SoapSettings) this.settings; }
1580        }
1581
1582        public SoapSettings mySettings
1583        {
1584            get { return (SoapSettings)this.settings; }
1585        }
1586
1587        public void Stop()
1588        {
1589            send = false;
1590        }
1591
1592        #endregion
1593
1594        #region INotifyPropertyChanged Member
1595
1596        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
1597     
1598        #endregion
1599    }
1600}
Note: See TracBrowser for help on using the repository browser.