Static Public Member Functions
static string	MakePbkdf2String (this IKeyedHashFunction hash, string input, string salt, int length)

static string	MakePbkdf2String (this IKeyedHashFunction hash, string input, string salt, int length, int iterationCount)

static string	MakePbkdf2String (this IKeyedHashFunction hash, string input, byte[] salt, int length)

static string	MakePbkdf2String (this IKeyedHashFunction hash, string input, byte[] salt, int length, int iterationCount)

static byte[]	MakePbkdf2 (this IKeyedHashFunction hash, byte[] salt, int length, int iterationCount)

static byte[]	MakePbkdf2 (this IKeyedHashFunction hash, byte[] data, byte[] salt, int length)

static byte[]	MakePbkdf2 (this IKeyedHashFunction hash, byte[] data, byte[] salt, int length, int iterationCount)

static bool	VerifyPbkdf2 (this IKeyedHashFunction hash, byte[] hashed, byte[] otherData, byte[] salt)

static bool	VerifyPbkdf2 (this IKeyedHashFunction hash, byte[] hashed, byte[] otherData, byte[] salt, int iterationCount)

static bool	VerifyPbkdf2String (this IKeyedHashFunction hash, string hashedString, string otherString, byte[] salt)

static bool	VerifyPbkdf2String (this IKeyedHashFunction hash, string hashedString, string otherString, byte[] salt, int iterationCount)

static bool	VerifyPbkdf2String (this IKeyedHashFunction hash, string hashedString, string otherString, string saltString)

static bool	VerifyPbkdf2String (this IKeyedHashFunction hash, string hashedString, string otherString, string saltString, int iterationCount)

static string	ComputeString (this IHashFunction hash, string s)

static byte[]	GenerateSalt (this IHashFunction hash)

static string	GenerateSaltString (this IHashFunction hash)

Static Private Member Functions
static bool	ByteArraysEqual (byte[] a, byte[] b)

static string	BinaryToHex (byte[] data)

Private Attributes
const int	DefaultIterationCount = 10000

Detailed Description

Definition at line 23 of file CryptoHashExtensions.cs.

Member Function Documentation

static string Deveel.Data.Security.CryptoHashExtenions.BinaryToHex ( byte[] data )

inlinestaticprivate

