private static byte[] scanKeyFile(CryptobyConsole console) { scanner = new Scanner(java.lang.System.@in); byte[] tempKey = null; do { Console.Out.WriteLine("\nAllowed Key Sizes 128,192 and 256 Bit."); Console.Out.WriteLine("Enter Path to Key File (Type '" + quit + "' to Escape):" ); if (scanner.hasNext(quit)) { aesCrypterFile(console); } keyPath = scanner.next(); try { tempKey = CryptobyFileManager.getKeyFromFile(keyPath); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); aesCrypterFile(console); } catch (FormatException) { Console.Out.WriteLine("Key File format is not correct!"); aesCrypterFile(console); } keySize = tempKey.Length * 4; }while (keySize != 128 && keySize != 192 && keySize != 256); return(tempKey); }
public virtual void testRSACrypt1024false() { System.Console.Out.WriteLine("RSACrypt1024false"); int keySize = 1024; CryptobyClient client = new CryptobyClient(); CryptobyCore core = new CryptobyCore(client); KeyGenRSA generator = new KeyGenRSA(core); generator.initGenerator(keySize); byte[] plainInput = Encoding.UTF8.GetBytes("Text to Test for Testing from Tester by Testcase" ); string publicKeyString = generator.getPublicKey(); byte[] publicKey = CryptobyHelper.hexStringToBytes(publicKeyString); generator.initGenerator(keySize); string privateKeyString = generator.getPrivateKey(); byte[] privateKey = CryptobyHelper.hexStringToBytes(privateKeyString); CryptRSA rsa = new CryptRSA(); byte[] expResult = plainInput; byte[] result = rsa.encrypt(plainInput, publicKey); result = rsa.decrypt(result, privateKey); NUnit.Framework.Assert.IsFalse(Arrays.equals(expResult, result)); }
private static void aesEncrypterText(CryptobyConsole console) { scanner = new Scanner(java.lang.System.@in); scanner.useDelimiter("\n"); // Input your String Text to encrypt Console.Out.WriteLine("\nYour Text to encrypt (Type '" + quit + "' to Escape):" ); if (scanner.hasNext(quit)) { aesCrypterText(console); } plainByte = Encoding.UTF8.GetBytes(scanner.next()); // Input your Key for encryption key = scanKeyText(console); // Initial AES Crypt Object initAESKeyGen(console); // Encrypt the String Text with given Key Console.Out.WriteLine("\nEncrypting in progress..."); cryptByte = console.getCore().getCryptSym().encrypt(plainByte, key); // Convert byte Array into a Hexcode String charTextHex = CryptobyHelper.bytesToHexStringUpper(cryptByte).ToCharArray(); // Print encrypted Text in Hex Block form Console.Out.WriteLine("\nEncryption successfull..."); Console.Out.WriteLine(CryptobyHelper.printHexBlock("AES", keySize, charTextHex )); // Back to Text Crypter Menu Console.Out.WriteLine("\nGo back to AES Text Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); aesCrypterText(console); }
private void generateKeys(int keyBitSize) { keyByteSize = keyBitSize / 8; do { // Generate Primes for Q and P // Use Cores parallel, if there are more than 1 if (cores > 1) { do { BigInteger[] primes = getPrimesParallel(keyBitSize); p = primes[0]; q = primes[1]; }while (p.compareTo(q) == 0); } else { do { p = getPrimesParallel(keyBitSize)[0]; q = getPrimesParallel(keyBitSize)[0]; log2ofPQ = java.lang.Math.abs(CryptobyHelper.logBigInteger(p) - CryptobyHelper.logBigInteger (q)); }while (log2ofPQ <= 0.1 || log2ofPQ >= 30); } // Calculate n Module calcN(); // Calculate Phi Module calcPhi(); // Calculate D Module calcD(); }while (n.toByteArray().Length != (keyByteSize) || d.toByteArray().Length != (keyByteSize )); }
/// <summary>Method convert public key String to block format and add a title.</summary> /// <remarks>Method convert public key String to block format and add a title.</remarks> /// <param name="publicKey">String converted to char array and than to block String</param> /// <returns>Return block String of publicKey</returns> public static string printPublicKeyBlock(string publicKey) { java.lang.StringBuilder sb = new java.lang.StringBuilder(); sb.append("\nPublic Key:\n"); sb.append(CryptobyHelper.charToBlockString(publicKey.ToCharArray())); sb.append(EOB); return(sb.ToString()); }
public virtual void testPrintPublicKeyBlock() { System.Console.Out.WriteLine("printPublicKeyBlock"); string publicKey = "TestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTest"; string result = CryptobyHelper.printPublicKeyBlock(publicKey); System.Console.Out.WriteLine(result); }
/// <summary>Generate a SHA3 Hash/Key depend on password input as String.</summary> /// <remarks>Generate a SHA3 Hash/Key depend on password input as String.</remarks> /// <param name="keySize">Size of hash. Allowed are 224, 256, 384 and 512.</param> /// <param name="password">String password which will be hashed</param> /// <returns>SHA3 hash as Hex String</returns> public virtual string generateKey(int keySize, string password) { byte[] bytePW = Encoding.UTF8.GetBytes(password); KeyGenSHA3.init(keySize); KeyGenSHA3.update(bytePW, bytePW.Length * 8); string output = CryptobyHelper.bytesToHexString(KeyGenSHA3.getHash()); return(output); }
/// <summary>This method load a key file from disk to byte array.</summary> /// <remarks> /// This method load a key file from disk to byte array. They key in the file /// must be in Hex String Block format which will be merged and converted /// from hex String to byte array as output. /// </remarks> /// <param name="filePath">Path to key file which bytes will be loaded</param> /// <returns>Byte array of hex string in filePath</returns> /// <exception cref="System.IO.IOException"> /// If file not found or other IO problems there will be /// throw an IOException /// </exception> public static byte[] getKeyFromFile(string filePath) { StreamReader streamReader = new StreamReader(filePath); string sb = streamReader.ReadToEnd(); streamReader.Close(); System.Console.WriteLine(CryptobyHelper.hexStringToBytes(sb)); return(CryptobyHelper.hexStringToBytes(sb)); }
private static void rsaDecrypterText(CryptobyConsole console) { scanner = new Scanner(java.lang.System.@in); // Input encrypted Hex String Text to decrypt Console.Out.WriteLine("\nYour Text to decrypt (Type '" + quit + "' to Escape):" ); // Convert crypted HexString Block to one String try { string cryptText = string.Empty; while (!scanner.hasNext(CryptobyHelper.getEOBString())) { if (scanner.hasNext(quit)) { rsaCrypterText(console); } cryptText = cryptText + scanner.next(); } cryptByte = CryptobyHelper.hexStringToBytes(cryptText); } catch (FormatException) { // Catch false format of Input Console.Out.WriteLine("\nNot allowed Crypted Text! Must be a Upper Hex String!" ); cryptByte = BigInteger.ZERO.toByteArray(); } // Input the Private Key privateKeyByte = scanPrivateKey(console); // Initial RSA Crypt Object initRSAKeyGen(console); // Decrypt the String Text with given Key Console.Out.WriteLine("\nDecryption in progress..."); try { plainByte = console.getCore().getCryptAsym().decrypt(cryptByte, privateKeyByte); } catch (Exception) { Console.Out.WriteLine("\nUnable to decrypt this String!!"); plainByte = null; // Press Return for Continues CryptobyHelper.pressEnter(); rsaCrypterText(console); } Console.Out.WriteLine("\nDecryption finished..."); // Print decrypted Text Console.Out.WriteLine("\nRSA-" + keySize + " decrypted Text:"); Console.Out.WriteLine(Encoding.UTF8.GetString(plainByte)); // Reset RSA Crypt Object to release Memory initRSAKeyGen(console); // Back to Menu rsaCrypter with Enter (Return) Key Console.Out.WriteLine("\nGo back to RSA Text Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); rsaCrypterText(console); }
/// <summary> /// Method merge inputs and add a title to return String which can print /// encrypted text and title in User Interfaces. /// </summary> /// <remarks> /// Method merge inputs and add a title to return String which can print /// encrypted text and title in User Interfaces. /// </remarks> /// <param name="cryptType">Type of cryptology implementation as String</param> /// <param name="inputKeySize">Size of used key as integer</param> /// <param name="inputCharTextHex"> /// Char array of String which will be converted to /// block /// </param> /// <returns>Return String of merged input parameter and text</returns> public static string printHexBlock(string cryptType, int inputKeySize, char[] inputCharTextHex ) { java.lang.StringBuilder sb = new java.lang.StringBuilder(); sb.append("\n").append(cryptType).append("-").append(inputKeySize).append(" encrypted Text in Hex form (Copy with '" + EOB + "'):\n"); sb.append(CryptobyHelper.charToBlockString(inputCharTextHex)); sb.append(EOB); return(sb.ToString()); }
public virtual void testCharToBlockString() { System.Console.Out.WriteLine("charToBlockString"); byte[] cryptByte = Encoding.UTF8.GetBytes("TestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTest" ); char[] charTextHex = CryptobyHelper.bytesToHexStringUpper(cryptByte).ToCharArray( ); string result = CryptobyHelper.charToBlockString(charTextHex); System.Console.Out.WriteLine(result); }
private static void aesDecrypterText(CryptobyConsole console) { scanner = new Scanner(java.lang.System.@in); // Input encrypted Hex String Text to decrypt Console.Out.WriteLine("\nYour Text to decrypt (Type '" + quit + "' to Escape):" ); // Convert crypted HexString Block to one String try { string cryptText = string.Empty; while (!scanner.hasNext(CryptobyHelper.getEOBString())) { if (scanner.hasNext(quit)) { aesCrypterText(console); } cryptText = cryptText + scanner.next(); } cryptByte = CryptobyHelper.hexStringToBytes(cryptText); } catch (FormatException) { // Catch false format of Input Console.Out.WriteLine("\nNot allowed Crypted Text! Must be a Upper Hex String!" ); cryptByte = BigInteger.ZERO.toByteArray(); } // Input your Key for encryption key = scanKeyText(console); // Initial AES Crypt Object initAESKeyGen(console); // Decrypt the String Text with given Key Console.Out.WriteLine("\nDecrypting in progress..."); try { plainByte = console.getCore().getCryptSym().decrypt(cryptByte, key); } catch (Exception) { Console.Out.WriteLine("\nUnable to decrypt this String!!"); // Enter for Continues CryptobyHelper.pressEnter(); aesCrypterText(console); } // Print decrypted Text Console.Out.WriteLine("\nDecryption finished..."); Console.Out.WriteLine("\nAES-" + keySize + " decrypted Text:"); Console.Out.WriteLine(Encoding.UTF8.GetString(plainByte)); // Back to Text Crypter Menu Console.Out.WriteLine("\nGo back to AES Text Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); aesCrypterText(console); }
/// <summary>Generate a random SHA3 Hash/Key as String.</summary> /// <remarks>Generate a random SHA3 Hash/Key as String.</remarks> /// <param name="keySize">Size of hash. Allowed are 224, 256, 384 and 512.</param> /// <returns>SHA3 hash as Hex String</returns> public virtual string generateKey(int keySize) { SecureRandom scRandom = new SecureRandom(); byte[] randomPW = new byte[40]; scRandom.nextBytes(randomPW); KeyGenSHA3.init(keySize); KeyGenSHA3.update(randomPW, randomPW.Length * 8); string output = CryptobyHelper.bytesToHexString(KeyGenSHA3.getHash()); return(output); }
/// <param name="console"></param> public static void testMillerRabin(CryptobyConsole console) { Scanner scanner = new Scanner(java.lang.System.@in); // Initial Variables int rounds; string percent; BigInteger number; do { // Input Number for Primenumber Testing System.Console.Out.WriteLine("Set Primenumber to Test."); System.Console.Out.Write("Please enter a positive number: "); while (!scanner.hasNextBigInteger()) { System.Console.Out.Write("That's not a number! Enter a positive number: "); scanner.next(); } number = scanner.nextBigInteger(); }while (number.compareTo(BigInteger.ONE) < 0); do { // Set the rounds of the Miller Rabin Test System.Console.Out.WriteLine("Set rounds parameter between 1 and 15."); System.Console.Out.Write("Please enter the number of rounds: "); while (!scanner.hasNextInt()) { System.Console.Out.Write("That's not a number! Enter a valid number: "); scanner.next(); } rounds = scanner.nextInt(); }while (rounds < 1 || rounds > 15); // Initial Miller Rabin Object console.getCore().getClient().setPrimTestArt("MillerRabin"); console.getCore().getClient().setPrimetestrounds(rounds); console.getCore().initPrimeTest(); // Get Result of Test if (console.getCore().getPrimetest().isPrime(number)) { percent = console.getCore().getPrimetest().getProbability().ToString(); System.Console.Out.WriteLine("\nResult: Number is probably a Primenumber, probability: " + percent + "%"); } else { System.Console.Out.WriteLine("\nResult: Number is NOT a Primenumber"); } // Back to Menu Choose PrimeTest System.Console.Out.WriteLine("\nGo back to Primetest Menu: Press Enter"); CryptobyHelper.pressEnter(); console.menuPrimeTest(); }
public virtual void testPrintHexBlock() { System.Console.Out.WriteLine("printHexBlock"); byte[] cryptByte = Encoding.UTF8.GetBytes("TestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTest" ); char[] inputCharTextHex = CryptobyHelper.bytesToHexStringUpper(cryptByte).ToCharArray (); string cryptType = "RSA"; int inputKeySize = 1024; string result = CryptobyHelper.printHexBlock(cryptType, inputKeySize, inputCharTextHex ); System.Console.Out.WriteLine(result); }
public virtual void testEncryptDecrypt256() { System.Console.Out.WriteLine("encrypt and decrypt testphrase"); byte[] plainInput = Encoding.UTF8.GetBytes("Text to Test for Testing from Tester by Testcase" ); KeyGenSHA3 keyGen = new KeyGenSHA3(); string hexKey = keyGen.generateKey(256, "password"); byte[] bKey = CryptobyHelper.hexStringToBytes(hexKey); CryptAES instance = new CryptAES(); byte[] expResult = plainInput; byte[] result = instance.encrypt(plainInput, bKey); result = instance.decrypt(result, bKey); Assert.AreEqual(expResult, result); }
public virtual void testEncryptDecrypt256_false() { System.Console.Out.WriteLine("crypt almost false key"); byte[] plainInput = Encoding.UTF8.GetBytes("Text to Test for Testing from Tester by Testcase" ); string hexKey = "13A9489AF957FF7B5E8E712737D0B4A0C92AE8EBAE9DD11E9C11B8CB79707017"; byte[] bKey = CryptobyHelper.hexStringToBytes(hexKey); CryptAES instance = new CryptAES(); byte[] expResult = plainInput; byte[] result = instance.encrypt(plainInput, bKey); hexKey = "13A9489AF957FF7B5E8E712737D0B4A0C92AE8EBAE9DD11E9C11B8CB79707011"; bKey = CryptobyHelper.hexStringToBytes(hexKey); result = instance.decrypt(result, bKey); Assert.IsFalse(Encoding.UTF8.GetString(expResult).Equals (Encoding.UTF8.GetString(result))); }
/// <summary>Generate RSA Private and Public Key with Size of keyBitSize.</summary> /// <remarks>Generate RSA Private and Public Key with Size of keyBitSize.</remarks> /// <param name="keyBitSize"> /// Size of RSA key which will be generated. Allowed are /// 1024, 2048 and 4096 /// </param> public virtual void initGenerator(int keyBitSize) { if (keyBitSize != 1024 && keyBitSize != 2048 && keyBitSize != 4096) { throw new ArgumentException("Just Keys with Size of 1024,2048 or 4096 are allowed!" ); } generateKeys(keyBitSize); // Generate Public Key to Hex String pubKeyByte = n.toByteArray(); pubKey = CryptobyHelper.bytesToHexString(pubKeyByte); byte[] dByte = d.toByteArray(); privKeyByte = new byte[dByte.Length + pubKeyByte.Length]; // Copy D ByteArray into first Part and N ByteArray into second Part Array.Copy(dByte, 0, privKeyByte, 0, dByte.Length); Array.Copy(pubKeyByte, 0, privKeyByte, dByte.Length, pubKeyByte.Length); // Generate Private Key to Hex String privKey = CryptobyHelper.bytesToHexString(privKeyByte); }
private BigInteger[] getPrimesParallel(int keyBitSize) { System.Threading.Thread[] startThreads = new System.Threading.Thread[cores]; GenPrimeThread[] primeThreads = new GenPrimeThread[cores]; BigInteger[] primes = new BigInteger[cores]; BigInteger[] retPrime = new BigInteger[2]; for (int i = 0; i < cores; i++) { primeThreads[i] = new GenPrimeThread(core, keyBitSize); startThreads[i] = new System.Threading.Thread(new System.Threading.ThreadStart(primeThreads[i].run)); } // Start Threads for (int i_1 = 0; i_1 < cores; i_1++) { startThreads[i_1].Start(); } for (int i_2 = 0; i_2 < cores; i_2++) { startThreads[i_2].Join(); } for (int i_3 = 0; i_3 < cores; i_3++) { primes[i_3] = primeThreads[i_3].getPrime(); } for (int i_4 = 0; i_4 < cores; i_4++) { for (int j = cores - 1; j >= 0; j--) { log2ofPQ = java.lang.Math.abs(CryptobyHelper.logBigInteger(primes[i_4]) - CryptobyHelper .logBigInteger(primes[j])); if (log2ofPQ >= 0.1 || log2ofPQ <= 30) { retPrime[0] = primes[i_4]; retPrime[1] = primes[j]; return(retPrime); } } } retPrime[0] = BigInteger.ZERO; retPrime[1] = BigInteger.ZERO; return(retPrime); }
public virtual void testEncryptDecrypt256_HugeData() { System.Console.Out.WriteLine("encrypt and decrypt huge Data"); byte[] plainInput = new byte[1000000]; KeyGenSHA3 keyGen = new KeyGenSHA3(); string hexKey = keyGen.generateKey(256, "password"); byte[] bKey = CryptobyHelper.hexStringToBytes(hexKey); CryptAES instance = new CryptAES(); byte[] expResult = plainInput; byte[] result = instance.encrypt(plainInput, bKey); result = instance.decrypt(result, bKey); for (int i = 0; i < 10; i++) { result = instance.encrypt(plainInput, bKey); result = instance.decrypt(result, bKey); } Assert.AreEqual(expResult, result); }
// Help Functions private static byte[] scanPrivateKey(CryptobyConsole console) { byte[] retKey = null; do { scanner = new Scanner(java.lang.System.@in); string keyText = string.Empty; // Input Private Key for decryption Console.Out.WriteLine("\nEnter the private Key (Type '" + quit + "' to Escape):" ); try { while (!scanner.hasNext(CryptobyHelper.getEOBString())) { if (scanner.hasNext(quit)) { rsaCrypterText(console); } keyText = keyText + scanner.next(); } retKey = CryptobyHelper.hexStringToBytes(keyText); keySize = retKey.Length * 4; } catch (FormatException) { // Catch false format of Input Console.Out.WriteLine("Not allowed Characters in Private Key! Just lower alphanumeric Characters!" ); retKey = BigInteger.ZERO.toByteArray(); keySize = 0; } catch (ArgumentNullException) { Console.Out.WriteLine("NullPointerException catched! Try again!"); retKey = BigInteger.ZERO.toByteArray(); keySize = 0; } }while (keySize != 1024 && keySize != 2048 && keySize != 4096); return(retKey); }
private static void rsaEncrypterText(CryptobyConsole console) { // Input your String Text to encrypt plainByte = scanPlainText(console); // Input the Public Key to encrypt publicKeyByte = scanPublicKey(console); // Initial RSA Crypt Object initRSAKeyGen(console); // Encrypt the String Text with given Key Console.Out.WriteLine("\nEncryption in progress..."); cryptByte = console.getCore().getCryptAsym().encrypt(plainByte, publicKeyByte); Console.Out.WriteLine("\nEncryption successfull..."); // Convert byte Array into a Hexcode String charTextHex = CryptobyHelper.bytesToHexStringUpper(cryptByte).ToCharArray(); // Print encrypted Text in Hex Block form Console.Out.WriteLine(CryptobyHelper.printHexBlock("RSA", keySize, charTextHex )); // Back to Menu rsaCrypter with Enter (Return) Key Console.Out.WriteLine("\nGo back to RSA Text Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); rsaCrypterText(console); }
public virtual void testEncryptDecrypt256_CBC() { System.Console.Out.WriteLine("encrypt and decrypt recurring words"); byte[] plainInput = Encoding.UTF8.GetBytes("TestTestTestTestTestTestTestTestTestTestTestTestTestTestTestTest" ); KeyGenSHA3 keyGen = new KeyGenSHA3(); string hexKey = keyGen.generateKey(256, "password"); byte[] bKey = CryptobyHelper.hexStringToBytes(hexKey); CryptAES instance = new CryptAES(); byte[] expResult = plainInput; byte[] result = instance.encrypt(plainInput, bKey); string resString = CryptobyHelper.bytesToHexStringUpper(result); for (int i = 0; i < resString.Length - 32; i += 32) { Assert.IsFalse(resString.Substring(i, 32).Equals (resString.Substring(i + 32, 32))); } result = instance.decrypt(result, bKey); Assert.AreEqual(expResult, result); }
private static void aesEncrypterFile(CryptobyConsole console) { // Input Path to File for encryption scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter Path to File for encryption (Type '" + quit + "' to Escape):"); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { aesCrypterFile(console); } plainFilePath = scanner.next(); // Get Bytes from PlainFile try { plainByte = CryptobyFileManager.getBytesFromFile(plainFilePath); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); aesCrypterFile(console); } // Input Path saving Path scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter Path to save encrypted File (Type '" + quit + "' to Escape):"); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { aesCrypterFile(console); } cryptFilePath = scanner.next(); // Input Key File for encryption key = scanKeyFile(console); // Initial AES Crypt Object initAESKeyGen(console); // Encrypt the String Text with given Key Console.Out.WriteLine("\nEncrypting in progress..."); cryptByte = console.getCore().getCryptSym().encrypt(plainByte, key); Console.Out.WriteLine("\nEncryption successfull. Saving File now..."); //Put encrypted Bytes to File try { CryptobyFileManager.putBytesToFile(cryptFilePath, cryptByte); } catch (System.IO.IOException ex) { Logger.getLogger(typeof(RsaUI).FullName).log(Level.SEVERE, null, ex); } Console.Out.WriteLine("\nEncrypted File saved to this Path:"); Console.Out.WriteLine(cryptFilePath); // Reset Variables initAESKeyGen(console); cryptByte = null; plainByte = null; key = null; // Back to File Crypter Menu Console.Out.WriteLine("\nGo back to AES File Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); aesCrypterFile(console); }
private static void aesDecrypterFile(CryptobyConsole console) { // Input Path to File for decryption scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter Path to decrypt a File (Type '" + quit + "' to Escape):" ); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { aesCrypterFile(console); } cryptFilePath = scanner.next(); try { // Get Bytes from PlainFile cryptByte = CryptobyFileManager.getBytesFromFile(cryptFilePath); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); aesCrypterFile(console); } // Input Path saving Path scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter Path to save decrypted File (Type '" + quit + "' to Escape):"); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { aesCrypterFile(console); } plainFilePath = scanner.next(); // Input your Key for encryption key = scanKeyFile(console); // Initial AES Crypt Object initAESKeyGen(console); // Decrypt the String Text with given Key Console.Out.WriteLine("\nDecrypting in progress..."); try { plainByte = console.getCore().getCryptSym().decrypt(cryptByte, key); } catch (Exception) { Console.Out.WriteLine("\nUnable to decrypt this String!!"); // Enter for Continues CryptobyHelper.pressEnter(); aesCrypterFile(console); } Console.Out.WriteLine("\nDecryption finished. Saving File now..."); try { //Put encrypted Bytes to File CryptobyFileManager.putBytesToFile(plainFilePath, plainByte); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); aesCrypterFile(console); } Console.Out.WriteLine("\nDecrypted File saved to this Path:"); Console.Out.WriteLine(plainFilePath); // Reset Variables initAESKeyGen(console); cryptByte = null; plainByte = null; key = null; // Back to File Crypter Menu Console.Out.WriteLine("\nGo back to AES File Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); aesCrypterFile(console); }
/// <param name="console"></param> public static void genSHA3KeyText(CryptobyConsole console) { Scanner scanner = new Scanner(java.lang.System.@in); // Initial Variables int keySize; int choice; string pwAns; string key; string password; // Set Default Key Size keySize = 256; do { Console.Out.WriteLine("\n"); Console.Out.WriteLine("Select Key Size in Bit"); Console.Out.WriteLine("----------------------\n"); Console.Out.WriteLine("1 - 224"); Console.Out.WriteLine("2 - 256"); Console.Out.WriteLine("3 - 384"); Console.Out.WriteLine("4 - 512"); Console.Out.WriteLine("5 - Back"); Console.Out.Write("Enter Number: "); while (!scanner.hasNextInt()) { Console.Out.WriteLine("That's not a number! Enter 1,2,3,4 or 5:"); scanner.next(); } choice = scanner.nextInt(); }while (choice < 1 || choice > 5); switch (choice) { case 1: { keySize = 224; break; } case 2: { keySize = 256; break; } case 3: { keySize = 384; break; } case 4: { keySize = 512; break; } case 5: { console.menuGenKey(); break; } default: { console.menuGenKey(); break; } } do { // Input a Password or nothing, in the case it will be used a Secure Random number Console.Out.WriteLine("Do you want to use a password. If not, it will be used a SecureRandom password." ); Console.Out.Write("Enter y or n: "); pwAns = scanner.next(); }while (!pwAns.Equals("y") && !pwAns.Equals("n")); if (pwAns.Equals("y")) { Console.Out.Write("Enter Password for the Key: "); password = scanner.next(); } else { password = string.Empty; } // Initial Key Generator console.getCore().getClient().setKeySymArt("SHA3"); console.getCore().initSymKey(); // Get Result of Test if (password.Equals(string.Empty)) { key = console.getCore().getKeyGenSym().generateKey(keySize); } else { key = console.getCore().getKeyGenSym().generateKey(keySize, password); } // Print Key Console.Out.WriteLine("SHA3-" + keySize + ": " + key); // Enter for Continues CryptobyHelper.pressEnter(); // Back to Menu Choose PrimeTest console.menuGenKey(); }
/// <summary>Encrypt a byte array in blocks with AES algorithm in CBC mode.</summary> /// <remarks>Encrypt a byte array in blocks with AES algorithm in CBC mode.</remarks> /// <param name="plainInput">Plain byte array to encrypt</param> /// <param name="key">256 Bit key to encrypt plainInput</param> /// <returns>Return encrypted byte array</returns> public virtual byte[] encrypt(byte[] plainInput, byte[] key) { int inputLength = plainInput.Length; int percentProgress; int prevPercent = -1; byte[] inputLengthByte = ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(inputLength).array(); int restInput = plainInput.Length % nBytes; byte[] exKey = initKeyExpand(key); byte[] cipher = new byte[nBytes]; byte[] cryptOutput = new byte[(inputLength - restInput) + nBytes * 2]; int outputLength = cryptOutput.Length; byte[] initVector = new byte[nBytes]; byte[] nextBlock = new byte[nBytes]; SecureRandom scRandom = new SecureRandom(); // Copy plaintext Array into crypt Array System.Array.Copy(plainInput, 0, cryptOutput, 0, inputLength); // Fill Initialization Vector with Random Bytes scRandom.nextBytes(initVector); // Copy first Input Block to nextBlock System.Array.Copy(cryptOutput, 0, nextBlock, 0, nBytes); // XOR Random initVektor with first Input Block nextBlock = CryptobyHelper.xorByteArrays(nextBlock, initVector); // Copy xored prevBlock into first Input Block System.Array.Copy(nextBlock, 0, cryptOutput, 0, nBytes); // Encrypt last BlockArray initVector = encryptCipher(initVector, exKey); // Add the initVector Array in to last BlockArray and encrypt it System.Array.Copy(initVector, 0, cryptOutput, outputLength - nBytes, nBytes); // Add in the first Byte after CryptText the origin length of plaintext Array System.Array.Copy(inputLengthByte, 0, cryptOutput, outputLength - nBytes * 2, 4); // Encrypt every Block in CBC Mode for (int i = 0; i < outputLength - nBytes; i += nBytes) { // Convert i to percent for ProgressBar // percentProgress = (int)(((float)i / (float)(outputLength - nBytes)) * 100); // // Print ProgressBar // if (percentProgress > prevPercent) // { // CryptobyHelper.printProgressBar(percentProgress); // } // prevPercent = percentProgress; // Copy current block in to Cipher Array System.Array.Copy(nextBlock, 0, cipher, 0, nBytes); // Encrypt Cipher cipher = this.encryptCipher(cipher, exKey); // CBC Mode: XOR next PlainBlock with encrypted Cipher if (i + nBytes < outputLength) { System.Array.Copy(cryptOutput, i + nBytes, nextBlock, 0, nBytes); nextBlock = CryptobyHelper.xorByteArrays(nextBlock, cipher); } // Copy Cipher back in decryptOutput Array System.Array.Copy(cipher, 0, cryptOutput, i, nBytes); } // CryptobyHelper.printProgressBar(100); return(cryptOutput); }
/// <summary>Decrypt a byte array in blocks with AES algorithm in CBC mode.</summary> /// <remarks>Decrypt a byte array in blocks with AES algorithm in CBC mode.</remarks> /// <param name="cryptInput">Encrypted byte array to decrypt</param> /// <param name="key">256 Bit key to decrypt cryptInput</param> /// <returns>Return decrypted byte array</returns> public virtual byte[] decrypt(byte[] cryptInput, byte[] key) { int percentProgress; int prevPercent = -1; byte[] exKey = initKeyExpand(key); int outputLength = cryptInput.Length; byte[] decryptOutput = new byte[outputLength]; System.Array.Copy(cryptInput, 0, decryptOutput, 0, outputLength); byte[] cipher = new byte[nBytes]; byte[] inputLengthByte = new byte[nBytes]; byte[] plainOutput; byte[] initVector = new byte[nBytes]; byte[] prevBlock = new byte[nBytes]; // Add the initVector Array in to last BlockArray and encrypt it System.Array.Copy(decryptOutput, outputLength - nBytes, initVector, 0, nBytes); // Decrypt last BlockArray initVector = this.decryptCipher(initVector, exKey); // Copy initVector to prevBlock Array System.Array.Copy(initVector, 0, prevBlock, 0, nBytes); for (int i = 0; i < outputLength - nBytes; i += nBytes) { // // Convert i to percent for ProgressBar // percentProgress = (int)(((float)i / (float)(outputLength - nBytes)) * 100); // // Print ProgressBar // if (percentProgress > prevPercent) // { // CryptobyHelper.printProgressBar(percentProgress); // } // prevPercent = percentProgress; // Copy current block in to Cipher Array System.Array.Copy(decryptOutput, i, cipher, 0, nBytes); // Decrypt Cipher cipher = this.decryptCipher(cipher, exKey); // CBC Mode: XOR next PlainBlock with encrypted Cipher if (i + nBytes < outputLength) { cipher = CryptobyHelper.xorByteArrays(prevBlock, cipher); System.Array.Copy(decryptOutput, i, prevBlock, 0, nBytes); } // Copy Cipher back in current decryptOutput Array System.Array.Copy(cipher, 0, decryptOutput, i, nBytes); } // Read last Index of encryptet Output // and use the Integer Content for lenght of plainOutput System.Array.Copy(decryptOutput, outputLength - nBytes * 2, inputLengthByte, 0, 4); int lengthOriginArray = ByteBuffer.wrap(inputLengthByte).order(ByteOrder.BIG_ENDIAN ).getInt(); try { plainOutput = new byte[lengthOriginArray]; System.Array.Copy(decryptOutput, 0, plainOutput, 0, lengthOriginArray); } catch (Exception) { plainOutput = cryptInput; } // CryptobyHelper.printProgressBar(100); return(plainOutput); }
private static void rsaDecrypterFile(CryptobyConsole console) { // Input Path to File for decryption scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter Path to File for Decryption (Type '" + quit + "' to Escape):"); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { rsaCrypterFile(console); } cryptFilePath = scanner.next(); // Get Bytes from PlainFile try { cryptByte = CryptobyFileManager.getBytesFromFile(cryptFilePath); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); rsaCrypterFile(console); } // Input Path saving Path scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter saving Path for decrypted File (Type '" + quit + "' to Escape):"); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { rsaCrypterFile(console); } plainFilePath = scanner.next(); // Input Path to Key File for decryption scanner = new Scanner(java.lang.System.@in); Console.Out.WriteLine("Enter Path to Private Key File (Type '" + quit + "' to Escape):" ); scanner.useDelimiter("\n"); if (scanner.hasNext(quit)) { rsaCrypterFile(console); } privateKeyPath = scanner.next(); // Get Bytes from Private Key File try { privateKeyByte = CryptobyFileManager.getKeyFromFile(privateKeyPath); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); rsaCrypterFile(console); } catch (FormatException) { Console.Out.WriteLine("Key File format is not correct!"); rsaCrypterFile(console); } // Initial RSA Crypt Object initRSAKeyGen(console); // Encrypt the File with given Key Console.Out.WriteLine("\nDecryption in progress..."); try { plainByte = console.getCore().getCryptAsym().decrypt(cryptByte, privateKeyByte); } catch (Exception) { Console.Out.WriteLine("\nUnable to decrypt this File!!"); plainByte = null; // Press Return for Continues CryptobyHelper.pressEnter(); rsaCrypterFile(console); } Console.Out.WriteLine("\nDecryption finished. Saving File now..."); try { //Put encrypted Bytes to File CryptobyFileManager.putBytesToFile(plainFilePath, plainByte); } catch (System.IO.IOException) { CryptobyHelper.printIOExp(); rsaCrypterFile(console); } Console.Out.WriteLine("\nDecrypted File saved to this Path:"); Console.Out.WriteLine(plainFilePath); // Reset Variables initRSAKeyGen(console); cryptByte = null; plainByte = null; publicKeyByte = null; // Back to Menu rsaCrypter with Enter (Return) Key Console.Out.WriteLine("\nGo back to RSA File Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); rsaCrypterFile(console); }
private static void rsaEncGenKeysText(CryptobyConsole console) { scanner = new Scanner(java.lang.System.@in); string privateKey; string publicKey; // Set Default Key Size keySize = 1024; do { Console.Out.WriteLine("\n"); Console.Out.WriteLine("Choose Key Size in Bit"); Console.Out.WriteLine("----------------------\n"); Console.Out.WriteLine("1 - 1024"); Console.Out.WriteLine("2 - 2048"); Console.Out.WriteLine("3 - 4096"); Console.Out.WriteLine("4 - Back"); Console.Out.Write("Enter Number: "); while (!scanner.hasNextInt()) { Console.Out.Write("That's not a number! Enter 1,2,3 or 4: "); scanner.next(); } choice = scanner.nextInt(); }while (choice < 1 || choice > 4); switch (choice) { case 1: { keySize = 1024; break; } case 2: { keySize = 2048; break; } case 3: { keySize = 4096; break; } case 4: { rsaCrypterText(console); break; } default: { rsaEncGenKeysText(console); break; } } // Input your String Text to encrypt plainByte = scanPlainText(console); // Initial RSA Crypt Object initRSAKeyGen(console); // Get Public Key in Bytecode Console.Out.WriteLine("\nGenerate Private and Public RSA Keys..."); console.getCore().getKeyGenAsym().initGenerator(keySize); publicKeyByte = console.getCore().getKeyGenAsym().getPublicKeyByte(); // Get Public and Private Key as String publicKey = console.getCore().getKeyGenAsym().getPublicKey(); privateKey = console.getCore().getKeyGenAsym().getPrivateKey(); // Encrypt the String Text with given Key Console.Out.WriteLine("\nEncryption in progress..."); cryptByte = console.getCore().getCryptAsym().encrypt(plainByte, publicKeyByte); Console.Out.WriteLine("\nEncryption successfull..."); // Convert crypted byte Array into a Hexcode String charTextHex = CryptobyHelper.bytesToHexStringUpper(cryptByte).ToCharArray(); // Print encrypted Text in Hex Block form Console.Out.WriteLine(CryptobyHelper.printHexBlock("RSA", keySize, charTextHex )); // Print Private Keys Console.Out.WriteLine(CryptobyHelper.printPrivateKeyBlock(privateKey)); // Print Public Keys Console.Out.WriteLine(CryptobyHelper.printPublicKeyBlock(publicKey)); // Back to Menu rsaCrypter with Enter (Return) Key Console.Out.WriteLine("\nGo back to RSA Text Crypter Menu: Press Enter"); CryptobyHelper.pressEnter(); rsaCrypterText(console); }