SignatureProfile

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package th.in.oneauthen.signing;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.Security;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Enumeration;

import javax.persistence.NoResultException;

import org.apache.log4j.Logger;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import th.in.oneauthen.object.SignatureProfileDB;
import th.in.oneauthen.object.DAO.SignatureProfileDAO;

/**
 *
 * @author paradorn
 */
public class SignatureProfile {
    private static Logger logger = Logger.getLogger(SignatureProfile.class);

    static{
        Security.addProvider(new BouncyCastleProvider());
    }

    public static final String PKCS12_INSTANCE = "PKCS12";
    public static final String JKS_INSTANCE = "JKS";

    public static SignatureProfile generateNewProfile ( String profileName, byte[] profileKey, String profileKeyPIN, int ownerId ) {
        SignatureProfile profile = null; // String profileName, byte[] profileKey, String profileKeyPIN, int ownerId
        SignatureProfileDB  registeredProfile = null;

        registeredProfile = new SignatureProfileDAO().findByNameAndUserUID(profileName, ownerId);

        if ( registeredProfile == null ) {
            // No profile setting for this user with this name
            // Start keystore validation process
            // Load key store
            X509Certificate cert;
            ArrayList<X509Certificate> certList = new ArrayList<X509Certificate>();
            try {
                KeyStore ks = KeyStore.getInstance(PKCS12_INSTANCE);
                try{
                    ks.load( new ByteArrayInputStream(profileKey) , profileKeyPIN.toCharArray() );
                } catch (Exception e){
                    if (e instanceof IOException && e.getMessage().contains("DerInputStream.getLength()")){
                        ks = KeyStore.getInstance(JKS_INSTANCE);
                        ks.load( new ByteArrayInputStream(profileKey) , profileKeyPIN.toCharArray());
                    }else{
                        logger.error("Key store loading failed !!");
                        logger.debug("Key store loading failed !!", e);

                        return profile;
                    }
                }

                profile = new SignatureProfile();


                Enumeration<String> aliases = ks.aliases();
                while(aliases.hasMoreElements()){
                    // Fetch accessing name from specified key store
                    String alies = aliases.nextElement();
                    if ( ks.isKeyEntry(alies) ){
                        profile.pk = (PrivateKey) ks.getKey(alies, profileKeyPIN.toCharArray());
                        profile.signerCert = (X509Certificate) ks.getCertificate(alies);
                    }
                    cert = (X509Certificate) ks.getCertificate(alies);
                    certList.add(cert);
                }
            }catch (Exception e) {
                logger.error(e);
                return null;
            }

            if (profile.pk == null || certList.size()<0){
                logger.error("Private Key or certificate not found in key store");
                return null;
            }else{
                profile.certificateChain = new X509Certificate[certList.size()];
                profile.certificateChain = certList.toArray(profile.certificateChain);
            }
        } else {
            return null;
        }

        return profile;
    }

    private SignatureProfile () {
    }

    public SignatureProfile ( SignatureProfileDB profileDB ) throws Exception {

        // Load key store
        KeyStore ks = KeyStore.getInstance(PKCS12_INSTANCE);;
        try{
            ks.load( new FileInputStream(profileDB.getProfileKey()) , profileDB.getProfileKeyPIN().toCharArray() );
        } catch (Exception e){
            if (e instanceof IOException && e.getMessage().contains("DerInputStream.getLength()")){
                ks = KeyStore.getInstance(JKS_INSTANCE);
                ks.load( new FileInputStream(profileDB.getProfileKey()) , profileDB.getProfileKeyPIN().toCharArray());
            }else{
                logger.error("Key store loading failed !!");
                logger.debug("Key store loading failed !!", e);
            }
        }

        X509Certificate cert;
        ArrayList<X509Certificate> certList = new ArrayList<X509Certificate>();
        Enumeration<String> aliases = ks.aliases();
        while(aliases.hasMoreElements()){
            // Fetch accessing name from specified key store
            String alies = aliases.nextElement();
            if ( ks.isKeyEntry(alies) ){
                this.pk = (PrivateKey) ks.getKey(alies, profileDB.getProfileKeyPIN().toCharArray());
                this.signerCert = (X509Certificate) ks.getCertificate(alies);
                this.keyStoreCommonName= this.signerCert.getSubjectDN().getName().toString();
            }
            cert = (X509Certificate) ks.getCertificate(alies);
            certList.add(cert);
        }

        if (this.pk == null || certList.size()<0){
            logger.error("Private Key or certificate not found in key store");
        }else{
            this.certificateChain = new X509Certificate[certList.size()];
            this.certificateChain = certList.toArray(this.certificateChain);
        }
        String docPath = profileDB.getProfileDocDir();
        String docBackupPath = profileDB.getProfileBackupDir();
        String signPath = profileDB.getProfileSignDir();

        File docDir, docBackUpDir, signDir;
        if (isNotNull(docPath)){
            docDir = new File(docPath);
            if (docDir.exists() && docDir.isDirectory()){
                this.setInputDir(docDir);
            }else {
              logger.error("Invalid document directory : "+docPath);
            }
        }

        if (isNotNull(docBackupPath)){
            docBackUpDir = new File(docBackupPath);
            if (docBackUpDir.exists() && docBackUpDir.isDirectory()){
                this.setBackupDir(docBackUpDir);
            }else {
                logger.error("Invalid document backup directory : "+docBackupPath);
            }
        }

        if (isNotNull(signPath)){
            signDir = new File(signPath);
            if (signDir.exists() && signDir.isDirectory()){
                this.setOutputDir(signDir);
            }else {
                logger.error("Invalid signed document directory : "+signPath);
            }
        }

        if (profileDB.isSigVisible()){
            File sigImg = new File(profileDB.getSigImg());
            String sigLocation = profileDB.getSigLocation();
            if (sigImg.exists() && sigImg.isFile()){
                this.setSigImg(Files.readAllBytes(sigImg.toPath()));
                if (isSigLocationCorrect(sigLocation)){
                    this.setSignatureLocation(sigLocation);
                    this.setImagePage(profileDB.getSigDisplayPage());
                    this.setIsVisible(true);
                }else{
                    logger.error("Signature location for profile "+profileDB.getProfileName()+" is invalid");
                }
            }else{
                logger.error("Signature Image for profile "+profileDB.getProfileName()+" is not found or not a file");
            }
        }
    }

