mcs/class/System.Security/System.Security.Cryptography.Xml/XmlDsigEnvelopedSignatureTransform.cs

   1 //
   2 // XmlDsigEnvelopedSignatureTransform.cs -
   3 //      Enveloped Signature Transform implementation for XML Signature
   4 //
   5 // Author:
   6 //      Sebastien Pouliot (spouliot@motus.com)
   7 //      Atsushi Enomoto (atsushi@ximian.com)
   8 //
   9 // (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
  10 // (C) 2004 Novell Inc.
  11 //
  12
  13 using System.Collections;
  14 using System.IO;
  15 using System.Xml;
  16
  17 namespace System.Security.Cryptography.Xml {
  18
  19         [MonoTODO]
  20         public class XmlDsigEnvelopedSignatureTransform : Transform {
  21
  22                 private Type[] input;
  23                 private Type[] output;
  24                 private bool comments;
  25                 private object inputObj;
  26
  27                 public XmlDsigEnvelopedSignatureTransform ()
  28                 {
  29                         Algorithm = "http://www.w3.org/2000/09/xmldsig#enveloped-signature";
  30                         comments = false;
  31                 }
  32
  33                 public XmlDsigEnvelopedSignatureTransform (bool includeComments)
  34                 {
  35                         comments = includeComments;
  36                 }
  37
  38                 public override Type[] InputTypes {
  39                         get {
  40                                 if (input == null) {
  41                                         lock (this) {
  42                                                 // this way the result is cached if called multiple time
  43                                                 input = new Type [3];
  44                                                 input[0] = typeof (System.IO.Stream);
  45                                                 input[1] = typeof (System.Xml.XmlDocument);
  46                                                 input[2] = typeof (System.Xml.XmlNodeList);
  47                                         }
  48                                 }
  49                                 return input;
  50                         }
  51                 }
  52
  53                 public override Type[] OutputTypes {
  54                         get {
  55                                 if (output == null) {
  56                                         lock (this) {
  57                                                 // this way the result is cached if called multiple time
  58                                                 output = new Type [2];
  59                                                 input[0] = typeof (System.Xml.XmlDocument);
  60                                                 input[1] = typeof (System.Xml.XmlNodeList);
  61                                         }
  62                                 }
  63                                 return output;
  64                         }
  65                 }
  66
  67                 protected override XmlNodeList GetInnerXml ()
  68                 {
  69                         return null; // THIS IS DOCUMENTED AS SUCH
  70                 }
  71
  72                 [MonoTODO ("Is it really spec-compliant??")]
  73                 public override object GetOutput ()
  74                 {
  75                         XmlDocument doc = null;
  76
  77                         // possible input: Stream, XmlDocument, and XmlNodeList
  78                         if (inputObj is Stream) {
  79                                 doc = new XmlDocument ();
  80                                 doc.PreserveWhitespace = true;
  81                                 doc.XmlResolver = GetResolver ();
  82                                 doc.Load (inputObj as Stream);
  83                                 return GetOutputFromNode (doc, GetNamespaceManager (doc), true);
  84                         }
  85                         else if (inputObj is XmlDocument) {
  86                                 doc = inputObj as XmlDocument;
  87                                 return GetOutputFromNode (doc, GetNamespaceManager (doc), true);
  88                         }
  89                         else if (inputObj is XmlNodeList) {
  90                                 ArrayList al = new ArrayList ();
  91                                 XmlNodeList nl = (XmlNodeList) inputObj;
  92                                 if (nl.Count > 0) {
  93                                         XmlNamespaceManager m = GetNamespaceManager (nl.Item (0));
  94                                         ArrayList tmp = new ArrayList ();
  95                                         foreach (XmlNode n in nl)
  96                                                 tmp.Add (n);
  97                                         foreach (XmlNode n in tmp)
  98                                                 if (n.SelectNodes ("ancestor-or-self::dsig:Signature", m).Count == 0)
  99                                                         al.Add (GetOutputFromNode (n, m, false));
 100                                 }
 101                                 return new XmlDsigNodeList (al);
 102                         }
 103                         // Note that it is unexpected behavior with related to InputTypes (MS.NET accepts XmlElement)
 104                         else if (inputObj is XmlElement) {
 105                                 XmlElement el = inputObj as XmlElement;
 106                                 XmlNamespaceManager m = GetNamespaceManager (el);
 107                                 if (el.SelectNodes ("ancestor-or-self::dsig:Signature", m).Count == 0)
 108                                         return GetOutputFromNode (el, m, true);
 109                         }
 110
 111                         throw new NullReferenceException ();
 112                 }
 113
 114                 private XmlNamespaceManager GetNamespaceManager (XmlNode n)
 115                 {
 116                         XmlDocument doc = n is XmlDocument ? n as XmlDocument : n.OwnerDocument;
 117                         XmlNamespaceManager nsmgr = new XmlNamespaceManager (doc.NameTable);
 118                         nsmgr.AddNamespace ("dsig", XmlSignature.NamespaceURI);
 119                         return nsmgr;
 120                 }
 121
 122                 private XmlNode GetOutputFromNode (XmlNode input, XmlNamespaceManager nsmgr, bool remove)
 123                 {
 124                         XmlDocument doc = input is XmlDocument ? input as XmlDocument : input.OwnerDocument;
 125                         if (remove) {
 126                                 XmlNodeList nl = input.SelectNodes ("descendant-or-self::dsig:Signature", nsmgr);
 127                                 foreach (XmlNode n in nl)
 128                                         n.ParentNode.RemoveChild (n);
 129                         }
 130                         return input;
 131                 }
 132
 133                 public override object GetOutput (Type type)
 134                 {
 135                         if (type == Type.GetType ("Stream"))
 136                                 return GetOutput ();
 137                         throw new ArgumentException ("type");
 138                 }
 139
 140                 public override void LoadInnerXml (XmlNodeList nodeList)
 141                 {
 142                         // NO CHANGE
 143                 }
 144
 145                 [MonoTODO ("test")]
 146                 public override void LoadInput (object obj)
 147                 {
 148                         inputObj = obj;
 149                 }
 150         }
 151 }