From 4575de680f208fe13833116470664c7252e84bc8 Mon Sep 17 00:00:00 2001
From: Kenmegne <stephanie.kenmegne@gmail.com>
Date: Fri, 19 Jun 2026 11:07:23 +0000
Subject: [PATCH] move to new repo
---
Encryption/src/main/java/com/megatim/module/encryption/cipher/asymetric/AsymetricCryptography.java | 175 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 175 insertions(+), 0 deletions(-)
diff --git a/Encryption/src/main/java/com/megatim/module/encryption/cipher/asymetric/AsymetricCryptography.java b/Encryption/src/main/java/com/megatim/module/encryption/cipher/asymetric/AsymetricCryptography.java
new file mode 100644
index 0000000..d2d3002
--- /dev/null
+++ b/Encryption/src/main/java/com/megatim/module/encryption/cipher/asymetric/AsymetricCryptography.java
@@ -0,0 +1,175 @@
+/*
+ * 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);
+ }
+ }
+}
--
Gitblit v1.10.0