encrypt.java

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.spec.GCMParameterSpec;

public class encrypt extends JFrame {

    private JTextField passwordField;
    private JLabel statusLabel;

    public encrypt() {
        // Setzt den Titel des Fensters
        setTitle("FDSecure 2.0 - Data-Encrypt");
        // Legt die Standardoperation beim Schließen des Fensters fest
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // Setzt die Größe des Fensters
        setSize(500, 300);
        // Zentriert das Fenster auf dem Bildschirm
        setLocationRelativeTo(null);
        // Legt das Layout des Hauptfensters fest
        setLayout(new BorderLayout(10, 10)); // 10 Pixel Abstand zwischen Komponenten

        // Erstellt ein Panel für die Eingabesteuerung (Passwortfeld und Beschriftung)
        JPanel inputPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 10, 10));
        inputPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 10, 20)); // Polsterung

        // Erstellt eine Beschriftung für das Passwortfeld
        JLabel passwordLabel = new JLabel("Password:");
        passwordLabel.setFont(new Font("Inter", Font.PLAIN, 16)); // Schriftart anpassen
        inputPanel.add(passwordLabel);

        // Erstellt ein Textfeld für die Passworteingabe
        passwordField = new JPasswordField(20); // 20 Zeichen Breite
        passwordField.setFont(new Font("Inter", Font.PLAIN, 16));
        inputPanel.add(passwordField);
        add(inputPanel, BorderLayout.NORTH); // Fügt das Eingabepanel oben hinzu

        // Erstellt ein Panel für die Schaltflächen
        JPanel buttonPanel = new JPanel(new GridLayout(1, 2, 15, 0)); // 1 Reihe, 2 Spalten, 15 Pixel horizontaler Abstand
        buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 50, 20, 50)); // Polsterung

        // Erstellt die Schaltfläche zum Verschlüsseln
        JButton encryptButton = new JButton("encrypt");
        encryptButton.setFont(new Font("Inter", Font.BOLD, 16));
        encryptButton.setBackground(new Color(60, 179, 113)); // Mittelmeergrün
        encryptButton.setForeground(Color.WHITE);
        encryptButton.setFocusPainted(false); // Keine Fokus-Umrandung
        encryptButton.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createLineBorder(new Color(46, 139, 87), 2), // Dunkelgrüner Rand
                BorderFactory.createEmptyBorder(10, 20, 10, 20) // Innenpolsterung
        ));
        encryptButton.setCursor(new Cursor(Cursor.HAND_CURSOR)); // Hand-Cursor beim Überfahren
        encryptButton.addActionListener(e -> encryptFile()); // Aktion beim Klicken
        buttonPanel.add(encryptButton);

        // Erstellt die Schaltfläche zum Entschlüsseln
        JButton decryptButton = new JButton("decrypt");
        decryptButton.setFont(new Font("Inter", Font.BOLD, 16));
        decryptButton.setBackground(new Color(70, 130, 180)); // Stahlblau
        decryptButton.setForeground(Color.WHITE);
        decryptButton.setFocusPainted(false);
        decryptButton.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createLineBorder(new Color(65, 105, 225), 2), // Königsblau-Rand
                BorderFactory.createEmptyBorder(10, 20, 10, 20)
        ));
        decryptButton.setCursor(new Cursor(Cursor.HAND_CURSOR));
        decryptButton.addActionListener(e -> decryptFile()); // Aktion beim Klicken
        buttonPanel.add(decryptButton);
        add(buttonPanel, BorderLayout.CENTER); // Fügt das Schaltflächenpanel in die Mitte hinzu

        // Erstellt eine Statusleiste am unteren Rand
        statusLabel = new JLabel("Bereit.", SwingConstants.CENTER); // Text zentrieren
        statusLabel.setFont(new Font("Inter", Font.ITALIC, 14));
        statusLabel.setBorder(BorderFactory.createEmptyBorder(10, 0, 10, 0)); // Polsterung
        add(statusLabel, BorderLayout.SOUTH); // Fügt die Statusleiste unten hinzu

        // Macht das Fenster sichtbar
        setVisible(true);
    }

    // Methode zum Verschlüsseln einer Datei
    private void encryptFile() {
        // Holt das Passwort aus dem Textfeld
        String password = new String(passwordField.getText());
        if (password.isEmpty()) {
            // Zeigt eine Fehlermeldung an, wenn kein Passwort eingegeben wurde
            showMessage("Error please enter a Password", ".", JOptionPane.WARNING_MESSAGE);
            return;
        }

        // Erstellt einen Dateiauswahldialog
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle("Choose file");
        // Zeigt den Öffnen-Dialog an
        int userSelection = fileChooser.showOpenDialog(this);

        // Prüft, ob der Benutzer eine Datei ausgewählt hat
        if (userSelection == JFileChooser.APPROVE_OPTION) {
            File inputFile = fileChooser.getSelectedFile();
            // Erstellt den Namen der Ausgabedatei mit der neuen Endung .fds2e
            File outputFile = new File(inputFile.getAbsolutePath() + ".fds2e");

            try {
                // Liest den Inhalt der Eingabedatei in ein Byte-Array
                byte[] fileBytes = readAllBytes(inputFile);
                // Erzeugt einen Schlüssel aus dem Passwort (SHA-256 liefert 256 Bits, ideal für AES-256)
                byte[] key = generateKey(password);

                // LAYER 1: Verschlüsselt die Dateibytes mit dem Schlüssel (XOR-Operation)
                byte[] xorEncryptedBytes = new byte[fileBytes.length];
                for (int i = 0; i < fileBytes.length; i++) {
                    xorEncryptedBytes[i] = (byte) (fileBytes[i] ^ key[i % key.length]);
                }

                // LAYER 2: AES-256-GCM Verschlüsselung hinzufügen
                // Generiert einen kryptografisch sicheren, zufälligen 12-Byte-Initialisierungsvektor (IV)
                byte[] iv = new byte[12];
                SecureRandom random = new SecureRandom();
                random.nextBytes(iv);

                Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");
                GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, iv); // 128-bit Authentifizierungstag
                cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, gcmParameterSpec);
                byte[] aesEncryptedBytes = cipher.doFinal(xorEncryptedBytes);

                // Kombiniert den IV und die AES-verschlüsselten Daten in ein einziges Array
                byte[] finalEncryptedBytes = new byte[iv.length + aesEncryptedBytes.length];
                System.arraycopy(iv, 0, finalEncryptedBytes, 0, iv.length);
                System.arraycopy(aesEncryptedBytes, 0, finalEncryptedBytes, iv.length, aesEncryptedBytes.length);

                // Schreibt die verschlüsselten Bytes in die Ausgabedatei
                writeAllBytes(outputFile, finalEncryptedBytes);
                // Aktualisiert die Statusleiste
                statusLabel.setText("File successfully encrypted: " + outputFile.getName());
                // Zeigt eine Erfolgsmeldung an
                showMessage("success", "File successfully encrypted!", JOptionPane.INFORMATION_MESSAGE);

            } catch (Exception ex) {
                // Behandelt Fehler allgemein
                statusLabel.setText("Error: " + ex.getMessage());
                showMessage("Error", "Error: " + ex.getMessage(), JOptionPane.ERROR_MESSAGE);
                ex.printStackTrace();
            }
        }
    }

    // Methode zum Entschlüsseln einer Datei
    private void decryptFile() {
        // Holt das Passwort aus dem Textfeld
        String password = new String(passwordField.getText());
        if (password.isEmpty()) {
            // Zeigt eine Fehlermeldung an, wenn kein Passwort eingegeben wurde
            showMessage("Error", "No/wrong password entered.", JOptionPane.WARNING_MESSAGE);
            return;
        }

        // Erstellt einen Dateiauswahldialog
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle("Choose file to decrypt");
        // Setzt einen Dateifilter, um nur .fds2e-Dateien anzuzeigen
        fileChooser.setFileFilter(new javax.swing.filechooser.FileFilter() {
            @Override
            public boolean accept(File f) {
                return f.isDirectory() || f.getName().toLowerCase().endsWith(".fds2e");
            }

            @Override
            public String getDescription() {
                return "FDSecure 2.0-files (*.fds2e)";
            }
        });
        // Zeigt den Öffnen-Dialog an
        int userSelection = fileChooser.showOpenDialog(this);

        // Prüft, ob der Benutzer eine Datei ausgewählt hat
        if (userSelection == JFileChooser.APPROVE_OPTION) {
            File inputFile = fileChooser.getSelectedFile();
            // Überprüft, ob die ausgewählte Datei die neue .fds2e-Endung hat
            if (!inputFile.getName().toLowerCase().endsWith(".fds2e")) {
                showMessage("Error", "No/unsupported file/ file type.", JOptionPane.WARNING_MESSAGE);
                return;
            }

            // Erstellt den Namen der Ausgabedatei (entfernt die .fds2e-Endung)
            String outputFileName = inputFile.getName().substring(0, inputFile.getName().length() - ".fds2e".length());
            File outputFile = new File(inputFile.getParent(), outputFileName);

            try {
                // Liest den Inhalt der verschlüsselten Datei in ein Byte-Array
                byte[] totalBytes = readAllBytes(inputFile);
                if (totalBytes.length < 12) {
                    showMessage("Error", "Invalid or corrupted file.", JOptionPane.ERROR_MESSAGE);
                    return;
                }

                // Erzeugt den Schlüssel aus dem Passwort
                byte[] key = generateKey(password);

                // 1. Extrahiert den 12-Byte IV und den restlichen AES-Ciphertext
                byte[] iv = new byte[12];
                System.arraycopy(totalBytes, 0, iv, 0, 12);

                byte[] aesCipherBytes = new byte[totalBytes.length - 12];
                System.arraycopy(totalBytes, 12, aesCipherBytes, 0, aesCipherBytes.length);

                // LAYER 2 ENTSCHLÜSSELUNG: AES-256-GCM
                Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");
                GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, iv);
                cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, gcmParameterSpec);
                
                // Falls das Passwort falsch ist oder die Datei manipuliert wurde, bricht doFinal() hier ab!
                byte[] xorEncryptedBytes = cipher.doFinal(aesCipherBytes);

                // LAYER 1 ENTSCHLÜSSELUNG: XOR-Operation rückgängig machen
                byte[] decryptedBytes = new byte[xorEncryptedBytes.length];
                for (int i = 0; i < xorEncryptedBytes.length; i++) {
                    decryptedBytes[i] = (byte) (xorEncryptedBytes[i] ^ key[i % key.length]);
                }

                // Schreibt die entschlüsselten Bytes in die Ausgabedatei
                writeAllBytes(outputFile, decryptedBytes);
                // Aktualisiert die Statusleiste
                statusLabel.setText("File successfully decrypted: " + outputFile.getName());
                // Zeigt eine Erfolgsmeldung an
                showMessage("Success", "File successfully decrypted and exported!", JOptionPane.INFORMATION_MESSAGE);

            } catch (Exception ex) {
                // Behandelt Fehler (z.B. falsches Passwort / AEADBadTagException)
                statusLabel.setText("Error: " + ex.getMessage());
                showMessage("Error", "Decryption failed. Wrong password or corrupted file.", JOptionPane.ERROR_MESSAGE);
                ex.printStackTrace();
            }
        }
    }

    // Hilfsmethode zum Lesen aller Bytes aus einer Datei
    private byte[] readAllBytes(File file) throws IOException {
        try (FileInputStream fis = new FileInputStream(file)) {
            byte[] buffer = new byte[(int) file.length()];
            fis.read(buffer);
            return buffer;
        }
    }

    // Hilfsmethode zum Schreiben aller Bytes in eine Datei
    private void writeAllBytes(File file, byte[] data) throws IOException {
        try (FileOutputStream fos = new FileOutputStream(file)) {
            fos.write(data);
        }
    }

    // Generiert einen Schlüssel aus dem Passwort mithilfe von SHA-256
    private byte[] generateKey(String password) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        return digest.digest(password.getBytes());
    }

    // Hilfsmethode zum Anzeigen von Nachrichtenboxen
    private void showMessage(String title, String message, int messageType) {
        JOptionPane.showMessageDialog(this, message, title, messageType);
    }

    // Hauptmethode zum Starten der Anwendung
    public static void main(String[] args) {
        SwingUtilities.invokeLater(encrypt::new);
    }
}