root/tools/routingservice/trunk/src/jp/co/orkney/restlet/security/SecurityHelper.java

package jp.co.orkney.restlet.security;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;

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

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.*;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import jp.co.orkney.restlet.util.Log;

public class SecurityHelper
{

    public static final String PUB_FILE = "public.key";

    public static final String PRI_FILE = "private.key";

    public static final int PRIVATE = 0;

    public static final int PUBLIC = 1;

    public static final String ALGORITHM = "RSA/ECB/PKCS1Padding";

    // public static final String ALGORITHM = "RSA/ECB/OAEPPadding";
    // public static final String ALGORITHM = "SHA1withDSA";

    public static boolean checkAPIKey(String apiKey, String encKey,
            String signature, String clientId, Log log) throws IOException,
            KeyStoreException, CertificateException, NoSuchAlgorithmException,
            NoSuchPaddingException, NoSuchProviderException,
            InvalidKeyException, SignatureException, ShortBufferException,
            IllegalBlockSizeException, BadPaddingException
    {
        boolean isValid = false;
        boolean verifies = false;
        
        // Default path to the keystore file
        String keyStoreFileName = "security/wrs";

        // Default keystore password (you might want to change this)
        String keyStorePassword = "webroutingservice";

        // Load the keystore
        KeyStore keyStore = null;

        keyStore = KeyStore.getInstance("jks");
        FileInputStream keyStoreInputStream = null;

        keyStoreInputStream = new FileInputStream(keyStoreFileName);

        keyStore.load(keyStoreInputStream, keyStorePassword.toCharArray());
        keyStoreInputStream.close();

        BASE64Encoder myB64 = new BASE64Encoder();
        BASE64Decoder b64 = new BASE64Decoder();

        KeyPair kp = getPrivateKey(keyStore, clientId, keyStorePassword
                .toCharArray());

        Security.addProvider(new com.sun.crypto.provider.SunJCE());

        PrivateKey priKey = kp.getPrivate();
        PublicKey pubKey = kp.getPublic();

        Cipher c = null;

        c = Cipher.getInstance(ALGORITHM);

        Signature sig = null;
        sig = Signature.getInstance("SHA1withRSA", "SunRsaSign");
        sig.initVerify(pubKey);

        // byte[] sigToVerify = signature.substring(0,176).getBytes();
        byte[] sigToVerify = b64.decodeBuffer(signature);

        sig.update(apiKey.getBytes());
        verifies = sig.verify(sigToVerify);

        //System.out.println("signature verifies: " + verifies);
        log.write("signature verifies: " + verifies, 2);

        // byte[] text = encKey.substring(0,176).getBytes();
        byte[] text = b64.decodeBuffer(encKey);

        //System.out.println("Encrypting message...");
        log.write("Encrypting message...", 2);

        // text = crypt(c, priKey, text, Cipher.DECRYPT_MODE);
        text = encryptDecrypt("DECRYPT", text, priKey, log);

        String decKey = new String(text);
        //System.out.println("text = " + decKey);
        log.write("text = " + decKey, 2);

        isValid = apiKey.equals(decKey);

        return isValid && verifies;
    }

    public static byte[] crypt(Cipher cipher, Key key, byte[] text, int type)
            throws ShortBufferException, IllegalBlockSizeException,
            BadPaddingException, InvalidKeyException
    {
        byte[] decryptedFileBytes = null;

        cipher.init(type, key);

        int encryptedFileBytesChunkLength = 128;
        int numberOfEncryptedChunks = text.length
                / encryptedFileBytesChunkLength + 1;

        // The limit per chunk is 117 bytes for RSA
        int decryptedFileBytesChunkLength = 100;
        int decryptedFileBytesLength = numberOfEncryptedChunks
                * encryptedFileBytesChunkLength;
        // It looks like we must create the decrypted file as long as the
        // encrypted since RSA need 128 for output

        // Create the decoded byte array
        decryptedFileBytes = new byte[decryptedFileBytesLength];

        // Counters
        int decryptedByteIndex = 0;
        int encryptedByteIndex = 0;

        for (int i = 0; i < numberOfEncryptedChunks; i++)
        {
            if (i < numberOfEncryptedChunks - 1)
            {
                decryptedByteIndex = decryptedByteIndex
                        + cipher.doFinal(text, encryptedByteIndex,
                                encryptedFileBytesChunkLength,
                                decryptedFileBytes, decryptedByteIndex);
                encryptedByteIndex = encryptedByteIndex
                        + encryptedFileBytesChunkLength;
            }
            else
            {
                decryptedByteIndex = decryptedByteIndex
                        + cipher.doFinal(text, encryptedByteIndex, text.length
                                - encryptedByteIndex, decryptedFileBytes,
                                decryptedByteIndex);
            }
        }

        // decryptedFileBytes = cipher.doFinal(text);

        return decryptedFileBytes;
    }

