Advertisement
Guest User

Java Brute Force Password V0.1

a guest
Mar 3rd, 2013
440
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 11.70 KB | None | 0 0
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement