mcs/class/corlib/Mono.Security/ASN1.cs

   1 //
   2 // ASN1.cs: Abstract Syntax Notation 1 - micro-parser and generator
   3 //
   4 // Authors:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //      Jesper Pedersen  <jep@itplus.dk>
   7 //
   8 // (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 // (C) 2004 IT+ A/S (http://www.itplus.dk)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Collections;
  34 using System.IO;
  35 using System.Text;
  36
  37 namespace Mono.Security {
  38
  39         // References:
  40         // a.   ITU ASN.1 standards (free download)
  41         //      http://www.itu.int/ITU-T/studygroups/com17/languages/
  42
  43 #if INSIDE_CORLIB
  44         internal
  45 #else
  46         public
  47 #endif
  48         class ASN1 {
  49
  50                 private byte m_nTag;
  51                 private byte[] m_aValue;
  52                 private ArrayList elist;
  53
  54                 public ASN1 () : this (0x00, null) {}
  55
  56                 public ASN1 (byte tag) : this (tag, null) {}
  57
  58                 public ASN1 (byte tag, byte[] data)
  59                 {
  60                         m_nTag = tag;
  61                         m_aValue = data;
  62                 }
  63
  64                 public ASN1 (byte[] data)
  65                 {
  66                         m_nTag = data [0];
  67
  68                         int nLenLength = 0;
  69                         int nLength = data [1];
  70
  71                         if (nLength > 0x80) {
  72                                 // composed length
  73                                 nLenLength = nLength - 0x80;
  74                                 nLength = 0;
  75                                 for (int i = 0; i < nLenLength; i++) {
  76                                         nLength *= 256;
  77                                         nLength += data [i + 2];
  78                                 }
  79                         }
  80                         else if (nLength == 0x80) {
  81                                 // undefined length encoding
  82                                 throw new NotSupportedException ("Undefined length encoding.");
  83                         }
  84
  85                         m_aValue = new byte [nLength];
  86                         Buffer.BlockCopy (data, (2 + nLenLength), m_aValue, 0, nLength);
  87
  88                         if ((m_nTag & 0x20) == 0x20) {
  89                                 int nStart = (2 + nLenLength);
  90                                 Decode (data, ref nStart, data.Length);
  91                         }
  92                 }
  93
  94                 public int Count {
  95                         get {
  96                                 if (elist == null)
  97                                         return 0;
  98                                 return elist.Count;
  99                         }
 100                 }
 101
 102                 public byte Tag {
 103                         get { return m_nTag; }
 104                 }
 105
 106                 public int Length {
 107                         get {
 108                                 if (m_aValue != null)
 109                                         return m_aValue.Length;
 110                                 else
 111                                         return 0;
 112                         }
 113                 }
 114
 115                 public byte[] Value {
 116                         get {
 117                                 if (m_aValue == null)
 118                                         GetBytes ();
 119                                 return (byte[]) m_aValue.Clone ();
 120                         }
 121                         set {
 122                                 if (value != null)
 123                                         m_aValue = (byte[]) value.Clone ();
 124                         }
 125                 }
 126
 127                 private bool CompareArray (byte[] array1, byte[] array2)
 128                 {
 129                         bool bResult = (array1.Length == array2.Length);
 130                         if (bResult) {
 131                                 for (int i = 0; i < array1.Length; i++) {
 132                                         if (array1[i] != array2[i])
 133                                                 return false;
 134                                 }
 135                         }
 136                         return bResult;
 137                 }
 138
 139                 public bool Equals (byte[] asn1)
 140                 {
 141                         return CompareArray (this.GetBytes (), asn1);
 142                 }
 143
 144                 public bool CompareValue (byte[] value)
 145                 {
 146                         return CompareArray (m_aValue, value);
 147                 }
 148
 149                 public ASN1 Add (ASN1 asn1)
 150                 {
 151                         if (asn1 != null) {
 152                                 if (elist == null)
 153                                         elist = new ArrayList ();
 154                                 elist.Add (asn1);
 155                         }
 156                         return asn1;
 157                 }
 158
 159                 public virtual byte[] GetBytes ()
 160                 {
 161                         byte[] val = null;
 162                         if (m_aValue != null) {
 163                                 val = m_aValue;
 164                         }
 165                         else if (Count > 0) {
 166                                 int esize = 0;
 167                                 ArrayList al = new ArrayList ();
 168                                 foreach (ASN1 a in elist) {
 169                                         byte[] item = a.GetBytes ();
 170                                         al.Add (item);
 171                                         esize += item.Length;
 172                                 }
 173                                 val = new byte [esize];
 174                                 int pos = 0;
 175                                 for (int i=0; i < elist.Count; i++) {
 176                                         byte[] item = (byte[]) al[i];
 177                                         Buffer.BlockCopy (item, 0, val, pos, item.Length);
 178                                         pos += item.Length;
 179                                 }
 180                         }
 181
 182                         byte[] der;
 183                         int nLengthLen = 0;
 184
 185                         if (val != null) {
 186                                 int nLength = val.Length;
 187                                 // special for length > 127
 188                                 if (nLength > 127) {
 189                                         if (nLength <= Byte.MaxValue) {
 190                                                 der = new byte [3 + nLength];
 191                                                 Buffer.BlockCopy (val, 0, der, 3, nLength);
 192                                                 nLengthLen = 0x81;
 193                                                 der[2] = (byte)(nLength);
 194                                         }
 195                                         else if (nLength <= UInt16.MaxValue) {
 196                                                 der = new byte [4 + nLength];
 197                                                 Buffer.BlockCopy (val, 0, der, 4, nLength);
 198                                                 nLengthLen = 0x82;
 199                                                 der[2] = (byte)(nLength >> 8);
 200                                                 der[3] = (byte)(nLength);
 201                                         }
 202                                         else if (nLength <= 0xFFFFFF) {
 203                                                 // 24 bits
 204                                                 der = new byte [5 + nLength];
 205                                                 Buffer.BlockCopy (val, 0, der, 5, nLength);
 206                                                 nLengthLen = 0x83;
 207                                                 der [2] = (byte)(nLength >> 16);
 208                                                 der [3] = (byte)(nLength >> 8);
 209                                                 der [4] = (byte)(nLength);
 210                                         }
 211                                         else {
 212                                                 // max (Length is an integer) 32 bits
 213                                                 der = new byte [6 + nLength];
 214                                                 Buffer.BlockCopy (val, 0, der, 6, nLength);
 215                                                 nLengthLen = 0x84;
 216                                                 der [2] = (byte)(nLength >> 24);
 217                                                 der [3] = (byte)(nLength >> 16);
 218                                                 der [4] = (byte)(nLength >> 8);
 219                                                 der [5] = (byte)(nLength);
 220                                         }
 221                                 }
 222                                 else {
 223                                         // basic case (no encoding)
 224                                         der = new byte [2 + nLength];
 225                                         Buffer.BlockCopy (val, 0, der, 2, nLength);
 226                                         nLengthLen = nLength;
 227                                 }
 228                                 if (m_aValue == null)
 229                                         m_aValue = val;
 230                         }
 231                         else
 232                                 der = new byte[2];
 233
 234                         der[0] = m_nTag;
 235                         der[1] = (byte)nLengthLen;
 236
 237                         return der;
 238                 }
 239
 240                 // Note: Recursive
 241                 protected void Decode (byte[] asn1, ref int anPos, int anLength)
 242                 {
 243                         byte nTag;
 244                         int nLength;
 245                         byte[] aValue;
 246
 247                         // minimum is 2 bytes (tag + length of 0)
 248                         while (anPos < anLength - 1) {
 249                                 int nPosOri = anPos;
 250                                 DecodeTLV (asn1, ref anPos, out nTag, out nLength, out aValue);
 251
 252                                 ASN1 elm = Add (new ASN1 (nTag, aValue));
 253
 254                                 if ((nTag & 0x20) == 0x20) {
 255                                         int nConstructedPos = anPos;
 256                                         elm.Decode (asn1, ref nConstructedPos, nConstructedPos + nLength);
 257                                 }
 258                                 anPos += nLength; // value length
 259                         }
 260                 }
 261
 262                 // TLV : Tag - Length - Value
 263                 protected void DecodeTLV (byte[] asn1, ref int pos, out byte tag, out int length, out byte[] content)
 264                 {
 265                         tag = asn1 [pos++];
 266                         length = asn1 [pos++];
 267
 268                         // special case where L contains the Length of the Length + 0x80
 269                         if ((length & 0x80) == 0x80) {
 270                                 int nLengthLen = length & 0x7F;
 271                                 length = 0;
 272                                 for (int i = 0; i < nLengthLen; i++)
 273                                         length = length * 256 + asn1 [pos++];
 274                         }
 275
 276                         content = new byte [length];
 277                         Buffer.BlockCopy (asn1, pos, content, 0, length);
 278                 }
 279
 280                 public ASN1 this [int index] {
 281                         get {
 282                                 try {
 283                                         if ((elist == null) || (index >= elist.Count))
 284                                                 return null;
 285                                         return (ASN1) elist [index];
 286                                 }
 287                                 catch (ArgumentOutOfRangeException) {
 288                                         return null;
 289                                 }
 290                         }
 291                 }
 292
 293                 public ASN1 Element (int index, byte anTag)
 294                 {
 295                         try {
 296                                 if ((elist == null) || (index >= elist.Count))
 297                                         return null;
 298
 299                                 ASN1 elm = (ASN1) elist [index];
 300                                 if (elm.Tag == anTag)
 301                                         return elm;
 302                                 else
 303                                         return null;
 304                         }
 305                         catch (ArgumentOutOfRangeException) {
 306                                 return null;
 307                         }
 308                 }
 309
 310                 public override string ToString()
 311                 {
 312                         StringBuilder hexLine = new StringBuilder ();
 313
 314                         // Add tag
 315                         hexLine.AppendFormat ("Tag: {0} {1}", m_nTag.ToString ("X2"), Environment.NewLine);
 316
 317                         // Add length
 318                         hexLine.AppendFormat ("Length: {0} {1}", Value.Length, Environment.NewLine);
 319
 320                         // Add value
 321                         hexLine.Append ("Value: ");
 322                         hexLine.Append (Environment.NewLine);
 323                         for (int i = 0; i < Value.Length; i++) {
 324                                 hexLine.AppendFormat ("{0} ", Value [i].ToString ("X2"));
 325                                 if ((i+1) % 16 == 0)
 326                                         hexLine.AppendFormat (Environment.NewLine);
 327                         }
 328                         return hexLine.ToString ();
 329                 }
 330
 331                 public void SaveToFile (string filename)
 332                 {
 333                         if (filename == null)
 334                                 throw new ArgumentNullException ("filename");
 335
 336                         using (FileStream fs = File.OpenWrite (filename)) {
 337                                 byte[] data = GetBytes ();
 338                                 fs.Write (data, 0, data.Length);
 339                                 fs.Flush ();
 340                                 fs.Close ();
 341                         }
 342                 }
 343         }
 344 }