/*
|
* 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.aes.symetric;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileOutputStream;
|
import java.io.IOException;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.security.InvalidKeyException;
|
import java.security.NoSuchAlgorithmException;
|
import java.security.spec.InvalidKeySpecException;
|
import java.security.spec.KeySpec;
|
import java.util.Base64;
|
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 javax.crypto.SecretKey;
|
import javax.crypto.SecretKeyFactory;
|
import javax.crypto.spec.PBEKeySpec;
|
import javax.crypto.spec.SecretKeySpec;
|
|
/**
|
*
|
* @author STEPHANIE
|
*/
|
public class SymetricCryptography {
|
|
private static final String SALT = "hdbgshdbvnc";
|
private static final String HASH_ALGORITHM = "PBKDF2WithHmacSHA256";
|
private static final String ALGORITHM = "AES";
|
private static final int HASH_ITERATIONS = 65536;
|
|
/**
|
* Fonction qui sert à chiffrer
|
*
|
* @param inputPath : chemin vers le fichier à chiffrer
|
* @param keyLength : {128,192,256}
|
* @param outputPath : chemin vers le resutlat du chiffrement
|
* @param password : clé de chiffrement
|
*/
|
public static void encryptFile(String password, int keyLength, String inputPath, String outputPath) {
|
File file = new File(inputPath);
|
|
try {
|
if (file.exists()) {
|
/* Chiffre le fichier */
|
cryptOrDecryptFile(Cipher.ENCRYPT_MODE, password, keyLength, file, new File(outputPath));
|
}
|
} catch (Exception ex) {
|
Logger.getLogger(SymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
}
|
}
|
|
/**
|
* Fonction qui sert à déchiffrer
|
*
|
* @param inputPath : chemin du fichier à déchiffrer
|
* @param keyLength
|
* @param outputPath : chemin où stocké le resultat du déchiffrement
|
* @param password : clé de déchiffrement
|
*/
|
public static void decryptFile(String password, int keyLength, String inputPath, String outputPath) {
|
File file = new File(inputPath);
|
|
try {
|
/* Déchiffre le fichier */
|
cryptOrDecryptFile(Cipher.DECRYPT_MODE, password, keyLength, file,
|
new File(outputPath));
|
|
} catch (Exception ex) {
|
Logger.getLogger(SymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
}
|
}
|
|
|
private static void cryptOrDecryptFile(int mode, String password, int keyLength, File inputFile, File outputFile)
|
throws InvalidKeySpecException, NoSuchAlgorithmException, InvalidKeyException,
|
NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, IOException {
|
|
SecretKey secret = getKeyFromPassword(password, SALT, keyLength);
|
/* Utilisation de l'algorithme AES */
|
Cipher aesCipher = Cipher.getInstance(ALGORITHM);
|
aesCipher.init(mode, secret);
|
|
if (!outputFile.exists()) {
|
Files.createFile(outputFile.toPath());
|
}
|
|
FileInputStream inputStream = new FileInputStream(inputFile);
|
FileOutputStream outputStream = new FileOutputStream(outputFile);
|
|
byte[] buffer = new byte[64];
|
int bytesRead;
|
|
while ((bytesRead = inputStream.read(buffer)) != -1) {
|
byte[] output = aesCipher.update(buffer, 0, bytesRead);
|
if (output != null) {
|
outputStream.write(output);
|
}
|
}
|
byte[] outputBytes = aesCipher.doFinal();
|
if (outputBytes != null) {
|
outputStream.write(outputBytes);
|
}
|
inputStream.close();
|
outputStream.close();
|
}
|
|
/**
|
* Méthode servant à générer une clé secrète à partir du mot de passe de l'utilisateur
|
* @param password : mot de passe à partir duquel on veut générer la clé sécrète
|
* @param salt : valeur servant à renforcer la sécurité de la clé sécrète
|
* @param keylength : longueur de la clé en bit
|
* @return
|
* @throws NoSuchAlgorithmException
|
* @throws InvalidKeySpecException
|
*/
|
private static SecretKey getKeyFromPassword(String password, String salt, int keylength)
|
throws NoSuchAlgorithmException, InvalidKeySpecException {
|
|
SecretKeyFactory factory = SecretKeyFactory.getInstance(HASH_ALGORITHM);
|
KeySpec spec = new PBEKeySpec(password.toCharArray(), salt.getBytes(), HASH_ITERATIONS, keylength);
|
SecretKey secret = new SecretKeySpec(factory.generateSecret(spec)
|
.getEncoded(), ALGORITHM);
|
return secret;
|
}
|
|
|
public static String encryptString(String password, int keyLength, String strToEncrypt) {
|
|
try {
|
SecretKey secret = getKeyFromPassword(password, SALT, keyLength);
|
|
/* Utilisation de l'algorithme AES */
|
Cipher aesCipher = Cipher.getInstance(ALGORITHM);
|
aesCipher.init(Cipher.ENCRYPT_MODE, secret);
|
|
/* Chiffre la chaine de charactères */
|
return Base64.getEncoder().encodeToString(aesCipher.doFinal(strToEncrypt.getBytes(StandardCharsets.UTF_8)));
|
} catch (Exception ex) {
|
Logger.getLogger(SymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
return "";
|
}
|
}
|
|
public static String decryptString(String password, int keyLength, String strToDecrypt) {
|
|
try {
|
SecretKey secret = getKeyFromPassword(password, SALT, keyLength);
|
|
/* Utilisation de l'algorithme AES */
|
Cipher aesCipher = Cipher.getInstance(ALGORITHM);
|
aesCipher.init(Cipher.DECRYPT_MODE, secret);
|
|
/* Déchiffre le fichier */
|
return new String(aesCipher.doFinal(Base64.getDecoder().decode(strToDecrypt)));
|
|
} catch (Exception ex) {
|
Logger.getLogger(SymetricCryptography.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
|
return "";
|
}
|
}
|
}
|
