Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Java Brute Force Password V0.1

By: a guest on Mar 3rd, 2013  |  syntax: Java  |  size: 11.70 KB  |  views: 89  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  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. }