Added bunch of tools

Mostly command line and need fixing for different drive letters

Author: john-h-k

utils/BatchHasher.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Security.Cryptography;
+
+namespace PBKDF2Hasher
+{
+    public class BatchHasher
+    {
+
+        public static byte[] generateSalt()
+        {
+            var csprng = new RNGCryptoServiceProvider();
+            var salt = new byte[24];
+            csprng.GetBytes(salt);
+            return salt;
+        }
+
+        public static int Main(string[] args)
+        {
+            if (args.Length == 0)
+            {
+                Console.WriteLine(@"Please give a word followed by a salt, seperated by a comma (with no spaces) to be hashed
+                E.g beep,gxsnfYvKQIExdD233H8rpkx8MKp8KhdD - not beep, gxsnfYvKQIExdD233H8rpkx8MKp8KhdD");
+                return 1;
+            }
+            byte[] salt = new byte[24];
+            var SplitArgs = new string[args.Length][];
+            for (int i = 0; i < args.Length; i++)
+            {
+                SplitArgs[i] = args[i].Split(',');
+                if(SplitArgs[i].Length == 1)
+                {
+                    Console.WriteLine("No salt detected - salt will be generated");
+                    salt = generateSalt();
+                }
+            }
+
+            var hashes = new byte[args.Length][];
+            for (int i = 0; i < args.Length; i++)
+            {
+                byte[] hashValue;
+                
+
+                //Generate hash using salt
+                using (var pbkdf2 = new Rfc2898DeriveBytes(SplitArgs[i][0], Convert.FromBase64String(SplitArgs[i][1]), 100000))
+                {
+                    hashValue = pbkdf2.GetBytes(24);
+                }
+                hashes[i] = hashValue;
+            }
+            Console.WriteLine("Hashes come first, followed by a hiphen ('-') then the salt: ");
+            for (int i = 0; i < args.Length; i++)
+            {
+                Console.WriteLine(Convert.ToBase64String(hashes[i]) + " - " + SplitArgs[i][1]);
+            }
+
+        return 0;
+        }
+    }
+}

utils/Data.dat

@@ -0,0 +1,87 @@
+using System;
+using System.Security.Cryptography;
+
+namespace PBKDF2Hasher
+{
+    public class Hasher
+    {
+
+        public static byte[] GenerateSalt()
+        {
+            var csprng = new RNGCryptoServiceProvider();
+            var salt = new byte[32];
+            csprng.GetBytes(salt);
+            Console.WriteLine("Salt generated - {0}", Convert.ToBase64String(salt));
+            return salt;
+        }
+
+        public static int GetIterations()
+        {
+            Console.WriteLine("Please enter a number of iterations. If no input is given the program will default to 1 million: ");
+
+            int iterations;
+
+            string input = Console.ReadLine();
+            if (input == "")
+            {
+                Console.WriteLine("Using default iterations");
+                return 1000000;
+            }
+            try
+            {
+                iterations = Int32.Parse(input);
+            }
+            catch (FormatException)
+            {
+                Console.WriteLine("Please enter a valid number");
+                return GetIterations();
+            }
+            return iterations;
+        }
+
+        public static int Main(string[] args)
+        {
+            if (args.Length > 3 || args.Length == 0) 
+            {
+                Console.WriteLine("Please give a word to be hashed, and optionally a salt and an iteration number");
+                return 1;
+            }
+
+            Byte[] salt;
+            int iterations;
+
+            if (args.Length > 1)
+            {
+                salt = Convert.FromBase64String(args[1]);
+            }
+            else
+            {
+                salt = GenerateSalt();
+            }
+
+            if (args.Length == 3)
+            {
+                iterations = Convert.ToInt32(args[3]);
+            }
+            else
+            {
+                iterations = GetIterations();
+                
+            }
+            
+            byte[] hashValue;
+
+            //Generate hash using salt
+            using (var pbkdf2 = new Rfc2898DeriveBytes(args[0], salt, iterations))
+            {
+                Console.WriteLine("Hashing...");
+                hashValue = pbkdf2.GetBytes(64);
+            }
+
+            Console.WriteLine("\nHash: " + Convert.ToBase64String(hashValue) + "\n"  + "Salt: " + Convert.ToBase64String(salt));
+            
+
+        return 0;
+        }
+    }
+}

utils/Executables/DataProtector.exe

@@ -0,0 +1,14 @@
+using System;
+using System.Diagnostics;
+
+namespace App
+{
+    class Application
+    {
+        public static void Main()
+        {
+            Console.WriteLine("Hello World!");
+            Console.ReadKey();
+        }
+    }
+}

utils/Executables/Hasher.exe

@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Security.Cryptography;
+
+namespace JLib.Security
+{
+    public class DataProtector
+    {
+        public static void Main(string[] Args)
+        {
+            var data = Encoding.ASCII.GetBytes("MyData");
+            var Length = ProtectDataToFile(data, @"C:\Users\johnk\Documents\General Code\C#\Data.dat", @"C:\Users\johnk\UNIENT\ent.dat");
+
+            var entropy = new byte[16];
+
+            using (var BinReader = new BinaryReader(File.Open(@"C:\Users\johnk\UNIENT\ent.dat", FileMode.Open)))
+            {
+                entropy = BinReader.ReadBytes(16);
+            }
+            Console.WriteLine(Encoding.ASCII.GetString(UnprotectDataFromFile(entropy, @"C:\Users\johnk\Documents\General Code\C#\Data.dat", Length)));
+        }
+
+        public static long ProtectDataToFile(byte[] Data, string FilePath, string EntropyFilePath)
+        {
+            byte[] entropy = new byte[16];
+            var rng = new RNGCryptoServiceProvider();
+            rng.GetBytes(entropy);
+
+            var encryptedData = ProtectedData.Protect(Data, entropy, DataProtectionScope.CurrentUser);
+            long Length = encryptedData.Length;
+
+            using (var BinWriter = new BinaryWriter(File.Open(EntropyFilePath, FileMode.Create)))
+            {
+                BinWriter.Write(entropy);
+            }
+
+            using (var BinWriter = new BinaryWriter(File.Open(FilePath, FileMode.Create)))
+            {
+                BinWriter.Write(encryptedData);
+            }
+
+            return Length;
+        }
+
+        public static byte[] UnprotectDataFromFile(byte[] Entropy, string FilePath, long Length)
+        {
+            var data = new byte[Length];
+            using (var BinReader = new BinaryReader(File.Open(FilePath, FileMode.Open)))
+            {
+                data = BinReader.ReadBytes((int)Length);
+            }
+
+            return ProtectedData.Unprotect(data, Entropy, DataProtectionScope.CurrentUser);
+        }
+    }
+}