Definition at line 182 of file CryptoHashExtensions.cs.

                                                        {
             char[] hex = new char[data.Length * 2];
 
             for (int iter = 0; iter < data.Length; iter++) {
                 byte hexChar = ((byte)(data[iter] >> 4));
                 hex[iter * 2] = (char)(hexChar > 9 ? hexChar + 0x37 : hexChar + 0x30);
                 hexChar = ((byte)(data[iter] & 0xF));
                 hex[(iter * 2) + 1] = (char)(hexChar > 9 ? hexChar + 0x37 : hexChar + 0x30);
             }
             return new string(hex);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.ByteArraysEqual	(	byte[]	a,
		byte[]	b
	)

inlinestaticprivate

Definition at line 147 of file CryptoHashExtensions.cs.

                                                                 {
             if (ReferenceEquals(a, b)) {
                 return true;
             }
 
             if (a == null || b == null || a.Length != b.Length) {
                 return false;
             }
 
             bool areSame = true;
             for (int i = 0; i < a.Length; i++) {
                 areSame &= (a[i] == b[i]);
             }
             return areSame;
         }

static string Deveel.Data.Security.CryptoHashExtenions.ComputeString	(	this IHashFunction	hash,
		string	s
	)

inlinestatic

Definition at line 165 of file CryptoHashExtensions.cs.

                                                                               {
             var data = Encoding.UTF8.GetBytes(s);
             return BinaryToHex(hash.Compute(data));
         }

static byte [] Deveel.Data.Security.CryptoHashExtenions.GenerateSalt ( this IHashFunction hash )

inlinestatic

Definition at line 170 of file CryptoHashExtensions.cs.

                                                                    {
             int byteLength = (hash.HashSize / 2) / 8;
             byte[] buf = new byte[byteLength];
             var rng = new RNGCryptoServiceProvider();
             rng.GetBytes(buf);
             return buf;
         }

static string Deveel.Data.Security.CryptoHashExtenions.GenerateSaltString ( this IHashFunction hash )

inlinestatic

Definition at line 178 of file CryptoHashExtensions.cs.

                                                                          {
             return Convert.ToBase64String(hash.GenerateSalt());
         }

static byte [] Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2	(	this IKeyedHashFunction	hash,
		byte[]	salt,
		int	length,
		int	iterationCount
	)

inlinestatic

Definition at line 46 of file CryptoHashExtensions.cs.

                                                                                                                    {
             var hashKey = hash.Key;
             if (hashKey == null || hashKey.Length == 0)
                 throw new InvalidOperationException("Key was not specified for the hash.");
 
             return MakePbkdf2(hash, hashKey, salt, length, iterationCount);
         }

static byte [] Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2	(	this IKeyedHashFunction	hash,
		byte[]	data,
		byte[]	salt,
		int	length
	)

inlinestatic

Definition at line 54 of file CryptoHashExtensions.cs.

                                                                                                             {
             return MakePbkdf2(hash, data, salt, length, DefaultIterationCount);
         }

static byte [] Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2	(	this IKeyedHashFunction	hash,
		byte[]	data,
		byte[]	salt,
		int	length,
		int	iterationCount
	)

inlinestatic

Definition at line 58 of file CryptoHashExtensions.cs.

                                                                                                                                 {
             hash.Key = data;
 
             int hashLength = hash.HashSize/8;
             if ((hash.HashSize & 7) != 0)
                 hashLength++;
 
             int keyLength = length/hashLength;
             if (length > (0xFFFFFFFFL*hashLength) || length < 0)
                 throw new ArgumentOutOfRangeException("length");
 
             if (length%hashLength != 0)
                 keyLength++;
 
             byte[] extendedkey = new byte[salt.Length + 4];
             Buffer.BlockCopy(salt, 0, extendedkey, 0, salt.Length);
 
             using (var ms = new MemoryStream()) {
                 for (int i = 0; i < keyLength; i++) {
                     extendedkey[salt.Length] = (byte) (((i + 1) >> 24) & 0xFF);
                     extendedkey[salt.Length + 1] = (byte) (((i + 1) >> 16) & 0xFF);
                     extendedkey[salt.Length + 2] = (byte) (((i + 1) >> 8) & 0xFF);
                     extendedkey[salt.Length + 3] = (byte) (((i + 1)) & 0xFF);
 
                     byte[] u = hash.Compute(extendedkey);
                     Array.Clear(extendedkey, salt.Length, 4);
 
                     byte[] f = u;
                     for (int j = 1; j < iterationCount; j++) {
                         u = hash.Compute(u);
                         for (int k = 0; k < f.Length; k++) {
                             f[k] ^= u[k];
                         }
                     }
 
                     ms.Write(f, 0, f.Length);
                     Array.Clear(u, 0, u.Length);
                     Array.Clear(f, 0, f.Length);
                 }
 
                 byte[] dk = new byte[length];
                 ms.Position = 0;
                 ms.Read(dk, 0, length);
                 ms.Position = 0;
 
                 for (long i = 0; i < ms.Length; i++) {
                     ms.WriteByte(0);
                 }
 
                 Array.Clear(extendedkey, 0, extendedkey.Length);
                 return dk;
             }
         }

static string Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2String	(	this IKeyedHashFunction	hash,
		string	input,
		string	salt,
		int	length
	)

inlinestatic

Definition at line 28 of file CryptoHashExtensions.cs.

                                                                                                                    {
             return MakePbkdf2String(hash, input, salt, length, DefaultIterationCount);
         }

static string Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2String	(	this IKeyedHashFunction	hash,
		string	input,
		string	salt,
		int	length,
		int	iterationCount
	)

inlinestatic

Definition at line 32 of file CryptoHashExtensions.cs.

                                                                                                                                        {
             return hash.MakePbkdf2String(input, Convert.FromBase64String(salt), length, iterationCount);
         }

static string Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2String	(	this IKeyedHashFunction	hash,
		string	input,
		byte[]	salt,
		int	length
	)

inlinestatic

Definition at line 36 of file CryptoHashExtensions.cs.

                                                                                                                    {
             return MakePbkdf2String(hash, input, salt, length, DefaultIterationCount);
         }

static string Deveel.Data.Security.CryptoHashExtenions.MakePbkdf2String	(	this IKeyedHashFunction	hash,
		string	input,
		byte[]	salt,
		int	length,
		int	iterationCount
	)

inlinestatic

Definition at line 40 of file CryptoHashExtensions.cs.

                                                                                                                                        {
             var data = Encoding.UTF8.GetBytes(input);
             var result = hash.MakePbkdf2(data, salt, length, iterationCount);
             return Convert.ToBase64String(result);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.VerifyPbkdf2	(	this IKeyedHashFunction	hash,
		byte[]	hashed,
		byte[]	otherData,
		byte[]	salt
	)

inlinestatic

Definition at line 112 of file CryptoHashExtensions.cs.

                                                                                                                     {
             return VerifyPbkdf2(hash, hashed, otherData, salt, DefaultIterationCount);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.VerifyPbkdf2	(	this IKeyedHashFunction	hash,
		byte[]	hashed,
		byte[]	otherData,
		byte[]	salt,
		int	iterationCount
	)

inlinestatic

Definition at line 116 of file CryptoHashExtensions.cs.

                                                                                                                                         {
             int length = hashed.Length;
 
             var otherHashed = hash.MakePbkdf2(otherData, salt, length, iterationCount);
 
             if (otherHashed.Length != hashed.Length)
                 return false;
 
             return ByteArraysEqual(hashed, otherHashed);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.VerifyPbkdf2String	(	this IKeyedHashFunction	hash,
		string	hashedString,
		string	otherString,
		byte[]	salt
	)

inlinestatic

Definition at line 127 of file CryptoHashExtensions.cs.

                                                                                                                                   {
             return VerifyPbkdf2String(hash, hashedString, otherString, salt, DefaultIterationCount);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.VerifyPbkdf2String	(	this IKeyedHashFunction	hash,
		string	hashedString,
		string	otherString,
		byte[]	salt,
		int	iterationCount
	)

inlinestatic

Definition at line 131 of file CryptoHashExtensions.cs.

                                                                                                                                                       {
             return hash.VerifyPbkdf2String(hashedString, otherString, Convert.ToBase64String(salt), iterationCount);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.VerifyPbkdf2String	(	this IKeyedHashFunction	hash,
		string	hashedString,
		string	otherString,
		string	saltString
	)

inlinestatic

Definition at line 135 of file CryptoHashExtensions.cs.

                                                                                                                                         {
             return VerifyPbkdf2String(hash, hashedString, otherString, saltString, DefaultIterationCount);
         }

static bool Deveel.Data.Security.CryptoHashExtenions.VerifyPbkdf2String	(	this IKeyedHashFunction	hash,
		string	hashedString,
		string	otherString,
		string	saltString,
		int	iterationCount
	)

inlinestatic

Definition at line 139 of file CryptoHashExtensions.cs.

                                                                                                                                                             {
             var hashed = Convert.FromBase64String(hashedString);
             var otherData = Encoding.UTF8.GetBytes(otherString);
             var salt = Convert.FromBase64String(saltString);
 
             return hash.VerifyPbkdf2(hashed, otherData, salt, iterationCount);
         }

Member Data Documentation

const int Deveel.Data.Security.CryptoHashExtenions.DefaultIterationCount = 10000

private

Definition at line 26 of file CryptoHashExtensions.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Security/CryptoHashExtensions.cs

Static Public Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

Member Data Documentation