    public static Key getKey(String filename, int type)
            throws FileNotFoundException
    {
        FileInputStream fis = null;
        fis = new FileInputStream(filename);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int b;
        try
        {
            while ((b = fis.read()) != -1)
            {
                baos.write(b);
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        byte[] keydata = baos.toByteArray();

        Key key = null;
        try
        {
            KeyFactory kf = KeyFactory.getInstance("RSA", "BC");
            switch (type)
            {
            case PRIVATE:
                PKCS8EncodedKeySpec encodedPrivateKey = new PKCS8EncodedKeySpec(
                        keydata);
                key = kf.generatePrivate(encodedPrivateKey);
                return key;
            case PUBLIC:
                X509EncodedKeySpec encodedPublicKey = new X509EncodedKeySpec(
                        keydata);
                key = kf.generatePublic(encodedPublicKey);
                return key;
            }
        }
        catch (NoSuchAlgorithmException e)
        {
            e.printStackTrace();
        }
        catch (NoSuchProviderException e)
        {
            e.printStackTrace();
        }
        catch (InvalidKeySpecException e)
        {
            e.printStackTrace();
        }

        return key;
    }

    // From http://javaalmanac.com/egs/java.security/GetKeyFromKs.html
    public static KeyPair getPrivateKey(KeyStore keystore, String alias,
            char[] password)
    {
        try
        {
            // Get private key
            Key key = keystore.getKey(alias, password);
            if (key instanceof PrivateKey)
            {
                // Get certificate of public key
                Certificate cert = keystore.getCertificate(alias);

                // Get public key
                PublicKey publicKey = cert.getPublicKey();

                // Return a key pair
                return new KeyPair(publicKey, (PrivateKey) key);
            }
        }
        catch (UnrecoverableKeyException e)
        {
        }
        catch (NoSuchAlgorithmException e)
        {
        }
        catch (KeyStoreException e)
        {
        }
        return null;
    }

    public static byte[] encryptDecrypt(String type, byte[] data, Key secretKey, Log log)
            throws ShortBufferException, NoSuchAlgorithmException,
            NoSuchPaddingException, InvalidKeyException,
            IllegalBlockSizeException, BadPaddingException, IOException
    {
        byte cryptedCipherText[] = null;

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        //System.out.println("Provider is-->" + cipher.getProvider().getInfo());
        log.write("Provider is-->" + cipher.getProvider().getInfo(), 2);
        int j = 0;
        int k = 0;
        boolean flag = false;
        byte[] bufferedEncryption = null;

        if (type.equals("ENCRYPT"))
        {
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            j = 112;
            k = 112;
            bufferedEncryption = new byte[k];

        }
        else
        {
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            j = 128;
            k = 128;

            bufferedEncryption = new byte[k];
        }

        int cipherlength = cipher.getOutputSize(data.length);
        //System.out.println("data size-->" + data.length);
        log.write("data size-->" + data.length, 2);
        //System.out.println("cipher size-->" + cipherlength);
        log.write("cipher size-->" + cipherlength, 2);
        cryptedCipherText = new byte[cipherlength];

        ByteArrayOutputStream cryptedTextBuffer = new ByteArrayOutputStream();

        int count = 0;
        int i = 0;

        while (i < data.length)
        {
            System.arraycopy(data, i, bufferedEncryption, 0, j);
            //System.out.println("sizeof bufferedencryption-->"
                //    + bufferedEncryption.length);
            log.write("sizeof bufferedencryption-->"
                            + bufferedEncryption.length, 2);
            cryptedCipherText = cipher.doFinal(bufferedEncryption);
            count += cryptedCipherText.length;
            //System.out.println("Length-->" + count);
            log.write("Length-->" + count, 2);
            cryptedTextBuffer.write(cryptedCipherText);
            //System.out.println("i-->" + i);
            log.write("i-->" + i, 2);

            i += k;
            bufferedEncryption = new byte[k];
            if (flag == true)
                break;
            if (i + k > data.length)
            {
                j = data.length - i;
                flag = true;
            }

        }

        cryptedCipherText = cryptedTextBuffer.toByteArray();

        // cryptedCipherText = cipher.doFinal(data);

        return cryptedCipherText;
    }

}