/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.module.encryption.cipher.asymetric;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.file.Files;
import java.security.GeneralSecurityException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import org.apache.commons.codec.binary.Base64;

/**
 *
 * @author STEPHANIE
 */
public class AsymetricCryptography {

    private Cipher cipher;

    public AsymetricCryptography() throws NoSuchAlgorithmException, NoSuchPaddingException {
//        this.cipher = Cipher.getInstance("RSA");
        this.cipher = Cipher.getInstance("RSA");
    }

    private PrivateKey getPrivate(String filename) throws Exception {
        byte[] keyBytes = Files.readAllBytes(new File(filename).toPath());
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        return kf.generatePrivate(spec);
    }

    private PublicKey getPublic(String filename) throws Exception {
        byte[] keyBytes = Files.readAllBytes(new File(filename).toPath());
        X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        return kf.generatePublic(spec);
    }

    private void encryptFile(byte[] input, File output, PrivateKey key)
            throws IOException, GeneralSecurityException {
        this.cipher.init(Cipher.ENCRYPT_MODE, key);
        writeToFile(output, this.cipher.doFinal(input));
    }

    private void decryptFile(byte[] input, File output, PublicKey key) {
        try {
            this.cipher.init(Cipher.DECRYPT_MODE, key);
            writeToFile(output, this.cipher.doFinal(input));
        } catch (InvalidKeyException | IllegalBlockSizeException | BadPaddingException | IOException ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        }
    }

    private void writeToFile(File output, byte[] toWrite)
            throws IllegalBlockSizeException, BadPaddingException, IOException {
        FileOutputStream fos = new FileOutputStream(output);
        fos.write(toWrite);
        fos.flush();
        fos.close();
    }

    private String encryptText(String msg, PrivateKey key)
            throws NoSuchAlgorithmException, NoSuchPaddingException,
            UnsupportedEncodingException, IllegalBlockSizeException,
            BadPaddingException, InvalidKeyException {
        this.cipher.init(Cipher.ENCRYPT_MODE, key);
        return Base64.encodeBase64String(cipher.doFinal(msg.getBytes("UTF-8")));
    }

    private String decryptText(String msg, PublicKey key)
            throws InvalidKeyException, UnsupportedEncodingException,
            IllegalBlockSizeException, BadPaddingException {
        this.cipher.init(Cipher.DECRYPT_MODE, key);
        return new String(cipher.doFinal(Base64.decodeBase64(msg)), "UTF-8");
    }

    public static String encryptText(String msg, String privateKeyPath) {
        try {
            AsymetricCryptography ac = new AsymetricCryptography();
            PrivateKey privateKey = ac.getPrivate(privateKeyPath);
            
            return ac.encryptText(msg, privateKey);
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
             return null;
        } catch (NoSuchPaddingException ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
             return null;
        } catch (Exception ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
             return null;
        }
       
    }
    
     public static String decryptText(String msg, String publicKeyPath) {
        try {
            AsymetricCryptography ac = new AsymetricCryptography();
            PublicKey publicKey = ac.getPublic(publicKeyPath);
            
            return ac.decryptText(msg, publicKey);
        } catch (NoSuchAlgorithmException ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
             return null;
        } catch (NoSuchPaddingException ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
             return null;
        } catch (Exception ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
             return null;
        }
       
    }
    
    public byte[] getFileInBytes(File f) throws IOException {
        FileInputStream fis = new FileInputStream(f);
        byte[] fbytes = new byte[(int) f.length()];
        fis.read(fbytes);
        fis.close();
        return fbytes;
    }

    /**
     * Fonction qui crypte un fichier
     * @param inputPath : chemin du fichier à crypter
     * @param outputPath : chemin vers les fichier crypté
     * @param privateKeyPath : chemin vers le fichier contenant la clé privée
     */
    public static void encryptFile(String inputPath, String outputPath, String privateKeyPath) {
        try {
            AsymetricCryptography ac = new AsymetricCryptography();
            PrivateKey privateKey = ac.getPrivate(privateKeyPath);

            ac.encryptFile(ac.getFileInBytes(new File(inputPath)),
                    new File(outputPath), privateKey);
        } catch (Exception ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        }
    }

    /**
     * Fonction qui décrypte un fichier
     * @param inputPath : chemin vers le fichier à décrypter
     * @param outputPath : chemin du fichier  contenant les données décryptées
     * @param publicKeyPath : chemin vers le fichier contenant la clé publique
     */
    public static void decryptFile(String inputPath, String outputPath, String publicKeyPath) {
        try {
            AsymetricCryptography ac = new AsymetricCryptography();
            PublicKey publicKey = ac.getPublic(publicKeyPath);

            ac.decryptFile(ac.getFileInBytes(new File(inputPath)),
                    new File(outputPath), publicKey);
        } catch (Exception ex) {
            Logger.getLogger(AsymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
        }
    }
}