Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / xsp / System / Web / Configuration / MachineKeySection.cs / 6 / MachineKeySection.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.Configuration
{
using System;
using System.Xml;
using System.Configuration;
using System.Collections.Specialized;
using System.Collections;
using System.IO;
using System.Text;
using System.Security.Cryptography;
using System.Web.Util;
using System.Globalization;
using System.Web.Hosting;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Security.Permissions;
/*
= s_validationKey.Length) {
// Buffer.BlockCopy(s_validationKey, 0, buf, start + length, s_validationKey.Length);
// byte[] computedHash = md5.ComputeHash(buf, start, length + s_validationKey.Length);
//
// // Cleanup validation key from buf
// for (int i = (start + length); i < (start + length + s_validationKey.Length); i++) {
// buf[i] = 0;
// }
//
// return computedHash;
// }
// }
byte[] bAll = new byte[totalLength];
Buffer.BlockCopy(buf, start, bAll, 0, length);
if (modifier != null)
{
Buffer.BlockCopy(modifier, 0, bAll, length, modifier.Length);
length += modifier.Length;
}
Buffer.BlockCopy(s_validationKey, 0, bAll, length, s_validationKey.Length);
return md5.ComputeHash(bAll);
}
private static void SetInnerOuterKeys(byte[] validationKey) {
byte[] key = null;
if (validationKey.Length > BLOCK_SIZE) {
key = new byte[HASH_SIZE];
int hr = UnsafeNativeMethods.GetSHA1Hash(validationKey, validationKey.Length, key, key.Length);
Marshal.ThrowExceptionForHR(hr);
}
if (s_inner == null)
s_inner = new byte[BLOCK_SIZE];
if (s_outer == null)
s_outer = new byte[BLOCK_SIZE];
int i;
for (i=0; i < BLOCK_SIZE; i++) {
s_inner[i] = 0x36;
s_outer[i] = 0x5C;
}
for (i=0; i < validationKey.Length; i++) {
s_inner[i] ^= validationKey[i];
s_outer[i] ^= validationKey[i];
}
}
private static byte[] GetHMACSHA1Hash(byte[] buf, byte[] modifier, int start, int length) {
if (length < 0 || buf == null || length > buf.Length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "length"));
if (start < 0 || start >= length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "start"));
byte[] buffer = new byte[HASH_SIZE];
int hr = UnsafeNativeMethods.GetHMACSHA1Hash(buf, start, length,
modifier, (modifier == null) ? 0 : modifier.Length,
s_inner, s_inner.Length, s_outer, s_outer.Length,
buffer, buffer.Length);
Marshal.ThrowExceptionForHR(hr);
return buffer;
}
internal static string HashAndBase64EncodeString(string s)
{
byte[] ab;
byte[] hash;
string result;
ab = Encoding.Unicode.GetBytes(s);
hash = HashData(ab, null, 0, ab.Length);
result = Convert.ToBase64String(hash);
return result;
}
static internal void DestroyByteArray(byte[] buf)
{
if (buf == null || buf.Length < 1)
return;
for (int iter = 0; iter < buf.Length; iter++)
buf[iter] = (byte)0;
}
internal void DestroyKeys()
{
MachineKeySection.DestroyByteArray(_ValidationKey);
MachineKeySection.DestroyByteArray(_DecryptionKey);
}
static char[] s_acharval;
static unsafe internal String ByteArrayToHexString(byte[] buf, int iLen)
{
char[] acharval = s_acharval;
if (acharval == null)
{
acharval = new char[16];
for (int i = acharval.Length; --i >= 0; )
{
if (i < 10)
{
acharval[i] = (char)('0' + i);
}
else
{
acharval[i] = (char)('A' + (i - 10));
}
}
s_acharval = acharval;
}
if (buf == null)
return null;
if (iLen == 0)
iLen = buf.Length;
char[] chars = new char[iLen * 2];
fixed (char* fc = chars, fcharval = acharval)
{
fixed (byte* fb = buf)
{
char* pc;
byte* pb;
pc = fc;
pb = fb;
while (--iLen >= 0)
{
*pc++ = fcharval[(*pb & 0xf0) >> 4];
*pc++ = fcharval[*pb & 0x0f];
pb++;
}
}
}
return new String(chars);
}
static void EnsureConfig()
{
if (s_config == null)
{
lock (s_initLock)
{
if (s_config == null)
{
MachineKeySection config = RuntimeConfig.GetAppConfig().MachineKey;
config.ConfigureEncryptionObject();
s_config = config;
s_compatMode = config.CompatibilityMode;
}
}
}
}
// NOTE: When encoding the data, this method *may* return the same reference to the input "buf" parameter
// with the hash appended in the end if there's enough space. The "length" parameter would also be
// appropriately adjusted in those cases. This is an optimization to prevent unnecessary copying of
// buffers.
internal static byte[] GetEncodedData(byte[] buf, byte[] modifier, int start, ref int length)
{
EnsureConfig();
byte[] bHash = HashData(buf, modifier, start, length);
byte[] returnBuffer;
if (buf.Length - start - length >= bHash.Length)
{
// Append hash to end of buffer if there's space
Buffer.BlockCopy(bHash, 0, buf, start + length, bHash.Length);
returnBuffer = buf;
}
else
{
returnBuffer = new byte[length + bHash.Length];
Buffer.BlockCopy(buf, start, returnBuffer, 0, length);
Buffer.BlockCopy(bHash, 0, returnBuffer, length, bHash.Length);
start = 0;
}
length += bHash.Length;
if (s_config.Validation == MachineKeyValidation.TripleDES || s_config.Validation == MachineKeyValidation.AES) {
returnBuffer = EncryptOrDecryptData(true, returnBuffer, modifier, start, length, true);
length = returnBuffer.Length;
}
return returnBuffer;
}
// NOTE: When decoding the data, this method *may* return the same reference to the input "buf" parameter
// with the "dataLength" parameter containing the actual length of the data in the "buf" (i.e. length of actual
// data is (total length of data - hash length)). This is an optimization to prevent unnecessary copying of buffers.
internal static byte[] GetDecodedData(byte[] buf, byte[] modifier, int start, int length, ref int dataLength)
{
EnsureConfig();
if (s_config.Validation == MachineKeyValidation.TripleDES || s_config.Validation == MachineKeyValidation.AES) {
buf = EncryptOrDecryptData(false, buf, modifier, start, length, true);
if (buf == null || buf.Length < HASH_SIZE)
throw new HttpException(SR.GetString(SR.Unable_to_validate_data));
length = buf.Length;
start = 0;
}
if (length < HASH_SIZE || start < 0 || start >= length)
throw new HttpException(SR.GetString(SR.Unable_to_validate_data));
byte[] bHash = HashData(buf, modifier, start, length - HASH_SIZE);
for (int iter = 0; iter < bHash.Length; iter++)
if (bHash[iter] != buf[start + length - HASH_SIZE + iter])
throw new HttpException(SR.GetString(SR.Unable_to_validate_data));
dataLength = length - HASH_SIZE;
return buf;
}
internal static byte[] HashData(byte[] buf, byte[] modifier, int start, int length)
{
EnsureConfig();
byte[] hash = null;
if (s_config.Validation == MachineKeyValidation.MD5)
hash = MD5HashForData(buf, modifier, start, length);
else
hash = GetHMACSHA1Hash(buf, modifier, start, length);
// We need to pad the returning hash so that they all have an uniform size (makes it easier when we decode)
// MD5 will return a 16 byte hash, whereas the default SHA1 returns 20, so we pad it with 4 zero bytes
System.Web.Util.Debug.Assert(hash.Length <= HASH_SIZE, "Hash size is greater than HASH_SIZE constant!");
if (hash.Length < HASH_SIZE)
{
byte[] tmp = new byte[HASH_SIZE];
Buffer.BlockCopy(hash, 0, tmp, 0, hash.Length);
hash = tmp;
}
return hash;
}
private void ConfigureEncryptionObject()
{
using (new ApplicationImpersonationContext()) {
s_validationKey = ValidationKeyInternal;
byte[] dKey = DecryptionKeyInternal;
SetInnerOuterKeys(s_validationKey);
DestroyKeys();
switch (Decryption) {
case "3DES":
s_oSymAlgoDecryption = new TripleDESCryptoServiceProvider();
break;
case "DES":
s_oSymAlgoDecryption = new DESCryptoServiceProvider();
break;
case "AES":
s_oSymAlgoDecryption = new RijndaelManaged();
break;
default: // "Auto" case
if (dKey.Length == 8) {
s_oSymAlgoDecryption = new DESCryptoServiceProvider();
} else {
s_oSymAlgoDecryption = new RijndaelManaged();
}
break;
}
switch(Validation)
{
case MachineKeyValidation.TripleDES:
if (dKey.Length == 8) {
s_oSymAlgoValidation = new DESCryptoServiceProvider();
} else {
s_oSymAlgoValidation = new TripleDESCryptoServiceProvider();
}
break;
case MachineKeyValidation.AES:
s_oSymAlgoValidation = new RijndaelManaged();
break;
}
if (s_oSymAlgoValidation != null) {
SetKeyOnSymAlgorithm(s_oSymAlgoValidation, dKey);
s_oEncryptorStackValidation = new Stack();
s_oDecryptorStackValidation = new Stack();
}
SetKeyOnSymAlgorithm(s_oSymAlgoDecryption, dKey);
s_oEncryptorStackDecryption = new Stack();
s_oDecryptorStackDecryption = new Stack();
DestroyByteArray(dKey);
}
}
private void SetKeyOnSymAlgorithm(SymmetricAlgorithm symAlgo, byte[] dKey)
{
try {
if (dKey.Length == 24 && symAlgo is DESCryptoServiceProvider) {
byte[] bTemp = new byte[8];
Buffer.BlockCopy(dKey, 0, bTemp, 0, 8);
symAlgo.Key = bTemp;
DestroyByteArray(bTemp);
} else {
symAlgo.Key = dKey;
}
symAlgo.GenerateIV();
symAlgo.IV = new byte[symAlgo.IV.Length];
} catch (Exception e) {
throw new ConfigurationErrorsException(SR.GetString(SR.Bad_machine_key, e.Message), ElementInformation.Properties["decryptionKey"].Source, ElementInformation.Properties["decryptionKey"].LineNumber);
}
}
private static ICryptoTransform GetCryptoTransform(bool fEncrypt, bool useValidationSymAlgo)
{
Stack st;
if (useValidationSymAlgo) {
st = (fEncrypt ? s_oEncryptorStackValidation : s_oDecryptorStackValidation);
} else {
st = (fEncrypt ? s_oEncryptorStackDecryption : s_oDecryptorStackDecryption);
}
lock (st) {
if (st.Count > 0)
return (ICryptoTransform)st.Pop();
}
if (useValidationSymAlgo) {
lock (s_oSymAlgoValidation) {
return (fEncrypt ? s_oSymAlgoValidation.CreateEncryptor() : s_oSymAlgoValidation.CreateDecryptor());
}
} else {
lock (s_oSymAlgoDecryption) {
return (fEncrypt ? s_oSymAlgoDecryption.CreateEncryptor() : s_oSymAlgoDecryption.CreateDecryptor());
}
}
}
private static void ReturnCryptoTransform(bool fEncrypt, ICryptoTransform ct, bool useValidationSymAlgo)
{
Stack st;
if (useValidationSymAlgo) {
st = (fEncrypt ? s_oEncryptorStackValidation : s_oDecryptorStackValidation);
} else {
st = (fEncrypt ? s_oEncryptorStackDecryption : s_oDecryptorStackDecryption);
}
lock (st) {
if (st.Count <= 100)
st.Push(ct);
}
}
static byte[] s_ahexval;
static internal byte[] HexStringToByteArray(String str)
{
if (((uint)str.Length & 0x1) == 0x1) // must be 2 nibbles per byte
{
return null;
}
byte[] ahexval = s_ahexval; // initialize a table for faster lookups
if (ahexval == null)
{
ahexval = new byte['f' + 1];
for (int i = ahexval.Length; --i >= 0; )
{
if ('0' <= i && i <= '9')
{
ahexval[i] = (byte)(i - '0');
}
else if ('a' <= i && i <= 'f')
{
ahexval[i] = (byte)(i - 'a' + 10);
}
else if ('A' <= i && i <= 'F')
{
ahexval[i] = (byte)(i - 'A' + 10);
}
}
s_ahexval = ahexval;
}
byte[] result = new byte[str.Length / 2];
int istr = 0, ir = 0;
int n = result.Length;
while (--n >= 0)
{
int c1, c2;
try
{
c1 = ahexval[str[istr++]];
}
catch (ArgumentNullException)
{
c1 = 0;
return null;// Inavlid char
}
catch (ArgumentException)
{
c1 = 0;
return null;// Inavlid char
}
catch (IndexOutOfRangeException)
{
c1 = 0;
return null;// Inavlid char
}
try
{
c2 = ahexval[str[istr++]];
}
catch (ArgumentNullException)
{
c2 = 0;
return null;// Inavlid char
}
catch (ArgumentException)
{
c2 = 0;
return null;// Inavlid char
}
catch (IndexOutOfRangeException)
{
c2 = 0;
return null;// Inavlid char
}
result[ir++] = (byte)((c1 << 4) + c2);
}
return result;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.Configuration
{
using System;
using System.Xml;
using System.Configuration;
using System.Collections.Specialized;
using System.Collections;
using System.IO;
using System.Text;
using System.Security.Cryptography;
using System.Web.Util;
using System.Globalization;
using System.Web.Hosting;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Security.Permissions;
/*
= s_validationKey.Length) {
// Buffer.BlockCopy(s_validationKey, 0, buf, start + length, s_validationKey.Length);
// byte[] computedHash = md5.ComputeHash(buf, start, length + s_validationKey.Length);
//
// // Cleanup validation key from buf
// for (int i = (start + length); i < (start + length + s_validationKey.Length); i++) {
// buf[i] = 0;
// }
//
// return computedHash;
// }
// }
byte[] bAll = new byte[totalLength];
Buffer.BlockCopy(buf, start, bAll, 0, length);
if (modifier != null)
{
Buffer.BlockCopy(modifier, 0, bAll, length, modifier.Length);
length += modifier.Length;
}
Buffer.BlockCopy(s_validationKey, 0, bAll, length, s_validationKey.Length);
return md5.ComputeHash(bAll);
}
private static void SetInnerOuterKeys(byte[] validationKey) {
byte[] key = null;
if (validationKey.Length > BLOCK_SIZE) {
key = new byte[HASH_SIZE];
int hr = UnsafeNativeMethods.GetSHA1Hash(validationKey, validationKey.Length, key, key.Length);
Marshal.ThrowExceptionForHR(hr);
}
if (s_inner == null)
s_inner = new byte[BLOCK_SIZE];
if (s_outer == null)
s_outer = new byte[BLOCK_SIZE];
int i;
for (i=0; i < BLOCK_SIZE; i++) {
s_inner[i] = 0x36;
s_outer[i] = 0x5C;
}
for (i=0; i < validationKey.Length; i++) {
s_inner[i] ^= validationKey[i];
s_outer[i] ^= validationKey[i];
}
}
private static byte[] GetHMACSHA1Hash(byte[] buf, byte[] modifier, int start, int length) {
if (length < 0 || buf == null || length > buf.Length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "length"));
if (start < 0 || start >= length)
throw new ArgumentException(SR.GetString(SR.InvalidArgumentValue, "start"));
byte[] buffer = new byte[HASH_SIZE];
int hr = UnsafeNativeMethods.GetHMACSHA1Hash(buf, start, length,
modifier, (modifier == null) ? 0 : modifier.Length,
s_inner, s_inner.Length, s_outer, s_outer.Length,
buffer, buffer.Length);
Marshal.ThrowExceptionForHR(hr);
return buffer;
}
internal static string HashAndBase64EncodeString(string s)
{
byte[] ab;
byte[] hash;
string result;
ab = Encoding.Unicode.GetBytes(s);
hash = HashData(ab, null, 0, ab.Length);
result = Convert.ToBase64String(hash);
return result;
}
static internal void DestroyByteArray(byte[] buf)
{
if (buf == null || buf.Length < 1)
return;
for (int iter = 0; iter < buf.Length; iter++)
buf[iter] = (byte)0;
}
internal void DestroyKeys()
{
MachineKeySection.DestroyByteArray(_ValidationKey);
MachineKeySection.DestroyByteArray(_DecryptionKey);
}
static char[] s_acharval;
static unsafe internal String ByteArrayToHexString(byte[] buf, int iLen)
{
char[] acharval = s_acharval;
if (acharval == null)
{
acharval = new char[16];
for (int i = acharval.Length; --i >= 0; )
{
if (i < 10)
{
acharval[i] = (char)('0' + i);
}
else
{
acharval[i] = (char)('A' + (i - 10));
}
}
s_acharval = acharval;
}
if (buf == null)
return null;
if (iLen == 0)
iLen = buf.Length;
char[] chars = new char[iLen * 2];
fixed (char* fc = chars, fcharval = acharval)
{
fixed (byte* fb = buf)
{
char* pc;
byte* pb;
pc = fc;
pb = fb;
while (--iLen >= 0)
{
*pc++ = fcharval[(*pb & 0xf0) >> 4];
*pc++ = fcharval[*pb & 0x0f];
pb++;
}
}
}
return new String(chars);
}
static void EnsureConfig()
{
if (s_config == null)
{
lock (s_initLock)
{
if (s_config == null)
{
MachineKeySection config = RuntimeConfig.GetAppConfig().MachineKey;
config.ConfigureEncryptionObject();
s_config = config;
s_compatMode = config.CompatibilityMode;
}
}
}
}
// NOTE: When encoding the data, this method *may* return the same reference to the input "buf" parameter
// with the hash appended in the end if there's enough space. The "length" parameter would also be
// appropriately adjusted in those cases. This is an optimization to prevent unnecessary copying of
// buffers.
internal static byte[] GetEncodedData(byte[] buf, byte[] modifier, int start, ref int length)
{
EnsureConfig();
byte[] bHash = HashData(buf, modifier, start, length);
byte[] returnBuffer;
if (buf.Length - start - length >= bHash.Length)
{
// Append hash to end of buffer if there's space
Buffer.BlockCopy(bHash, 0, buf, start + length, bHash.Length);
returnBuffer = buf;
}
else
{
returnBuffer = new byte[length + bHash.Length];
Buffer.BlockCopy(buf, start, returnBuffer, 0, length);
Buffer.BlockCopy(bHash, 0, returnBuffer, length, bHash.Length);
start = 0;
}
length += bHash.Length;
if (s_config.Validation == MachineKeyValidation.TripleDES || s_config.Validation == MachineKeyValidation.AES) {
returnBuffer = EncryptOrDecryptData(true, returnBuffer, modifier, start, length, true);
length = returnBuffer.Length;
}
return returnBuffer;
}
// NOTE: When decoding the data, this method *may* return the same reference to the input "buf" parameter
// with the "dataLength" parameter containing the actual length of the data in the "buf" (i.e. length of actual
// data is (total length of data - hash length)). This is an optimization to prevent unnecessary copying of buffers.
internal static byte[] GetDecodedData(byte[] buf, byte[] modifier, int start, int length, ref int dataLength)
{
EnsureConfig();
if (s_config.Validation == MachineKeyValidation.TripleDES || s_config.Validation == MachineKeyValidation.AES) {
buf = EncryptOrDecryptData(false, buf, modifier, start, length, true);
if (buf == null || buf.Length < HASH_SIZE)
throw new HttpException(SR.GetString(SR.Unable_to_validate_data));
length = buf.Length;
start = 0;
}
if (length < HASH_SIZE || start < 0 || start >= length)
throw new HttpException(SR.GetString(SR.Unable_to_validate_data));
byte[] bHash = HashData(buf, modifier, start, length - HASH_SIZE);
for (int iter = 0; iter < bHash.Length; iter++)
if (bHash[iter] != buf[start + length - HASH_SIZE + iter])
throw new HttpException(SR.GetString(SR.Unable_to_validate_data));
dataLength = length - HASH_SIZE;
return buf;
}
internal static byte[] HashData(byte[] buf, byte[] modifier, int start, int length)
{
EnsureConfig();
byte[] hash = null;
if (s_config.Validation == MachineKeyValidation.MD5)
hash = MD5HashForData(buf, modifier, start, length);
else
hash = GetHMACSHA1Hash(buf, modifier, start, length);
// We need to pad the returning hash so that they all have an uniform size (makes it easier when we decode)
// MD5 will return a 16 byte hash, whereas the default SHA1 returns 20, so we pad it with 4 zero bytes
System.Web.Util.Debug.Assert(hash.Length <= HASH_SIZE, "Hash size is greater than HASH_SIZE constant!");
if (hash.Length < HASH_SIZE)
{
byte[] tmp = new byte[HASH_SIZE];
Buffer.BlockCopy(hash, 0, tmp, 0, hash.Length);
hash = tmp;
}
return hash;
}
private void ConfigureEncryptionObject()
{
using (new ApplicationImpersonationContext()) {
s_validationKey = ValidationKeyInternal;
byte[] dKey = DecryptionKeyInternal;
SetInnerOuterKeys(s_validationKey);
DestroyKeys();
switch (Decryption) {
case "3DES":
s_oSymAlgoDecryption = new TripleDESCryptoServiceProvider();
break;
case "DES":
s_oSymAlgoDecryption = new DESCryptoServiceProvider();
break;
case "AES":
s_oSymAlgoDecryption = new RijndaelManaged();
break;
default: // "Auto" case
if (dKey.Length == 8) {
s_oSymAlgoDecryption = new DESCryptoServiceProvider();
} else {
s_oSymAlgoDecryption = new RijndaelManaged();
}
break;
}
switch(Validation)
{
case MachineKeyValidation.TripleDES:
if (dKey.Length == 8) {
s_oSymAlgoValidation = new DESCryptoServiceProvider();
} else {
s_oSymAlgoValidation = new TripleDESCryptoServiceProvider();
}
break;
case MachineKeyValidation.AES:
s_oSymAlgoValidation = new RijndaelManaged();
break;
}
if (s_oSymAlgoValidation != null) {
SetKeyOnSymAlgorithm(s_oSymAlgoValidation, dKey);
s_oEncryptorStackValidation = new Stack();
s_oDecryptorStackValidation = new Stack();
}
SetKeyOnSymAlgorithm(s_oSymAlgoDecryption, dKey);
s_oEncryptorStackDecryption = new Stack();
s_oDecryptorStackDecryption = new Stack();
DestroyByteArray(dKey);
}
}
private void SetKeyOnSymAlgorithm(SymmetricAlgorithm symAlgo, byte[] dKey)
{
try {
if (dKey.Length == 24 && symAlgo is DESCryptoServiceProvider) {
byte[] bTemp = new byte[8];
Buffer.BlockCopy(dKey, 0, bTemp, 0, 8);
symAlgo.Key = bTemp;
DestroyByteArray(bTemp);
} else {
symAlgo.Key = dKey;
}
symAlgo.GenerateIV();
symAlgo.IV = new byte[symAlgo.IV.Length];
} catch (Exception e) {
throw new ConfigurationErrorsException(SR.GetString(SR.Bad_machine_key, e.Message), ElementInformation.Properties["decryptionKey"].Source, ElementInformation.Properties["decryptionKey"].LineNumber);
}
}
private static ICryptoTransform GetCryptoTransform(bool fEncrypt, bool useValidationSymAlgo)
{
Stack st;
if (useValidationSymAlgo) {
st = (fEncrypt ? s_oEncryptorStackValidation : s_oDecryptorStackValidation);
} else {
st = (fEncrypt ? s_oEncryptorStackDecryption : s_oDecryptorStackDecryption);
}
lock (st) {
if (st.Count > 0)
return (ICryptoTransform)st.Pop();
}
if (useValidationSymAlgo) {
lock (s_oSymAlgoValidation) {
return (fEncrypt ? s_oSymAlgoValidation.CreateEncryptor() : s_oSymAlgoValidation.CreateDecryptor());
}
} else {
lock (s_oSymAlgoDecryption) {
return (fEncrypt ? s_oSymAlgoDecryption.CreateEncryptor() : s_oSymAlgoDecryption.CreateDecryptor());
}
}
}
private static void ReturnCryptoTransform(bool fEncrypt, ICryptoTransform ct, bool useValidationSymAlgo)
{
Stack st;
if (useValidationSymAlgo) {
st = (fEncrypt ? s_oEncryptorStackValidation : s_oDecryptorStackValidation);
} else {
st = (fEncrypt ? s_oEncryptorStackDecryption : s_oDecryptorStackDecryption);
}
lock (st) {
if (st.Count <= 100)
st.Push(ct);
}
}
static byte[] s_ahexval;
static internal byte[] HexStringToByteArray(String str)
{
if (((uint)str.Length & 0x1) == 0x1) // must be 2 nibbles per byte
{
return null;
}
byte[] ahexval = s_ahexval; // initialize a table for faster lookups
if (ahexval == null)
{
ahexval = new byte['f' + 1];
for (int i = ahexval.Length; --i >= 0; )
{
if ('0' <= i && i <= '9')
{
ahexval[i] = (byte)(i - '0');
}
else if ('a' <= i && i <= 'f')
{
ahexval[i] = (byte)(i - 'a' + 10);
}
else if ('A' <= i && i <= 'F')
{
ahexval[i] = (byte)(i - 'A' + 10);
}
}
s_ahexval = ahexval;
}
byte[] result = new byte[str.Length / 2];
int istr = 0, ir = 0;
int n = result.Length;
while (--n >= 0)
{
int c1, c2;
try
{
c1 = ahexval[str[istr++]];
}
catch (ArgumentNullException)
{
c1 = 0;
return null;// Inavlid char
}
catch (ArgumentException)
{
c1 = 0;
return null;// Inavlid char
}
catch (IndexOutOfRangeException)
{
c1 = 0;
return null;// Inavlid char
}
try
{
c2 = ahexval[str[istr++]];
}
catch (ArgumentNullException)
{
c2 = 0;
return null;// Inavlid char
}
catch (ArgumentException)
{
c2 = 0;
return null;// Inavlid char
}
catch (IndexOutOfRangeException)
{
c2 = 0;
return null;// Inavlid char
}
result[ir++] = (byte)((c1 << 4) + c2);
}
return result;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- UIElement.cs
- AttributeProviderAttribute.cs
- ResourceDefaultValueAttribute.cs
- ConfigUtil.cs
- FixedPageAutomationPeer.cs
- ObjectViewListener.cs
- CodeGenerator.cs
- XmlSerializer.cs
- FileLoadException.cs
- LowerCaseStringConverter.cs
- DataGridViewColumnCollection.cs
- ProtocolsSection.cs
- HttpInputStream.cs
- PropertyExpression.cs
- BasicKeyConstraint.cs
- KnownTypes.cs
- StreamGeometry.cs
- Walker.cs
- ClonableStack.cs
- DataTableTypeConverter.cs
- SqlDataSourceStatusEventArgs.cs
- DeferredTextReference.cs
- SQLDateTime.cs
- GridViewAutomationPeer.cs
- DataControlPagerLinkButton.cs
- Win32SafeHandles.cs
- ConfigurationManager.cs
- Pen.cs
- AdRotator.cs
- ISAPIWorkerRequest.cs
- FormViewRow.cs
- InputElement.cs
- X509ScopedServiceCertificateElementCollection.cs
- MetadataArtifactLoaderXmlReaderWrapper.cs
- UserValidatedEventArgs.cs
- ThrowHelper.cs
- CaseInsensitiveHashCodeProvider.cs
- BooleanProjectedSlot.cs
- AvTrace.cs
- UIElementPropertyUndoUnit.cs
- ValidatedMobileControlConverter.cs
- QueryContinueDragEventArgs.cs
- WebErrorHandler.cs
- DataServiceException.cs
- XmlHelper.cs
- SiteMapProvider.cs
- SqlDataSourceStatusEventArgs.cs
- bidPrivateBase.cs
- GraphicsContext.cs
- DataGridColumnHeader.cs
- ToolStripLabel.cs
- Keyboard.cs
- ScrollEvent.cs
- BridgeDataReader.cs
- Message.cs
- DataGridColumn.cs
- TCPListener.cs
- SubstitutionList.cs
- GeneralEndpointIdentity.cs
- CacheSection.cs
- NameValueCollection.cs
- Rotation3DAnimationBase.cs
- SafeFileMappingHandle.cs
- IPHostEntry.cs
- __Filters.cs
- XamlStream.cs
- NativeMethods.cs
- xamlnodes.cs
- SchemaDeclBase.cs
- TemplateContainer.cs
- ChtmlTextWriter.cs
- LightweightEntityWrapper.cs
- AspCompat.cs
- XPathSingletonIterator.cs
- DocumentationServerProtocol.cs
- SqlRewriteScalarSubqueries.cs
- SynchronizedInputHelper.cs
- WebConfigurationHostFileChange.cs
- DaylightTime.cs
- util.cs
- Button.cs
- TextProperties.cs
- OleDbMetaDataFactory.cs
- TableRowGroup.cs
- AuthenticatingEventArgs.cs
- BooleanSwitch.cs
- ProofTokenCryptoHandle.cs
- ReferencedCollectionType.cs
- CodeNamespaceCollection.cs
- EntryWrittenEventArgs.cs
- EntityDataSourceSelectedEventArgs.cs
- SmtpCommands.cs
- XPathAncestorQuery.cs
- CustomValidator.cs
- SymbolType.cs
- DesignerVerbCollection.cs
- ManualResetEvent.cs
- ContentAlignmentEditor.cs
- BasicViewGenerator.cs
- GraphicsContext.cs