context: //
  // Unit tests for MachineKeySectionUtils (internals)
  //
  // Author:
  //	Sebastien Pouliot  <sebastien@ximian.com>
  //
  // Copyright (C) 2010 Novell, Inc (http://www.novell.com)
  //
  // Permission is hereby granted, free of charge, to any person obtaining
  // a copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to
  // permit persons to whom the Software is furnished to do so, subject to
  // the following conditions:
  // 
  // The above copyright notice and this permission notice shall be
  // included in all copies or substantial portions of the Software.
  // 
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  //
  
  using System;
  using System.IO;
  using System.Web.Configuration;
  using System.Web.Util;
  using NUnit.Framework;
  
  namespace MonoTests.System.Web.Util {
  
  	[TestFixture]
  	public class MachineKeySectionUtilsTest {
  
  		static byte ChangeByte (byte b)
  		{
  			return (b == Byte.MaxValue) ? Byte.MinValue : (byte) (b + 1);
  		}
  
  		public void Encrypt_RoundTrip (MachineKeySection section)
  		{
  			byte [] data = new byte [14];
  			byte [] encdata = MachineKeySectionUtils.Encrypt (section, data);
  			byte [] decdata = MachineKeySectionUtils.Decrypt (section, encdata);
  			Assert.AreEqual (data, decdata, "roundtrip");
  
  			// changing length (missing first byte)
  			byte [] cut = new byte [encdata.Length - 1];
  			Array.Copy (encdata, 1, cut, 0, cut.Length);
  			Assert.IsNull (MachineKeySectionUtils.Decrypt (section, cut), "bad length");
  
  			// changing last byte (padding)
  			byte be = encdata [encdata.Length - 1];
  			encdata [encdata.Length - 1] = ChangeByte (be);
  			byte[] result = MachineKeySectionUtils.Decrypt (section, encdata);
  			// this will return null if a bad padding is detected - OTOH since we're using a random key and we
  			// encrypt a random IV it's possible the decrypted stuff will randomly have a "valid" padding (there's
  			// only so much possible values and the bots runs those tests pretty often and give false positive)
  			// To avoid this we fallback to ensure the data is invalid (if should be empty)
  			int total = 0;
  			if (result != null) {
  				for (int i=0; i < result.Length; i++)
  					total += result [i];
  			}
  			Assert.IsTrue (result == null || total != 0, "bad padding");
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_Default ()
  		{
  			Encrypt_RoundTrip (new MachineKeySection ());
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_AES ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.AES;
  			Encrypt_RoundTrip (section);
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_TripleDES ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.TripleDES;
  			Encrypt_RoundTrip (section);
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_MD5 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.MD5;
  			Encrypt_RoundTrip (section);
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_SHA1 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.SHA1;
  			Encrypt_RoundTrip (section);
  		}
  #if NET_4_0
  		[Test]
  		public void Encrypt_RoundTrip_HMACSHA256 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.HMACSHA256;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_HMACSHA384 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.HMACSHA384;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_HMACSHA512 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.HMACSHA512;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void Encrypt_RoundTrip_Custom_RIPEMD160 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.ValidationAlgorithm = "alg:HMACRIPEMD160";
  			EncryptSign_RoundTrip (section);
  		}
  #endif
  		public void EncryptSign_RoundTrip (MachineKeySection section)
  		{
  			byte [] data = new byte [14];
  			byte [] block = MachineKeySectionUtils.EncryptSign (section, data);
  			byte [] decdata = MachineKeySectionUtils.VerifyDecrypt (section, block);
  			Assert.AreEqual (data, decdata, "roundtrip");
  
  			// changing a byte of the data
  			byte b0 = block [0];
  			block [0] = ChangeByte (b0);
  			Assert.IsNull (MachineKeySectionUtils.VerifyDecrypt (section, block), "bad data");
  			block [0] = b0;
  
  			// changing a byte of the signature
  			byte be = block [block.Length - 1];
  			block [block.Length - 1] = ChangeByte (be);
  			Assert.IsNull (MachineKeySectionUtils.VerifyDecrypt (section, block), "bad signature");
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_Default ()
  		{
  			EncryptSign_RoundTrip (new MachineKeySection ());
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_AES ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.AES;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_TripleDES ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.TripleDES;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_MD5 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.MD5;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_SHA1 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.SHA1;
  			EncryptSign_RoundTrip (section);
  		}
  #if NET_4_0
  		[Test]
  		public void EncryptSign_RoundTrip_HMACSHA256 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.HMACSHA256;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_HMACSHA384 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.HMACSHA384;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_HMACSHA512 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.HMACSHA512;
  			EncryptSign_RoundTrip (section);
  		}
  
  		[Test]
  		public void EncryptSign_RoundTrip_Custom_RIPEMD160 ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.ValidationAlgorithm = "alg:HMACRIPEMD160";
  			EncryptSign_RoundTrip (section);
  		}
  #endif
  		public void Validation_RoundTrip (MachineKeySection section)
  		{
  			byte [] data = new byte [] { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };
  			byte [] block = MachineKeySectionUtils.Sign (section, data);
  			Assert.AreEqual (data, MachineKeySectionUtils.Verify (section, block), "OK");
  
  			// changing last byte
  			for (int i = 0; i < data.Length; i++) {
  				byte b = block [i];
  				block [i] = ChangeByte (b);
  				Assert.IsNull (MachineKeySectionUtils.Verify (section, block), "bad-" + i.ToString ());
  				block [i] = b;
  			}
  		}
  
  		[Test]
  		public void Validation_RoundTrip_Default ()
  		{
  			Validation_RoundTrip (new MachineKeySection ());
  		}
  
  		[Test]
  		public void Validation_RoundTrip_AES ()
  		{
  			MachineKeySection section = new MachineKeySection ();
  			section.Validation = MachineKeyValidation.AES;
  			Validation_RoundTrip (section);
  		}
  
  		[Test]
  		public void Validation_RoundTrip_TripleDES ()
  		{
  
gt: 			MachineKeySection section = new MachineKeySection ();