java encrypt

package encryption.algorithm.base;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;



import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class RSAFileUtility {


private static final String ORIGIN_FILE_PATH = "c:/plainText.txt";
   private static final String ENCRYPTED_FILE_PATH = "c:/cipherText.txt";
   private static final String DECRYPTED_FILE_PATH = "c:/decryptedText.txt";

/*
* cryptographic algorithm
*/
private static final String ALGORITHM = "RSA";
// private static final String ALGORITHM = "RSA/ECB/PKCS1Padding";


/*
* signature algorithm
*/
//    public static final String SIGNATURE_ALGORITHM = "MD5withRSA"; 
    public static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";
   
    /*
     * message digest algorithm
     */
//    public static final String MESSAGE_DIGEST_ALGORITHM = "MD5";
    public static final String MESSAGE_DIGEST_ALGORITHM = "SHA";
   
private static final String PUBLICKEY = "PublicKey";
private static final String PRIVATEKEY = "PrivateKey";


/**
* Generate keyMap that include public key and private key
* @return
* @throws Exception
*/
public static Map<String, String> initKey() throws Exception {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
keyGen.initialize(1024);
KeyPair keyPair = keyGen.generateKeyPair();
PublicKey publickey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();

Map<String,String> keyMap = new HashMap<String, String>();
keyMap.put(PUBLICKEY, encryptByBase64(publickey));
keyMap.put(PRIVATEKEY, encryptByBase64(privateKey));
return keyMap;

}

/**
* Encrypt key by Base64
* @param key
* @return
*/
public static String encryptByBase64(Key key){
return new BASE64Encoder().encodeBuffer(key.getEncoded());
}

/**
* Decrypt key by Base64
* @param key
* @return
* @throws IOException
*/
public static byte[] decryptByBase64(String key) throws IOException{
return new BASE64Decoder().decodeBuffer(key);
}

/**
* Sign
* @param text
* @param key
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
* @throws SignatureException
*/
public static byte[] sign(String text,PrivateKey key) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException{
byte[] textByte = text.getBytes();
Signature signInstance = Signature.getInstance(SIGNATURE_ALGORITHM);
signInstance.initSign(key);
signInstance.update(textByte);
byte[] signText = signInstance.sign();
return signText;
}


public static byte[] sign(byte[] text,PrivateKey key) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException{
Signature signInstance = Signature.getInstance(SIGNATURE_ALGORITHM);
signInstance.initSign(key);
signInstance.update(text);
byte[] signText = signInstance.sign();
return signText;
}



    /**
     * Encrypt a text using public key.
     * @param text The original unencrypted text
     * @param key The public key
     * @return Encrypted text
     * @throws java.lang.Exception
     */
    public static byte[] encrypt(byte[] text, PublicKey key) throws Exception
    {
        byte[] cipherText = null;
        try
        {
            // get an RSA cipher object and print the provider
            Cipher cipher = Cipher.getInstance("RSA");

            // encrypt the plaintext using the public key
            cipher.init(Cipher.ENCRYPT_MODE, key);
            cipherText = cipher.doFinal(text);
        }
        catch (Exception e)
        {
         
            throw e;
        }
        return cipherText;
    }

    /**
     * Decrypt text using private key
     * @param text The encrypted text
     * @param key The private key
     * @return The unencrypted text
     * @throws java.lang.Exception
     */
    public static byte[] decrypt(byte[] text, PrivateKey key) throws Exception
    {
        byte[] dectyptedText = null;
        try
        {
            // decrypt the text using the private key
            Cipher cipher = Cipher.getInstance("RSA");
          
            cipher.init(Cipher.DECRYPT_MODE, key);
            dectyptedText = cipher.doFinal(text);
        }
        catch (Exception e)
        {
         
            throw e;
        }
        return dectyptedText;

    }

/**
* Verify signature
* @param text
* @param key
* @param signature
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
* @throws SignatureException
*/
public static boolean verifySign(byte[] text, PublicKey key, byte[] signature) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException{
Signature sign = Signature.getInstance(SIGNATURE_ALGORITHM);
sign.initVerify(key);
sign.update(text);
boolean verifyResult = sign.verify(signature);
return verifyResult;
}

  public static void encryptDecryptFile(String srcFileName, String destFileName, Key key, int cipherMode) throws Exception
    {
        OutputStream outputWriter = null;
        InputStream inputReader = null;
        try
        {
            Cipher cipher = Cipher.getInstance("RSA");
            String textLine = null;
            //RSA encryption data size limitations are slightly less than the key modulus size,
            //depending on the actual padding scheme used (e.g. with 1024 bit (128 byte) RSA key,
            //the size limit is 117 bytes for PKCS#1 v 1.5 padding. (http://www.jensign.com/JavaScience/dotnet/RSAEncrypt/)
            byte[] buf = cipherMode == Cipher.ENCRYPT_MODE? new byte[100] : new byte[128];
            int bufl;
            // init the Cipher object for Encryption...
            cipher.init(cipherMode, key);

            // start FileIO
            outputWriter = new FileOutputStream(destFileName);
            inputReader = new FileInputStream(srcFileName);
            while ( (bufl = inputReader.read(buf)) != -1)
            {
                byte[] encText = null;
                if (cipherMode == Cipher.ENCRYPT_MODE)
                {
                      encText = encrypt(copyBytes(buf,bufl),(PublicKey)key);
                }
                else
                {
          
//                        System.out.println("buf = " + new BASE64Encoder().encode(buf));
                 
                    encText = decrypt(copyBytes(buf,bufl),(PrivateKey)key);
                }
                outputWriter.write(encText);
         
//                     System.out.println("encText = " + new BASE64Encoder().encode(encText));
          
            }
            outputWriter.flush();

        }
        catch (Exception e)
        {
          
            throw e;
        }
        finally
        {
            try
            {
                if (outputWriter != null)
                {
                    outputWriter.close();
                }
                if (inputReader != null)
                {
                    inputReader.close();
                }
            }
            catch (Exception e)
            {
                // do nothing...
            } // end of inner try, catch (Exception)...
        }
    }

    public static byte[] copyBytes(byte[] arr, int length)
    {
        byte[] newArr = null;
        if (arr.length == length)
        {
            newArr = arr;
        }
        else
        {
            newArr = new byte[length];
            for (int i = 0; i < length; i++)
            {
                newArr[i] = (byte) arr[i];
            }
        }
        return newArr;
    }

/**
* Generate MessageDigest
* @param text
* @return
* @throws NoSuchAlgorithmException
*/
public static byte[] generateMessageDigest(String fileName) throws Exception{
FileInputStream fi = new FileInputStream(fileName);
byte[] bufferArray = new byte[100];
int bufferSize = 0;
byte[] digest = null;
while((bufferSize=fi.read(bufferArray)) != -1){
MessageDigest md = MessageDigest.getInstance(MESSAGE_DIGEST_ALGORITHM);
md.update(copyBytes(bufferArray, bufferSize));
digest = md.digest();
}

return digest;
}


public static String readFile(String fileName) throws Exception{
BufferedReader bf = new BufferedReader(new FileReader(fileName));
String s = "";
String plainText = "";
while((s=bf.readLine()) != null){
plainText = plainText + s;
}
return plainText;
}


public static String inputFile(String fileName) throws Exception{
FileInputStream fi = new FileInputStream(fileName);
byte[] bufferArray = new byte[100];
int bufferSize = 0;
String text="";

while((bufferSize=fi.read(bufferArray)) !=  -1){
String s = new BASE64Encoder().encode(copyBytes(bufferArray, bufferSize));
text = text + s;
}
return text;
}

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



System.out.println("plainText:\n" + readFile(ORIGIN_FILE_PATH));

//A Generate public key and private key
Map<String, String> aKeyMap = RSAFileUtility.initKey();
String aPublickey = (String)aKeyMap.get(PUBLICKEY);
String aPrivateKey = (String)aKeyMap.get(PRIVATEKEY);
        System.err.println("Mr A Public key:\n" + aPublickey);  
        System.err.println("Mr A Private key:\n" + aPrivateKey);  
       
    //B Generate public key and private key
Map<String, String> bKeyMap = RSAFileUtility.initKey();
String bPublickey = (String)bKeyMap.get(PUBLICKEY);
String bPrivateKey = (String)bKeyMap.get(PRIVATEKEY);
        System.err.println("Mr B Public key:\n" + bPublickey);  
        System.err.println("Mr B Private key:\n" + bPrivateKey);  
       
        // A send A public key to B
        // B send B public key to A
       

//Generate message digest
byte[] messageDigest = RSAFileUtility.generateMessageDigest(ORIGIN_FILE_PATH);
       
       
        //A get private key
        PKCS8EncodedKeySpec aPrivateKeySpec = new PKCS8EncodedKeySpec(decryptByBase64(aPrivateKey));
        KeyFactory facInstance = KeyFactory.getInstance(ALGORITHM);
        PrivateKey aPrivateKeyCopy = facInstance.generatePrivate(aPrivateKeySpec);
       
        //A get public key
        X509EncodedKeySpec bPublicKeySpec = new X509EncodedKeySpec(decryptByBase64(bPublickey));
        PublicKey bPublicKeyCopy = facInstance.generatePublic(bPublicKeySpec);
       

        //encrypt by B public key
        RSAFileUtility.encryptDecryptFile(ORIGIN_FILE_PATH, ENCRYPTED_FILE_PATH, bPublicKeyCopy, Cipher.ENCRYPT_MODE);
   
       
        //sign by A private key
        byte[] signText = RSAFileUtility.sign(messageDigest, aPrivateKeyCopy);
  
       
        System.out.println("encryptText:\n" + inputFile(ENCRYPTED_FILE_PATH));
     

       
        //A send cipherText and signText to B

       
        //B get private key
        PKCS8EncodedKeySpec bPrivateKeySpec = new PKCS8EncodedKeySpec(decryptByBase64(bPrivateKey));
        PrivateKey bPrivateKeyCopy = facInstance.generatePrivate(bPrivateKeySpec);
       
        //B get public key
        X509EncodedKeySpec aPublicKeySpec = new X509EncodedKeySpec(decryptByBase64(aPublickey));
        PublicKey aPublicKeyCopy = facInstance.generatePublic(aPublicKeySpec);
       
        boolean verifySign = RSAFileUtility.verifySign(messageDigest, aPublicKeyCopy, signText);
        if(verifySign){
        System.err.println("Signature is right!");
        RSAFileUtility.encryptDecryptFile(ENCRYPTED_FILE_PATH, DECRYPTED_FILE_PATH, bPrivateKeyCopy, Cipher.DECRYPT_MODE);
        System.out.println("decryptedText:\n" + readFile(DECRYPTED_FILE_PATH));
       
        }
       





     
       

    
    
       
       

       


}

}