Sunday, March 31, 2013

Password Encryption Decryption using PBE With MD5 And DES algorithm in java



package com.swain.cell;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

public class Helper {

       public static Cipher dcipher, ecipher;

       // Responsible for setting, initializing this object's encrypter and
       // decrypter Chipher instances
       Helper(String passPhrase) {

              // 8-bytes Salt
              byte[] salt = { (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32,
                           (byte) 0x56, (byte) 0x34, (byte) 0xE3, (byte) 0x03 };

              // Iteration count
              int iterationCount = 19;

              try {
                     // Generate a temporary key. In practice, you would save this key
                     // Encrypting with DES Using a Pass Phrase
                     KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(), salt,
                                  iterationCount);
                     SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES")
                                  .generateSecret(keySpec);

                     ecipher = Cipher.getInstance(key.getAlgorithm());
                     dcipher = Cipher.getInstance(key.getAlgorithm());

                     // Prepare the parameters to the cipthers
                     AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt,
                                  iterationCount);

                     ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
                     dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);

              } catch (InvalidAlgorithmParameterException e) {
                     System.out.println("EXCEPTION: InvalidAlgorithmParameterException");
              } catch (InvalidKeySpecException e) {
                     System.out.println("EXCEPTION: InvalidKeySpecException");
              } catch (NoSuchPaddingException e) {
                     System.out.println("EXCEPTION: NoSuchPaddingException");
              } catch (NoSuchAlgorithmException e) {
                     System.out.println("EXCEPTION: NoSuchAlgorithmException");
              } catch (InvalidKeyException e) {
                     System.out.println("EXCEPTION: InvalidKeyException");
              }
       }

       // Encrpt Password
       @SuppressWarnings("unused")
       protected String encrypt(String str) {
              try {
                     // Encode the string into bytes using utf-8
                     byte[] utf8 = str.getBytes("UTF8");
                     // Encrypt
                     byte[] enc = ecipher.doFinal(utf8);
                     // Encode bytes to base64 to get a string
                     return new sun.misc.BASE64Encoder().encode(enc);

              } catch (BadPaddingException e) {
              } catch (IllegalBlockSizeException e) {
              } catch (UnsupportedEncodingException e) {
              }
              return null;
       }

       // Decrpt password
       // To decrypt the encryted password
       protected String decrypt(String str) {
              Cipher dcipher = null;
              try {
                     byte[] salt = { (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32,
                                  (byte) 0x56, (byte) 0x34, (byte) 0xE3, (byte) 0x03 };
                     int iterationCount = 19;
                     try {
                           String passPhrase = "";
                           KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(),
                                         salt, iterationCount);
                           SecretKey key = SecretKeyFactory
                                         .getInstance("PBEWithMD5AndDES")
                                         .generateSecret(keySpec);
                           dcipher = Cipher.getInstance(key.getAlgorithm());
                           // Prepare the parameters to the cipthers
                           AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt,
                                         iterationCount);
                           dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
                     } catch (InvalidAlgorithmParameterException e) {
                           System.out
                                         .println("EXCEPTION: InvalidAlgorithmParameterException");
                     } catch (InvalidKeySpecException e) {
                           System.out.println("EXCEPTION: InvalidKeySpecException");
                     } catch (NoSuchPaddingException e) {
                           System.out.println("EXCEPTION: NoSuchPaddingException");
                     } catch (NoSuchAlgorithmException e) {
                           System.out.println("EXCEPTION: NoSuchAlgorithmException");
                     } catch (InvalidKeyException e) {
                           System.out.println("EXCEPTION: InvalidKeyException");
                     }
                     // Decode base64 to get bytes
                     byte[] dec = new sun.misc.BASE64Decoder().decodeBuffer(str);
                     // Decrypt
                     byte[] utf8 = dcipher.doFinal(dec);
                     // Decode using utf-8
                     return new String(utf8, "UTF8");
              } catch (BadPaddingException e) {
              } catch (IllegalBlockSizeException e) {
              } catch (UnsupportedEncodingException e) {
              } catch (IOException e) {
              }
              return null;
       }

       /**
        * @param args
        */
       public static void main(String[] args) {
              try {

                     // Create encrypter/decrypter class
                     System.out.println("Inside Helper");
                     Helper encrypter = new Helper("");

                     // Pass the word to be Encrypted to Encrypt()
                     System.out.println("encrypt the String: SimplePassword");
                     String encrypted = encrypter.encrypt("SimplePassword");
                     System.out.println("encrypted String:" + encrypted);

                     // Pass the encrypted word to be Decrypted to Decrypt()
                     String decrypted = encrypter.decrypt(encrypted);
                     System.out.println("decrypted String:" + decrypted);
              } catch (Exception e) {
              }
       }

}


