New test.

[mono.git] / mcs / class / System.Web / System.Web.Configuration / MachineKeyConfig.cs

diff --git a/mcs/class/System.Web/System.Web.Configuration/MachineKeyConfig.cs b/mcs/class/System.Web/System.Web.Configuration/MachineKeyConfig.cs
index 50e066515a1e4b5f0e4e8e87a5d8d8b8f1b32f25..b60fca55746633275fde707d833d97448c560196 100644 (file)
--- a/mcs/class/System.Web/System.Web.Configuration/MachineKeyConfig.cs
+++ b/mcs/class/System.Web/System.Web.Configuration/MachineKeyConfig.cs
@@ -5,6 +5,7 @@
 //     Gonzalo Paniagua Javier (gonzalo@ximian.com)
 //
 // (C) 2002 Ximian, Inc (http://www.ximian.com)
+// Copyright (c) 2005 Novell, Inc (http://www.novell.com)
 //
 
 //
@@ -32,55 +33,120 @@ using System;
 using System.Collections;
 using System.Configuration;
 using System.Xml;
+using System.Security.Cryptography;
 
 namespace System.Web.Configuration
 {
        class MachineKeyConfig
        {
-               static MachineKeyConfig machineKey;
-               byte [] validationKey;
-               byte [] decryptionKey;
-               string validationType;
+               byte [] validation_key;
+               //bool    isolate_validation;
+               byte [] decryption_key;
+               byte [] decryption_key_192bits;
+               //bool    isolate_decryption; // For us, this is always true by now.
+               MachineKeyValidation validation_type;
 
+               static byte [] autogenerated;
+               static byte [] autogenerated_decrypt;
+               
+               static MachineKeyConfig ()
+               {
+                       autogenerated = new byte [64];
+                       RandomNumberGenerator rng = RandomNumberGenerator.Create ();
+                       rng.GetBytes (autogenerated);
+                       autogenerated_decrypt = new byte [64];
+                       rng.GetBytes (autogenerated_decrypt);
+               }
+               
                internal MachineKeyConfig (object parent)
                {
                        if (parent is MachineKeyConfig) {
                                MachineKeyConfig p = (MachineKeyConfig) parent;
-                               validationKey = p.validationKey;
-                               decryptionKey = p.decryptionKey;
-                               validationType = p.validationType;
+                               validation_key = p.validation_key;
+                               decryption_key = p.decryption_key;
+                               validation_type = p.validation_type;
                        }
                }
 
+               static byte ToHexValue (char c, bool high)
+               {
+                       byte v;
+                       if (c >= '0' && c <= '9')
+                               v = (byte) (c - '0');
+                       else if (c >= 'a' && c <= 'f')
+                               v = (byte) (c - 'a' + 10);
+                       else if (c >= 'A' && c <= 'F')
+                               v = (byte) (c - 'A' + 10);
+                       else
+                               throw new ArgumentException ("Invalid hex character");
+
+                       if (high)
+                               v <<= 4;
+
+                       return v;
+               }
+               
+               internal static byte [] GetBytes (string key, int len)
+               {
+                       byte [] result = new byte [len / 2];
+                       for (int i = 0; i < len; i += 2)
+                               result [i / 2] = (byte) (ToHexValue (key [i], true) + ToHexValue (key [i + 1], false));
+
+                       return result;
+               }
+
+               static byte [] MakeKey (string key, bool decryption) //, out bool isolate)
+               {
+                       if (key == null || key.StartsWith ("AutoGenerate")){
+                               //isolate = key.IndexOf ("IsolateApps") != 1;
+
+                               return (decryption) ? autogenerated_decrypt : autogenerated;
+                       }
+
+                       //isolate = false;
+
+                       int len = key.Length;
+                       if (len < 40 || len > 128 || (len % 2) == 1)
+                               throw new ArgumentException ("Invalid key length");
+
+                       return GetBytes (key, len);
+               }
+               
+               internal void SetValidationKey (string n)
+               {
+                       validation_key = MakeKey (n, false); //, out isolate_validation);
+               }
+               
                internal byte [] ValidationKey {
-                       get { return validationKey; }
-                       set { validationKey = value; }
+                       get { return validation_key; }
                }
 
+               internal void SetDecryptionKey (string n)
+               {
+                       decryption_key = MakeKey (n, true); //, out isolate_decryption);
+                       decryption_key_192bits = new byte [24];
+                       int count = 24;
+                       if (decryption_key.Length < 24)
+                               count = decryption_key.Length;
+                       Buffer.BlockCopy (decryption_key, 0, decryption_key_192bits, 0, count);
+               }
+               
                internal byte [] DecryptionKey {
-                       get { return decryptionKey; }
-                       set { decryptionKey = value; }
+                       get { return decryption_key; }
                }
 
-               internal string ValidationType {
-                       get {
-                               if (validationType == null)
-                                       validationType = "SHA1";
+               internal byte [] DecryptionKey192Bits {
+                       get { return decryption_key_192bits; }
+               }
 
-                               return validationType;
+               internal MachineKeyValidation ValidationType {
+                       get {
+                               return validation_type;
                        }
                        set {
-                               if (value == null)
-                                       return;
-
-                               validationType = value;
+                               validation_type = value;
                        }
                }
-
-               internal static MachineKeyConfig MachineKey {
-                       get { return machineKey; }
-                       set { machineKey = value; }
-               }
        }
 }