I am trying to move a project from C# to Java for a learning exercise. I am still very new to Java, but I have a TripleDES class in C# that encrypts strings and returns a string value of the encrypted byte array. Here is my C# code:
using System;
using System.IO;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
namespace tDocc.Classes
{
/// <summary>
/// Triple DES encryption class
/// </summary>
public static class TripleDES
{
private static byte[] key = { 110, 32, 73, 24, 125, 66, 75, 18, 79, 150, 211, 122, 213, 14, 156, 136, 171, 218, 119, 240, 81, 142, 23, 4 };
private static byte[] iv = { 25, 117, 68, 23, 99, 78, 231, 219 };
/// <summary>
/// Encrypt a string to an encrypted byte array
/// </summary>
/// <param name="plainText">Text to encrypt</param>
/// <returns>Encrypted byte array</returns>
public static byte[] Encrypt(string plainText)
{
UTF8Encoding utf8encoder = new UTF8Encoding();
byte[] inputInBytes = utf8encoder.GetBytes(plainText);
TripleDESCryptoServiceProvider tdesProvider = new TripleDESCryptoServiceProvider();
ICryptoTransform cryptoTransform = tdesProvider.CreateEncryptor(key, iv);
MemoryStream encryptedStream = new MemoryStream();
CryptoStream cryptStream = new CryptoStream(encryptedStream, cryptoTransform, CryptoStreamMode.Write);
cryptStream.Write(inputInBytes, 0, inputInBytes.Length);
cryptStream.FlushFinalBlock();
encryptedStream.Position = 0;
byte[] result = new byte[encryptedStream.Length];
encryptedStream.Read(result, 0, (int)encryptedStream.Length);
cryptStream.Close();
return result;
}
/// <summary>
/// Decrypt a byte array to a string
/// </summary>
/// <param name="inputInBytes">Encrypted byte array</param>
/// <returns>Decrypted string</returns>
public static string Decrypt(byte[] inputInBytes)
{
UTF8Encoding utf8encoder = new UTF8Encoding();
TripleDESCryptoServiceProvider tdesProvider = new TripleDESCryptoServiceProvider();
ICryptoTransform cryptoTransform = tdesProvider.CreateDecryptor(key, iv);
MemoryStream decryptedStream = new MemoryStream();
CryptoStream cryptStream = new CryptoStream(decryptedStream, cryptoTransform, CryptoStreamMode.Write);
cryptStream.Write(inputInBytes, 0, inputInBytes.Length);
cryptStream.FlushFinalBlock();
decryptedStream.Position = 0;
byte[] result = new byte[decryptedStream.Length];
decryptedStream.Read(result, 0, (int)decryptedStream.Length);
cryptStream.Close();
UTF8Encoding myutf = new UTF8Encoding();
return myutf.GetString(result);
}
/// <summary>
/// Decrypt an encrypted string
/// </summary>
/// <param name="text">Encrypted text</param>
/// <returns>Decrypted string</returns>
public static string DecryptText(string text)
{
if (text == "")
{
return text;
}
return Decrypt(Convert.FromBase64String(text));
}
/// <summary>
/// Encrypt a string
/// </summary>
/// <param name="text">Unencrypted text</param>
/// <returns>Encrypted string</returns>
public static string EncryptText(string text)
{
if (text == "")
{
return text;
}
return Convert.ToBase64String(Encrypt(text));
}
}
/// <summary>
/// Random number generator
/// </summary>
public static class RandomGenerator
{
/// <summary>
/// Generate random number
/// </summary>
/// <param name="
length">Number of randomizations</param>
/// <returns>Random number</returns>
public static int GenerateNumber(int length)
{
byte[] randomSeq = new byte[length];
new RNGCryptoServiceProvider().GetBytes(randomSeq);
int code = Environment.TickCount;
foreach (byte b in randomSeq)
{
code += (int)b;
}
return code;
}
}
/// <summary>
/// Hash generator class
/// </summary>
public static class Hasher
{
/// <summary>
/// Hash type
/// </summary>
public enum eHashType
{
/// <summary>
/// MD5 hash. Quick but collisions are more likely. This should not be used for anything important
/// </summary>
MD5 = 0,
/// <summary>
/// SHA1 hash. Quick and secure. This is a popular method for hashing passwords
/// </summary>
SHA1 = 1,
/// <summary>
/// SHA256 hash. Slower than SHA1, but more secure. Used for encryption keys
/// </summary>
SHA256 = 2,
/// <summary>
/// SHA348 hash. Even slower than SHA256, but offers more security
/// </summary>
SHA348 = 3,
/// <summary>
/// SHA512 hash. Slowest but most secure. Probably overkill for most applications
/// </summary>
SHA512 = 4,
/// <summary>
/// Derrived from MD5, but only returns 12 digits
/// </summary>
Digit12 = 5
}
/// <summary>
/// Hashes text using a specific hashing method
/// </summary>
/// <param name="text">Input text</param>
/// <param name="hash">Hash method</param>
/// <returns>Hashed text</returns>
public static string GetHash(string text, eHashType hash)
{
if (text == "")
{
return text;
}
if (hash == eHashType.MD5)
{
MD5CryptoServiceProvider hasher = new MD5CryptoServiceProvider();
return ByteToHex(hasher.ComputeHash(Encoding.ASCII.GetBytes(text)));
}
else if (hash == eHashType.SHA1)
{
SHA1Managed hasher = new SHA1Managed();
return ByteToHex(hasher.ComputeHash(Encoding.ASCII.GetBytes(text)));
}
else if (hash == eHashType.SHA256)
{
SHA256Managed hasher = new SHA256Managed();
return ByteToHex(hasher.ComputeHash(Encoding.ASCII.GetBytes(text)));
}
else if (hash == eHashType.SHA348)
{
SHA384Managed hasher = new SHA384Managed();
return ByteToHex(hasher.ComputeHash(Encoding.ASCII.GetBytes(text)));
}
else if (hash == eHashType.SHA512)
{
SHA512Managed hasher = new SHA512Managed();
return ByteToHex(hasher.ComputeHash(Encoding.ASCII.GetBytes(text)));
}
else if (hash == eHashType.Digit12)
{
MD5CryptoServiceProvider hasher = new MD5CryptoServiceProvider();
string newHash = ByteToHex(hasher.ComputeHash(Encoding.ASCII.GetBytes(text)));
return newHash.Substring(0, 12);
}
return "";
}
/// <summary>
/// Generates a hash based on a file's contents. Used for detecting changes to a file and testing for duplicate files
/// </summary>
/// <param name="info">FileInfo object for the file to be hashed</param>
/// <param name="hash">Hash method</param>
/// <returns>Hash string representing the contents of the file</returns>
public static string GetHash(FileInfo info, eHashType hash)
{
FileStream hashStream = new FileStream(info.FullName, FileMode.Open, FileAccess.Read);
string hashString = "";
if (hash == eHashType.MD5)
{
MD5CryptoServiceProvider hasher = new MD5CryptoServiceProvider();
hashString = ByteToHex(hasher.ComputeHash(hashStream));
}
else if (hash == eHashType.SHA1)
{
SHA1Managed hasher = new SHA1Managed();
hashString = ByteToHex(hasher.ComputeHash(hashStream));
}
else if (hash == eHashType.SHA256)
{
SHA256Managed hasher = new SHA256Managed();
hashString = ByteToHex(hasher.ComputeHash(hashStream));
}
else if (hash == eHashType.SHA348)
{
SHA384Managed hasher = new SHA384Managed();
hashString = ByteToHex(hasher.ComputeHash(hashStream));
}
else if (hash == eHashType.SHA512)
{
SHA512Managed hasher = new SHA512Managed();
hashString = ByteToHex(hasher.ComputeHash(hashStream));
}
hashStream.Close();
hashStream.Dispose();
hashStream = null;
return hashString;
}
/// <summary>
/// Converts a byte array to a hex string
/// </summary>
/// <param name="data">Byte array</param>
/// <returns>Hex string</returns>
public static string ByteToHex(byte[] data)
{
StringBuilder builder = new StringBuilder();
foreach (byte hashByte in data)
{
builder.Append(string.Format("{0:X1}", hashByte));
}
return builder.ToString();
}
/// <summary>
/// Converts a hex string to a byte array
/// </summary>
/// <param name="hexString">Hex string</param>
/// <returns>Byte array</returns>
public static byte[] HexToByte(string hexString)
{
byte[] returnBytes = new byte[hexString.
Length / 2];
for (int i = 0; i <= returnBytes.
Length - 1; i++)
{
returnBytes[i] = byte.Parse(hexString.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
}
return returnBytes;
}
}
}
And her is what I've got for Java code so far, but I'm getting the error "Input
length must be multiple of 8 when decrypting with padded cipher" when I
run the test on this:
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import com.tdocc.utils.Base64;
public class TripleDES {
private static byte[] keyBytes = { 110, 32, 73, 24, 125, 66, 75, 18, 79, (byte)150, (byte)211, 122, (byte)213, 14, (byte)156, (byte)136, (byte)171, (byte)218, 119, (byte)240, 81, (byte)142, 23, 4 };
private static byte[] ivBytes = { 25, 117, 68, 23, 99, 78, (byte)231, (byte)219 };
public static String encryptText(String plainText) {
try {
if (plainText.isEmpty()) return plainText;
return Base64.decode(TripleDES.encrypt(plainText)).toString();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static byte[] encrypt(String plainText) throws InvalidKeyException, InvalidAlgorithmParameterException, NoSuchPaddingException {
try {
final SecretKey key = new SecretKeySpec(keyBytes, "DESede");
final IvParameterSpec iv = new IvParameterSpec(ivBytes);
final Cipher cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key, iv);
final byte[] plainTextBytes = plainText.getBytes("utf-8");
final byte[] cipherText = cipher.doFinal(plainTextBytes);
return cipherText;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String decryptText(String message) {
try {
if (message.isEmpty()) return message;
else return TripleDES.decrypt(message.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String decrypt(byte[] message) {
try {
final SecretKey key = new SecretKeySpec(keyBytes, "DESede");
final IvParameterSpec iv = new IvParameterSpec(ivBytes);
final Cipher cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, key, iv);
final byte[] plainText = cipher.doFinal(message);
return plainText.toString();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