If above code  is not working please use below code.

Using Apache Base64..




import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

import org.apache.commons.codec.binary.Base64;

public class Helper {
public static Cipher dcipher, ecipher;

Helper(String passPhrase) {

byte[] salt = { (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32, (byte) 0x56, (byte) 0x34, (byte) 0xE3, (byte) 0x03 };

int iterationCount = 19;

try {
KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(), salt, iterationCount);
SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(keySpec);

ecipher = Cipher.getInstance(key.getAlgorithm());
dcipher = Cipher.getInstance(key.getAlgorithm());

AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt, iterationCount);

ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);

} catch (InvalidAlgorithmParameterException e) {
System.out.println("EXCEPTION: InvalidAlgorithmParameterException");
} catch (InvalidKeySpecException e) {
System.out.println("EXCEPTION: InvalidKeySpecException");
} catch (NoSuchPaddingException e) {
System.out.println("EXCEPTION: NoSuchPaddingException");
} catch (NoSuchAlgorithmException e) {
System.out.println("EXCEPTION: NoSuchAlgorithmException");
} catch (InvalidKeyException e) {
System.out.println("EXCEPTION: InvalidKeyException");
}
}

protected byte[] encrypt(String str) {
try {
byte[] utf8 = str.getBytes("UTF8");
byte[] enc = ecipher.doFinal(utf8);
return new Base64().encode(enc);

} catch (BadPaddingException e) {
} catch (IllegalBlockSizeException e) {
} catch (UnsupportedEncodingException e) {
}
return null;
}

protected String decrypt(byte[] str) {
Cipher dcipher = null;
try {
byte[] salt = { (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32, (byte) 0x56, (byte) 0x34, (byte) 0xE3, (byte) 0x03 };
int iterationCount = 19;
try {
String passPhrase = "";
KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(), salt, iterationCount);
SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(keySpec);
dcipher = Cipher.getInstance(key.getAlgorithm());
AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt, iterationCount);
dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
} catch (InvalidAlgorithmParameterException e) {
System.out.println("EXCEPTION: InvalidAlgorithmParameterException");
} catch (InvalidKeySpecException e) {
System.out.println("EXCEPTION: InvalidKeySpecException");
} catch (NoSuchPaddingException e) {
System.out.println("EXCEPTION: NoSuchPaddingException");
} catch (NoSuchAlgorithmException e) {
System.out.println("EXCEPTION: NoSuchAlgorithmException");
} catch (InvalidKeyException e) {
System.out.println("EXCEPTION: InvalidKeyException");
}
byte[] dec;
dec = (byte[]) new Base64().decode(str);
byte[] utf8 = dcipher.doFinal(dec);
return new String(utf8, "UTF8");

} catch (BadPaddingException e) {
} catch (IllegalBlockSizeException e) {
} catch (UnsupportedEncodingException e) {

return null;
}

/**
* @param args
*/
public static void main(String[] args) {
try {

System.out.println("Inside Helper");
Helper encrypter = new Helper("");

System.out.println("encrypt the String: SimplePassword");
byte[] encrypted = encrypter.encrypt("SimplePassword");
String s = new String(encrypted, "UTF8");
System.out.println("encrypted String:" + s);

// Pass the encrypted word to be Decrypted to Decrypt()
String decrypted = encrypter.decrypt(encrypted);
System.out.println("decrypted String:" + decrypted);
} catch (Exception e) {
}
}

}

How to Calculate the Future Investment Value of Investment.

Below java program for calculate future investment value. Here calculate s using the formula futureInvestmentValue =investmentAmount x (...