Source Code : Crypt demo

Java Is Open Source Programming Language You Can Download From Java and Java Libraries From http://www.oracle.com. Click Here to download
We provide this code related to title for you to solve your developing problem easily. Libraries which is import in this program you can download from http://www.oracle.com. Click Here or search from google with Libraries Name you get jar file related it

Crypt demo

      
/* infoScoop OpenSource
 * Copyright (C) 2010 Beacon IT Inc.
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/lgpl-3.0-standalone.html>.
 */

//package org.infoscoop.util;

import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Crypt {

  private static final Crypt thisInstance = new Crypt();
  private static final long serialVersionUID = 7490854493720551678L;
  private static Log log = LogFactory.getLog(Crypt.class);
  public static final byte ENCRYPT = 0;
  public static final byte DECRYPT = 1;
  
  private static SecretKey secretKey;
  
  private Crypt() {
    DESKeySpec dk;
    try {
      dk = new DESKeySpec(new Long(serialVersionUID).toString().getBytes());
      SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
        secretKey = kf.generateSecret(dk);
    } catch (Exception e) {
      log.error("", e);
    }
  }
  
  public static Crypt gerCryptInstance() {
    return thisInstance;
  }
  
  public String doCrypt(byte mode, String str) throws Exception {
    if (Crypt.DECRYPT == mode) {
      return decryptByDES(str);
    } else if (Crypt.ENCRYPT == mode) {
      return encryptByDES(str);
    }
    return "";
  }
  
  private String encryptByDES(String str) throws Exception{
        Cipher c;
    try {
      c = Cipher.getInstance("DES/ECB/PKCS5Padding");
            c.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encrypted = c.doFinal(str.getBytes());

            // convert into  hexadecimal number, and return as character string.
            String result = "";
            for (int i = 0; i < encrypted.length; i++) {
              result += byte2HexStr(encrypted[i]);
            }
            
      return result;
    } catch (InvalidKeyException e) {
      log.error("The information of the private key may be broken.", e);
      throw e;
    } catch (IllegalBlockSizeException e) {
      log.error("The length of data is unjust.", e);
      throw e;
    }
  }
  
  private String decryptByDES(String str) throws Exception{
        Cipher c;
    
    try {
      byte[] tmp = new byte[str.length()/2];
            int index = 0;
            while (index < str.length()) {
              // convert hexadecimal number into decimal number.
              int num = Integer.parseInt(str.substring(index, index + 2), 16);
              
              // convert into signed byte.
              if (num < 128) {
                tmp[index/2] = new Byte(Integer.toString(num)).byteValue();
              } else {
                tmp[index/2] = new Byte(Integer.toString(((num^255)+1)*-1)).byteValue();
              }
              index += 2;
            }
            
            c = Cipher.getInstance("DES/ECB/PKCS5Padding");
            c.init(Cipher.DECRYPT_MODE, secretKey);
            return new String(c.doFinal(tmp));
    } catch (InvalidKeyException e) {
      log.error("The information of the private key may be broken.", e);
      throw e;
    } catch (IllegalBlockSizeException e) {
      log.error("he length of data is unjust.", e);
      throw e;
    }
  }
  
  private String byte2HexStr(byte binary) {
    StringBuffer sb= new StringBuffer();
    int hex;
    
    hex = (int)binary & 0x000000ff;
    if (0 != (hex & 0xfffffff0)) {
      sb.append(Integer.toHexString(hex));
    } else {
      sb.append("0" + Integer.toHexString(hex));
    }
    return sb.toString();
  }
  
  public static String getHash(String data){
    return getHash(data, "SHA-256");
  } 
  
  public static String getHash(String data, String algorithm) {// create a digest from character string
    MessageDigest md = null;
    try{
      md = MessageDigest.getInstance(algorithm);
    }catch(NoSuchAlgorithmException e){
      log.error("", e);
      return null;
    }
    
    byte[] dat = data.getBytes();
    md.update(dat);// calculate a digest from a dat arrangement.
    byte[] digest = md.digest();
    
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < digest.length; i++) {
      int d = digest[i];
      if (d < 0) {// revise it because 128-255 become minus number value with byte type.
        d += 256;
      }
      if (d < 16) {// Because it become one column by a hex digit, if it is 0-15, we add "0" to a head to become two columns.
        sb.append("0");
      }
      sb.append(Integer.toString(d, 16));// display 1 byte of the digest value with hexadecimal two columns
    }
    
    return sb.toString();
  }
}

   
    
    
    
    
    
  

Thank with us