Encryptor.java

import javax.crypto.*;
import javax.crypto.spec.*;
import java.io.*;
import java.nio.file.*;
import java.security.*;
import java.security.spec.*;
import java.util.*;

public class Encryptor {

    // ===== FOLDERS =====
    static final Path INPUT_DIR = Paths.get("input");
    static final Path ENCRYPTED_DIR = Paths.get("encrypted");
    static final Path CLIENT_KEYS = Paths.get("keys/Client");

    static final String CLIENT_PUBLIC_KEY = "public.key";
    static final Set<String> IGNORE = Set.of(".jpg", ".png");

    // ===== CRYPTO CONSTANTS =====
    static final int AES_KEY_SIZE = 256;
    static final int GCM_IV_SIZE = 12;
    static final int GCM_TAG_SIZE = 128;
    static final int CHUNK_SIZE = 64 * 1024 * 1024; // 64MB

    public static void main(String[] args) throws Exception {
        Files.createDirectories(ENCRYPTED_DIR);
        PublicKey clientPub = loadPublicKey(CLIENT_KEYS.resolve(CLIENT_PUBLIC_KEY));

        Files.walk(INPUT_DIR)
                .filter(Files::isRegularFile)
                .forEach(file -> {
                    try {
                        if (shouldIgnore(file))
                            return;
                        encryptFile(file, clientPub);
                        Files.delete(file);
                        System.out.println("✔ Encrypted: " + file);
                    } catch (Exception e) {
                        System.out.println("❌ Failed: " + file + " (" + e.getMessage() + ")");
                    }
                });

        System.out.println("Encryption complete. Exiting...");
    }

    static void encryptFile(Path file, PublicKey rsaPub) throws Exception {
        KeyGenerator gen = KeyGenerator.getInstance("AES");
        gen.init(AES_KEY_SIZE);
        SecretKey aesKey = gen.generateKey();

        Path relative = INPUT_DIR.relativize(file);
        Path encFile = ENCRYPTED_DIR.resolve(relative + ".enc");
        Files.createDirectories(encFile.getParent());

        try (InputStream in = new BufferedInputStream(Files.newInputStream(file));
                DataOutputStream out = new DataOutputStream(new BufferedOutputStream(Files.newOutputStream(encFile)))) {

            byte[] buffer = new byte[CHUNK_SIZE];
            int bytesRead;

            while ((bytesRead = in.read(buffer)) != -1) {
                byte[] iv = new byte[GCM_IV_SIZE];
                SecureRandom.getInstanceStrong().nextBytes(iv);

                Cipher aes = Cipher.getInstance("AES/GCM/NoPadding");
                aes.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(GCM_TAG_SIZE, iv));

                byte[] encrypted = aes.doFinal(buffer, 0, bytesRead);

                out.writeInt(encrypted.length); // store chunk length
                out.write(iv); // store IV
                out.write(encrypted); // store encrypted chunk + tag
            }
        }

        // Encrypt AES key with RSA
        Cipher rsa = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        rsa.init(Cipher.ENCRYPT_MODE, rsaPub);
        byte[] encKey = rsa.doFinal(aesKey.getEncoded());

        Files.write(encFile.resolveSibling(encFile.getFileName() + ".key"), encKey);
    }

    static boolean shouldIgnore(Path file) {
        String n = file.getFileName().toString().toLowerCase();
        return IGNORE.stream().anyMatch(n::endsWith);
    }

    static PublicKey loadPublicKey(Path path) throws Exception {
        byte[] b = Base64.getDecoder().decode(Files.readAllBytes(path));
        return KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(b));
    }
}