1. package project.core;
  2.  
  3. import java.text.DecimalFormat;
  4.  
  5. public class Brute_Force {
  6.     /*
  7.      * CURRENTLY CRACKS:
  8.      * Letters, Numbers and Symbols.
  9.      *
  10.      * TODO:
  11.      * Implement matching lower/upper case option.
  12.      * Transfer to GPU for faster computations.
  13.      * -> Implement a GUI / data logging system. (Files)
  14.      * Implement common words / phrases + dictionary
  15.      */
  16.    
  17.     /* Possible characters / numbers for the password to brute force */
  18.     private static final String[] VALID_SYMBOLS = {
  19.         // Symbols
  20.         "-", "_", ".", "<", ">",
  21.        
  22.         // Numbers
  23.          "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
  24.        
  25.         // Uppercase/Lowercase
  26.         "A", "a", "B", "b", "C", "c", "D", "d", "E", "e", "F", "f", "G", "g", "H", "h", "I", "i", "J", "j", "K", "k", "L", "l", "M", "m", "N", "n", "O", "o", "P", "p", "Q", "q", "R", "r", "S", "s", "T", "t", "U", "u", "V", "v", "W", "w", "X", "x", "Y", "y", "Z", "z",
  27.         };
  28.    
  29.     /* Array for our computations */
  30.     private static String[] COMPUTATED_DATA = new String[VALID_SYMBOLS.length];
  31.    
  32.     /* Computation slot indexes */
  33.     private static int a, ab, abc, abcd, abcde, abcdef, abcdefg, abcdefgh, abcdefghi, abcdefghij;
  34.    
  35.     /* The time we started*/
  36.     private static long start_time = 0;
  37.    
  38.     /*
  39.      * Password we want to crack. (10 letters max)
  40.      * In most cases this wouldn't be available.. this algorithm
  41.      * is capable of computing and producing the password at some point.
  42.      * TYPE: BRUTE FORCE. Possible to bypass a login / authorization by
  43.      * brute forcing the required password >:D
  44.      */
  45.     private static final String PASS_TO_BRUTE_FORCE = "123456789";
  46.    
  47.     /**
  48.      * Main Entry Point Into Application.
  49.      * http://www.en.wikipedia.org/wiki/Brute-force_attack
  50.      * http://www.en.wikipedia.org/wiki/Password_cracking
  51.      * Translated to Java by Gabriel Bailey.
  52.      * @param args The arguments passed by the user..
  53.      */
  54.     public static void main(String[] args) {    start_time = System.currentTimeMillis();
  55.         /* Begin the brute force search */
  56.         boolean tmp = false;
  57.         try {
  58.             tmp = bruteForce(PASS_TO_BRUTE_FORCE, PASS_TO_BRUTE_FORCE.length());
  59.         } catch (InterruptedException e) {
  60.             e.printStackTrace();
  61.         }
  62.         log("Time took: " + (System.currentTimeMillis() - start_time)/1000 + " seconds");
  63.         log("Success For Brute Force: (" + PASS_TO_BRUTE_FORCE + ") == " + tmp);
  64.     }
  65.    
  66.    
  67.     /*
  68.      * The actual method translated to java.
  69.      */
  70.     static boolean bruteForce(final String password, int size) throws InterruptedException {
  71.         /* Display some details */
  72.         log("Initialize Brute Force Algorithm...");
  73.         log("Targeted Password: " + password);
  74.         log("Password length: " + size);
  75.         /* Obtain our starting time for later computations */
  76.         Thread.sleep(3000);
  77.         start_time = System.currentTimeMillis();
  78.         if (size == 1) {
  79.             // Cracked 'z' in 0ms.
  80.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  81.                 COMPUTATED_DATA[a] =
  82.                         appendLetter(a);
  83.                 if (password.equals(COMPUTATED_DATA[a])) {
  84.                     log("Pass Cracked: " + COMPUTATED_DATA[a]);
  85.                     return true;
  86.                 } else {
  87.                     debug(COMPUTATED_DATA[a]);
  88.                 }
  89.             }
  90.         } else if (size == 2) {
  91.             // Cracked 'zz' in 250ms.
  92.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  93.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  94.                     COMPUTATED_DATA[a] =
  95.                             appendLetter(a)
  96.                             + appendLetter(ab);
  97.                     if (password.equals(COMPUTATED_DATA[a])) {
  98.                         log("Pass Cracked: " + COMPUTATED_DATA[a]);
  99.                         return true;
  100.                     } else {
  101.                         debug(COMPUTATED_DATA[a]);
  102.                     }
  103.                 }
  104.             }
  105.         } else if (size == 3) {
  106.             // Cracked 'bye' in 265ms.
  107.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  108.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  109.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  110.                         COMPUTATED_DATA[a] =
  111.                                 appendLetter(a)
  112.                                 + appendLetter(ab)
  113.                                 + appendLetter(abc);
  114.                         if (password.equals(COMPUTATED_DATA[a])) {
  115.                             log("Pass Cracked: " + COMPUTATED_DATA[a]);
  116.                             return true;
  117.                         } else {
  118.                             debug(COMPUTATED_DATA[a]);
  119.                         }
  120.                     }
  121.                 }
  122.             }
  123.         } else if (size == 4) {
  124.             // Cracked 'rofl' in 6.7 seconds.
  125.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  126.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  127.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  128.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  129.                             COMPUTATED_DATA[a] =
  130.                                     appendLetter(a)
  131.                                     + appendLetter(ab)
  132.                                     + appendLetter(abc)
  133.                                     + appendLetter(abcd);
  134.                             if (password.equals(COMPUTATED_DATA[a])) {
  135.                                 log("Pass Cracked: " + COMPUTATED_DATA[a]);
  136.                                 return true;
  137.                             } else {
  138.                                 debug(COMPUTATED_DATA[a]);
  139.                             }
  140.                         }
  141.                     }
  142.                 }
  143.             }
  144.         } else if (size == 5) {
  145.             // Cracked 'lmfao' in
  146.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  147.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  148.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  149.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  150.                             for (abcde = 0; abcde < VALID_SYMBOLS.length; abcde++) {
  151.                                 COMPUTATED_DATA[a] =
  152.                                         appendLetter(a)
  153.                                         + appendLetter(ab) + appendLetter(abc)
  154.                                         + appendLetter(abcd)
  155.                                         + appendLetter(abcde);
  156.                                 if (password.equals(COMPUTATED_DATA[a])) {
  157.                                     log("Pass Cracked: " + COMPUTATED_DATA[a]);
  158.                                     return true;
  159.                                 } else {
  160.                                     debug(COMPUTATED_DATA[a]);
  161.                                 }
  162.                             }
  163.                         }
  164.                     }
  165.                 }
  166.             }
  167.         } else if (size == 6) {
  168.             // Cracked 'abcdef' in 1 minute.
  169.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  170.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  171.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  172.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  173.                             for (abcde = 0; abcde < VALID_SYMBOLS.length; abcde++) {
  174.                                 for (abcdef = 0; abcdef < VALID_SYMBOLS.length; abcdef++) {
  175.                                     COMPUTATED_DATA[a] =
  176.                                             appendLetter(a)
  177.                                             + appendLetter(ab)
  178.                                             + appendLetter(abc)
  179.                                             + appendLetter(abcd)
  180.                                             + appendLetter(abcde)
  181.                                             + appendLetter(abcdef);
  182.                                     if (password.equals(COMPUTATED_DATA[a])) {
  183.                                         log("Pass Cracked: " + COMPUTATED_DATA[a]);
  184.                                         return true;
  185.                                     } else {
  186.                                         debug(COMPUTATED_DATA[a]);
  187.                                     }
  188.                                 }
  189.                             }
  190.                         }
  191.                     }
  192.                 }
  193.             }
  194.         } else if (size == 7) {
  195.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  196.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  197.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  198.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  199.                             for (abcde = 0; abcde < VALID_SYMBOLS.length; abcde++) {
  200.                                 for (abcdef = 0; abcdef < VALID_SYMBOLS.length; abcdef++) {
  201.                                     for (abcdefg = 0; abcdefg < VALID_SYMBOLS.length; abcdefg++) {
  202.                                         COMPUTATED_DATA[a] =
  203.                                                 appendLetter(a)
  204.                                                 + appendLetter(ab)
  205.                                                 + appendLetter(abc)
  206.                                                 + appendLetter(abcd)
  207.                                                 + appendLetter(abcde)
  208.                                                 + appendLetter(abcdef)
  209.                                                 + appendLetter(abcdefg);
  210.                                         if (password.equals(COMPUTATED_DATA[a])) {
  211.                                             log("Pass Cracked: " + COMPUTATED_DATA[a]);
  212.                                             return true;
  213.                                         } else {
  214.                                             debug(COMPUTATED_DATA[a]);
  215.                                         }
  216.                                     }
  217.                                 }
  218.                             }
  219.                         }
  220.                     }
  221.                 }
  222.             }
  223.         } else if (size == 8) {
  224.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  225.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  226.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  227.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  228.                             for (abcde = 0; abcde < VALID_SYMBOLS.length; abcde++) {
  229.                                 for (abcdef = 0; abcdef < VALID_SYMBOLS.length; abcdef++) {
  230.                                     for (abcdefg = 0; abcdefg < VALID_SYMBOLS.length; abcdefg++) {
  231.                                         for (abcdefgh = 0; abcdefgh < VALID_SYMBOLS.length; abcdefgh++) {
  232.                                             COMPUTATED_DATA[a] =
  233.                                                     appendLetter(a)
  234.                                                     + appendLetter(ab)
  235.                                                     + appendLetter(abc)
  236.                                                     + appendLetter(abcd)
  237.                                                     + appendLetter(abcde)
  238.                                                     + appendLetter(abcdef)
  239.                                                     + appendLetter(abcdefg)
  240.                                                     + appendLetter(abcdefgh);
  241.                                             if (password.equals(COMPUTATED_DATA[a])) {
  242.                                                 log("Pass Cracked: "
  243.                                                         + COMPUTATED_DATA[a]);
  244.                                                 return true;
  245.                                             } else {
  246.                                                 debug(COMPUTATED_DATA[a]);
  247.                                             }
  248.                                         }
  249.                                     }
  250.                                 }
  251.                             }
  252.                         }
  253.                     }
  254.                 }
  255.             }
  256.         } else if (size == 9) {
  257.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  258.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  259.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  260.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  261.                             for (abcde = 0; abcde < VALID_SYMBOLS.length; abcde++) {
  262.                                 for (abcdef = 0; abcdef < VALID_SYMBOLS.length; abcdef++) {
  263.                                     for (abcdefg = 0; abcdefg < VALID_SYMBOLS.length; abcdefg++) {
  264.                                         for (abcdefgh = 0; abcdefgh < VALID_SYMBOLS.length; abcdefgh++) {
  265.                                             for (abcdefghi = 0; abcdefghi < VALID_SYMBOLS.length; abcdefghi++) {
  266.                                                 COMPUTATED_DATA[a] =
  267.                                                         appendLetter(a)
  268.                                                         + appendLetter(ab)
  269.                                                         + appendLetter(abc)
  270.                                                         + appendLetter(abcd)
  271.                                                         + appendLetter(abcde)
  272.                                                         + appendLetter(abcdef)
  273.                                                         + appendLetter(abcdefg)
  274.                                                         + appendLetter(abcdefgh)
  275.                                                         + appendLetter(abcdefghi);
  276.                                                 if (password.equals(COMPUTATED_DATA[a])) {
  277.                                                     log("Pass Cracked: "
  278.                                                             + COMPUTATED_DATA[a]);
  279.                                                     return true;
  280.                                                 } else {
  281.                                                     debug(COMPUTATED_DATA[a]);
  282.                                                 }
  283.                                             }
  284.                                         }
  285.                                     }
  286.                                 }
  287.                             }
  288.                         }
  289.                     }
  290.                 }
  291.             }
  292.         } else if (size == 10) {
  293.             for (a = 0; a < VALID_SYMBOLS.length; a++) {
  294.                 for (ab = 0; ab < VALID_SYMBOLS.length; ab++) {
  295.                     for (abc = 0; abc < VALID_SYMBOLS.length; abc++) {
  296.                         for (abcd = 0; abcd < VALID_SYMBOLS.length; abcd++) {
  297.                             for (abcde = 0; abcde < VALID_SYMBOLS.length; abcde++) {
  298.                                 for (abcdef = 0; abcdef < VALID_SYMBOLS.length; abcdef++) {
  299.                                     for (abcdefg = 0; abcdefg < VALID_SYMBOLS.length; abcdefg++) {
  300.                                         for (abcdefgh = 0; abcdefgh < VALID_SYMBOLS.length; abcdefgh++) {
  301.                                             for (abcdefghi = 0; abcdefghi < VALID_SYMBOLS.length; abcdefghi++) {
  302.                                                 for (abcdefghij = 0; abcdefghij < VALID_SYMBOLS.length; abcdefghij++) {
  303.                                                     COMPUTATED_DATA[a] =
  304.                                                             appendLetter(a)
  305.                                                             + appendLetter(ab)
  306.                                                             + appendLetter(abc)
  307.                                                             + appendLetter(abcd)
  308.                                                             + appendLetter(abcde)
  309.                                                             + appendLetter(abcdef)
  310.                                                             + appendLetter(abcdefg)
  311.                                                             + appendLetter(abcdefgh)
  312.                                                             + appendLetter(abcdefghi)
  313.                                                             + appendLetter(abcdefghij);
  314.                                                     if (password.equals(COMPUTATED_DATA[a])) {
  315.                                                         log("Pass Cracked: "
  316.                                                                 + COMPUTATED_DATA[a]);
  317.                                                         return true;
  318.                                                     } else {
  319.                                                         debug(COMPUTATED_DATA[a]);
  320.                                                     }
  321.                                                 }
  322.                                             }
  323.                                         }
  324.                                     }
  325.                                 }
  326.                             }
  327.                         }
  328.                     }
  329.                 }
  330.             }
  331.         }
  332.         return false;
  333.     }
  334.    
  335.     /*
  336.      * Printing a informative statement to the console.
  337.      */
  338.     private static void log(String string) {
  339.         System.out.println("[Brute Force] "+string);
  340.     }
  341.    
  342.     /*
  343.      * Printing a debug statement to the console.
  344.      */
  345.     static int message_index = 0;
  346.     final static DecimalFormat format = new DecimalFormat("###,###,###,###,###");
  347.     private static void debug(String string) {
  348.         System.out.println("[Brute Force Computation (# "+(format.format(message_index++))+")]: " + string);
  349.     }
  350.  
  351.     /*
  352.      * Obtaining a random letter from the VALID_SYMBOLS.
  353.      */
  354.     private static String appendLetter(int i) {
  355.         // new Random().nextInt(VALID_SYMBOLS.length)];
  356.         return VALID_SYMBOLS[i];
  357.     }
  358. }