    String signatureProfileName;
    PrivateKey pk;
    X509Certificate signerCert;
    String keyStoreCommonName;
    X509Certificate[] certificateChain;

    File inputDir;
    File backupDir;
    File outputDir;

    boolean isVisible = false;
    byte[] sigImg;
    String signatureLocation;
    int imagePage;

    public String getKeyStoreCommonName() {
        return keyStoreCommonName;
    }

    public void setKeyStoreCommonName(String keyStoreCommonName) {
        this.keyStoreCommonName = keyStoreCommonName;
    }

    public String getSignatureProfileName() {
        return signatureProfileName;
    }

    public void setSignatureProfileName(String signatureProfileName) {
        this.signatureProfileName = signatureProfileName;
    }

    public PrivateKey getPk() {
        return pk;
    }

    public void setPk(PrivateKey pk) {
        this.pk = pk;
    }

    public X509Certificate getSignerCert() {
        return signerCert;
    }

    public void setSignerCert(X509Certificate signerCert) {
        this.signerCert = signerCert;
    }

    public X509Certificate[] getCertificateChain() {
        return certificateChain;
    }

    public void setCertificateChain(X509Certificate[] certificateChain) {
        this.certificateChain = certificateChain;
    }

    public File getInputDir() {
        return inputDir;
    }

    public void setInputDir(File inputDir) {
        this.inputDir = inputDir;
    }

    public File getBackupDir() {
        return backupDir;
    }

    public void setBackupDir(File backupDir) {
        this.backupDir = backupDir;
    }

    public File getOutputDir() {
        return outputDir;
    }

    public void setOutputDir(File outputDir) {
        this.outputDir = outputDir;
    }

    public boolean isIsVisible() {
        return isVisible;
    }

    public void setIsVisible(boolean isVisible) {
        this.isVisible = isVisible;
    }

    public byte[] getSigImg() {
        return sigImg;
    }

    public void setSigImg(byte[] sigImg) {
        this.sigImg = sigImg;
    }

    public static boolean isNotNull (String val){
        if (val == null || val.length() <=0 )
            return false;
        else
            return true;
    }

    public int getImagePage() {
        return imagePage;
    }

    public void setImagePage(int imagePage) {
        this.imagePage = imagePage-1;
    }

    public String getSignatureLocation() {
        return signatureLocation;
    }

    public void setSignatureLocation(String signatureLocation) {
        this.signatureLocation = signatureLocation;
    }

    public static boolean isSigLocationCorrect (String locationString){
        boolean result = false;

        // location syntax = x0:x1:yo:y1 where x1 must > x0 and y1 must > y0
        if (isNotNull(locationString)){
            String[] coordinate = locationString.split(":");
            try{
                float x0 = Float.parseFloat(coordinate[0]);
                float x1 = Float.parseFloat(coordinate[1]);
                float y0 = Float.parseFloat(coordinate[2]);
                float y1 = Float.parseFloat(coordinate[3]);

//                if(x0<x1 && y0<y1)
//                    result = true;
            }catch (Exception e){}
        }
        return result;
    }

    public float[] getSignatuerCoOrdinate (){
//        if (isSigLocationCorrect(this.signatureLocation)){
            String[] strCoordinate = this.signatureLocation.split(":");
            float[] coordinate = new float[4];
            for (int i=0; i<4; i++)
                coordinate[i] = Float.parseFloat(strCoordinate[i]);

            return coordinate;
//        }else
//            return null;
    }
}