Advertisement
Guest User

Untitled

a guest
May 17th, 2018
129
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 17.12 KB | None | 0 0
  1. /*
  2.  * To change this license header, choose License Headers in Project Properties.
  3.  * To change this template file, choose Tools | Templates
  4.  * and open the template in the editor.
  5.  */
  6. //package passcrack;
  7.  
  8. import java.io.File;
  9. import java.util.ArrayList;
  10. import java.util.Arrays;
  11. import java.util.Iterator;
  12. import java.util.List;
  13. import java.util.Scanner;
  14. import static passcrack.jcrypt.crypt;
  15.  
  16. /**
  17.  *
  18.  * @author Anders
  19.  */
  20. public class PasswordCrack {
  21.  
  22.     private static void stage1(User user, Scanner dictScanner) {
  23.         List<String> names = Arrays.asList(user.name);
  24.         Iterator<String> nameIter = names.iterator();
  25.         while (dictScanner.hasNextLine() || nameIter.hasNext()) {
  26.             String currentWord;
  27.             if (dictScanner.hasNext()) {
  28.                 currentWord = dictScanner.nextLine();
  29.             } else {
  30.                 currentWord = nameIter.next();
  31.             }
  32.             if (isCracked(user, new StringBuilder(currentWord))) {
  33.                 return;
  34.             }
  35.         }
  36.     }
  37.  
  38.     private static void stage2(User user, Scanner dictScanner) {
  39.         if (user.cracked) {
  40.             return;
  41.         }
  42.         List<String> names = Arrays.asList(user.name);
  43.         Iterator<String> nameIter = names.iterator();
  44.         while (dictScanner.hasNextLine() || nameIter.hasNext()) {
  45.             String currentWord;
  46.             if (dictScanner.hasNext()) {
  47.                 currentWord = dictScanner.nextLine();
  48.             } else {
  49.                 currentWord = nameIter.next();
  50.             }
  51.  
  52.             StringBuilder currentSb = new StringBuilder(currentWord);
  53.             char first = currentSb.charAt(0);
  54.             char last = currentSb.charAt(currentSb.length() - 1);
  55.             for (int i = 1; i <= 14; i++) {
  56.  
  57.                 //append or prepend
  58.                 if (i == 1 || i == 2) {
  59.                     for (char c : chars) {
  60.                         runFunc(currentSb, i, c);
  61.                         if (isCracked(user, currentSb)) {
  62.                             return;
  63.                         }
  64.                         RrunFunc(currentSb, i, first, last);
  65.  
  66.                     }
  67.                 } //end of case append or prepend
  68.                 else {
  69.                     runFunc(currentSb, i, ' ');
  70.                     if (isCracked(user, currentSb)) {
  71.                         return;
  72.                     }
  73.                     RrunFunc(currentSb, i, first, last);
  74.  
  75.                 }
  76.  
  77.             }
  78.  
  79.         }
  80.     }
  81.  
  82.     private static void stage3(User user, Scanner dictScanner) {
  83.         if (user.cracked) {
  84.             return;
  85.         }
  86.         List<String> names = Arrays.asList(user.name);
  87.         Iterator<String> nameIter = names.iterator();
  88. //        if (!user.name[0].equals("Faker")) {
  89. //            return;
  90. //        }
  91.         while (dictScanner.hasNextLine() || nameIter.hasNext()) {
  92.             String currentWord;
  93.             if (dictScanner.hasNext()) {
  94.                 currentWord = dictScanner.nextLine();
  95.             } else {
  96.                 currentWord = nameIter.next();
  97.             }
  98.             // System.out.println(user.name[0]);
  99. //            if (!currentWord.equals("add")) {
  100. //                continue;
  101. //            }
  102.             StringBuilder currentSb = new StringBuilder(currentWord);
  103.             char firstOuter = currentSb.charAt(0);
  104.             char lastOuter = currentSb.charAt(currentSb.length() - 1);
  105.             for (int i = 1; i <= 14; i++) {
  106.  
  107.                 //append or prepend
  108.                 if (i == 1 || i == 2) {
  109.                     for (char c : chars) {
  110.                         runFunc(currentSb, i, c);
  111.                         char firstInner = currentSb.charAt(0);
  112.                         char lastInner = currentSb.charAt(currentSb.length() - 1);
  113.                         for (int j = 1; j <= 14; j++) {
  114.  
  115.                             if (j == 1 || j == 2) {
  116.                                 //TOO EXHAUSTIVE
  117. //                                for (char d : chars) {
  118. //                                    runFunc(currentSb, j, d);
  119. //
  120. //                                    if (currentSb.toString().equals(user.passClear)) {
  121. //                                        return;
  122. //                                    }
  123. //                                    RrunFunc(currentSb, j, firstInner, lastInner);
  124. //                                }
  125.                             } else {
  126.                                 runFunc(currentSb, j, ' ');
  127. //                                if (i == 2 && j == 11) {
  128. //                                    System.out.println(currentSb);
  129. //                                    System.out.println(currentSb.toString().equals(user.passClear));
  130. //                                }
  131.                                 if (isCracked(user, currentSb)) {
  132.                                     return;
  133.                                 }
  134.                                 RrunFunc(currentSb, j, firstInner, lastInner);
  135.                             }
  136.                             //System.out.println("i: " + i + " j: " + j);
  137.                         }
  138.                         RrunFunc(currentSb, i, firstOuter, lastOuter);
  139.                     }
  140.                 } //end of case append or prepend
  141.                 else {
  142.                     runFunc(currentSb, i, ' ');
  143.                     char firstInner = currentSb.charAt(0);
  144.                     char lastInner = currentSb.charAt(currentSb.length() - 1);
  145.                     for (int j = 1; j <= 14; j++) {
  146.                         //   System.out.println("i: " + i + " j: " + j);
  147.                         if (j == 1 || j == 2) {
  148.                         //TOO EXHAUSTIVE
  149. //                            for (char d : chars) {
  150. //                                runFunc(currentSb, j, d);
  151. //                                //     System.out.println(currentSb);
  152. //
  153. //                                if (isCracked(user, currentSb)) {
  154. //                                    return;
  155. //                                }
  156. //                                RrunFunc(currentSb, j, firstInner, lastInner);
  157. //
  158. //                            }
  159.                         } else {
  160.                             runFunc(currentSb, j, ' ');
  161.                             //  System.out.println(currentSb);
  162.                             if (isCracked(user, currentSb)) {
  163.                                 return;
  164.                             }
  165.                             RrunFunc(currentSb, j, firstInner, lastInner);
  166.                             //       System.out.println("i: " + i + " j: " + j);
  167.                         }
  168.                     }
  169.                     RrunFunc(currentSb, i, firstOuter, lastOuter);
  170.  
  171.                 }
  172.  
  173.             }
  174.  
  175.         }
  176.     }
  177.  
  178.     static char[] chars = "1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM".toCharArray();
  179.  
  180.     private static boolean isCracked(User usr, StringBuilder sb) {
  181.         if (usr.hash.equals(jcrypt.crypt(usr.salt, sb.toString()))) {
  182.             usr.cracked = true;
  183.             usr.passClear = sb.toString();
  184.             return true;
  185.         }
  186.  
  187.         return false;
  188.     }
  189.  
  190.     public static void main(String[] args) {
  191.  
  192.         if (args.length != 2) {
  193.             System.out.println("missing arguments <dictionary> <passwd>");
  194.             return;
  195.         }
  196.  
  197.         String[] found = {"Faker", "Horatio", "Gordon", "George", "Suzanna", "Frank", "Otis", "Quincy", "Wolf", "Benjamin", "Sam", "Rusty", "Emile", "Hugo"};
  198.  
  199.         String dictionary = args[0];
  200.         String passwd = args[1];
  201.  
  202.         Scanner plainScanner = getScanner("passwd1-plain.txt");
  203.         Scanner passwdScanner = getScanner(passwd);
  204.  
  205.         List<User> users = loadUserData(passwdScanner);
  206.  
  207.         for (User usr : users) {
  208.             for (String name : found) {
  209.                 if (name.equals(usr.name[0])) {
  210.                     usr.cracked = true;
  211.                 }
  212.  
  213.             }
  214.         }
  215.         System.out.println("STAGE 1: ------------------------");
  216.  
  217.         for (User usr : users) {
  218.  
  219.             stage1(usr, getScanner(dictionary));
  220.             System.out.println(usr);
  221.         }
  222.         System.out.println("STAGE 2: ------------------------");
  223.         for (User usr : users) {
  224.  
  225.             stage2(usr, getScanner(dictionary));
  226.  
  227.             System.out.println(usr);
  228.         }
  229.         System.out.println("STAGE 3: ------------------------");
  230.         for (User usr : users) {
  231.             if (usr.name[0].equals("Emily")) {
  232.                 stage3(usr, getScanner(dictionary));
  233.                 System.out.println(usr);
  234.             }
  235.         }
  236.  
  237.     }
  238.  
  239.     private static List loadUserData(Scanner s) {
  240.         PasswordCrack pc = new PasswordCrack();
  241.         List<PasswordCrack.User> users = new ArrayList<>();
  242.         while (s.hasNextLine()) {
  243.             String line = s.nextLine();
  244.             User usr = pc.new User(line);
  245.             users.add(usr);
  246.         }
  247.  
  248.         return users;
  249.     }
  250.  
  251.     private static Scanner getScanner(String fileName) {
  252.         //char[] charMessage;
  253.         Scanner s;
  254.         try {
  255.             s = new Scanner(new File(fileName));
  256.  
  257.         } catch (Exception e) {
  258.             System.out.println(e.getMessage());
  259.             return null;
  260.         }
  261.  
  262.         return s;
  263.     }
  264.  
  265.     private static void fillClearText(List<User> users, Scanner s) {
  266.  
  267.         for (User user : users) {
  268.             user.passClear = s.nextLine();
  269.         }
  270.     }
  271.  
  272.     private static void prepend(StringBuilder word, char c) {
  273.         //StringBuilder tmp = new StringBuilder(word);
  274.         // tmp = tmp.insert(0, c);
  275.         word.insert(0, c);
  276.     }
  277.  
  278.     private static void Rprepend(StringBuilder word) {
  279.         //StringBuilder tmp = new StringBuilder(word);
  280.         // tmp = tmp.insert(0, c);
  281.         word.deleteCharAt(0);
  282.     }
  283.  
  284.     private static void append(StringBuilder word, char c) {
  285.         // StringBuilder tmp = new StringBuilder(word);
  286.         // tmp.append(c);
  287.         word.append(c);
  288.     }
  289.  
  290.     private static void Rappend(StringBuilder word) {
  291.         word.deleteCharAt(word.length() - 1);
  292.     }
  293.  
  294.     private static void deleteFirst(StringBuilder word) {
  295.         word.deleteCharAt(0);
  296.     }
  297.  
  298.     private static void RdeleteFirst(StringBuilder word, char c) {
  299.         word.insert(0, c);
  300.     }
  301.  
  302.     private static void deleteLast(StringBuilder word) {
  303.         word.deleteCharAt(word.length() - 1);
  304.     }
  305.  
  306.     private static void RdeleteLast(StringBuilder word, char c) {
  307.         word.append(c);
  308.     }
  309.  
  310.     private static void reverse(StringBuilder word) {
  311.         word.reverse();
  312.     }
  313.  
  314.     private static void Rreverse(StringBuilder word) {
  315.         word.reverse();
  316.     }
  317.  
  318.     private static void duplicate(StringBuilder word) {
  319.         StringBuilder tmp = new StringBuilder(word);
  320.         word.append(tmp);
  321.     }
  322.  
  323.     private static void Rduplicate(StringBuilder word) {
  324.         int length = word.length() / 2;
  325.         word.setLength(length);
  326.     }
  327.  
  328.     private static void reflect1(StringBuilder word) {
  329.         StringBuilder tmp = new StringBuilder(word);
  330.  
  331.         word.append(tmp.reverse());
  332.     }
  333.  
  334.     private static void Rreflect1(StringBuilder word) {
  335.         int length = word.length() / 2;
  336.         word.setLength(length);
  337.     }
  338.  
  339.     private static void reflect2(StringBuilder word) {
  340.         StringBuilder tmp = new StringBuilder(word);
  341.         word.reverse().append(tmp);
  342.     }
  343.  
  344.     private static void Rreflect2(StringBuilder word) {
  345.         int length = word.length() / 2;
  346.         word.setLength(length);
  347.         word.reverse();
  348.     }
  349.  
  350.     private static void capitalize(StringBuilder word) {
  351.  
  352.         Character c = word.charAt(0);
  353.         c = Character.toUpperCase(c);
  354.         // System.out.println("Char: " + c);
  355.         word.setCharAt(0, c);
  356.     }
  357.  
  358.     private static void Rcapitalize(StringBuilder word, char first) {
  359.         word.setCharAt(0, first);
  360.     }
  361.  
  362.     private static void uppercase(StringBuilder word) {
  363.  
  364.         // return new StringBuilder(word.toString().toUpperCase());
  365.         String str = word.toString().toUpperCase();
  366.         word.replace(0, word.length(), str);
  367.         // System.out.println("Upper: " + word);
  368.     }
  369.  
  370.     private static void Ruppercase(StringBuilder word) {
  371.         String str = word.toString().toLowerCase();
  372.         word.replace(0, word.length(), str);
  373.     }
  374.  
  375. //Ny instants
  376.     private static void lowercase(StringBuilder word) {
  377.         String str = word.toString().toLowerCase();
  378.         word.replace(0, word.length(), str);
  379.     }
  380.  
  381.     private static void Rlowercase(StringBuilder word) {
  382.     }
  383.  
  384.     private static void toggleCaseLower(StringBuilder word) {
  385.         String str = word.toString();
  386.         char[] upper = str.toUpperCase().toCharArray();
  387.         char[] lower = str.toLowerCase().toCharArray();
  388.         for (int i = 0; i < upper.length; i++) {
  389.             if (i % 2 == 0) {
  390.                 word.setCharAt(i, lower[i]);
  391.             } else {
  392.                 word.setCharAt(i, upper[i]);
  393.             }
  394.         }
  395.     }
  396.  
  397.     private static void RtoggleCaseLower(StringBuilder word) {
  398.         lowercase(word);
  399.     }
  400.  
  401.     private static void toggleCaseHigher(StringBuilder word) {
  402.         String str = word.toString();
  403.         char[] upper = str.toUpperCase().toCharArray();
  404.         char[] lower = str.toLowerCase().toCharArray();
  405.         for (int i = 0; i < upper.length; i++) {
  406.             if (i % 2 == 0) {
  407.                 word.setCharAt(i, upper[i]);
  408.             } else {
  409.                 word.setCharAt(i, lower[i]);
  410.             }
  411.         }
  412.     }
  413.  
  414.     private static void nCap(StringBuilder word) {
  415.         char first = word.charAt(0);
  416.         uppercase(word);
  417.         word.setCharAt(0, first);
  418.     }
  419.  
  420.     private static void RnCap(StringBuilder word) {
  421.         lowercase(word);
  422.     }
  423.  
  424.     private static void RtoggleCaseHigher(StringBuilder word) {
  425.         lowercase(word);
  426.     }
  427.  
  428.     private static void runFunc(StringBuilder word, int choice, char c) {
  429.  
  430.         switch (choice) {
  431.             case 1:
  432.                 prepend(word, c);
  433.                 break;
  434.             case 2:
  435.                 append(word, c);
  436.                 break;
  437.             case 3:
  438.                 deleteFirst(word);
  439.                 break;
  440.             case 4:
  441.                 deleteLast(word);
  442.                 break;
  443.             case 5:
  444.                 reverse(word);
  445.                 break;
  446.             case 6:
  447.                 duplicate(word);
  448.                 break;
  449.             case 7:
  450.                 reflect1(word);
  451.                 break;
  452.             case 8:
  453.                 reflect2(word);
  454.                 break;
  455.             case 9:
  456.                 capitalize(word);
  457.                 break;
  458.  
  459.             case 10:
  460.                 lowercase(word);
  461.                 break;
  462.             case 11:
  463.                 uppercase(word);
  464.                 break;
  465.             case 12:
  466.                 toggleCaseLower(word);
  467.                 break;
  468.             case 13:
  469.                 toggleCaseHigher(word);
  470.                 break;
  471.             case 14:
  472.                 nCap(word);
  473.                 break;
  474.         }
  475.  
  476.     }
  477.  
  478.     private static void RrunFunc(StringBuilder word, int choice, char first, char last) {
  479.  
  480.         switch (choice) {
  481.             case 1:
  482.                 Rprepend(word);
  483.                 break;
  484.             case 2:
  485.                 Rappend(word);
  486.                 break;
  487.             case 3:
  488.                 RdeleteFirst(word, first);
  489.                 break;
  490.             case 4:
  491.                 RdeleteLast(word, last);
  492.                 break;
  493.             case 5:
  494.                 Rreverse(word);
  495.                 break;
  496.             case 6:
  497.                 Rduplicate(word);
  498.                 break;
  499.             case 7:
  500.                 Rreflect1(word);
  501.                 break;
  502.             case 8:
  503.                 Rreflect2(word);
  504.                 break;
  505.             case 9:
  506.                 Rcapitalize(word, first);
  507.  
  508.                 break;
  509.  
  510.             case 10:
  511.                 Rlowercase(word);
  512.                 break;
  513.             case 11:
  514.                 Ruppercase(word);
  515.             case 12:
  516.                 RtoggleCaseLower(word);
  517.                 break;
  518.             case 13:
  519.                 RtoggleCaseHigher(word);
  520.                 break;
  521.             case 14:
  522.                 RnCap(word);
  523.                 break;
  524.  
  525.         }
  526.  
  527.     }
  528.  
  529.     private class User {
  530.  
  531.         boolean cracked = false;
  532.         String salt;
  533.         String hash;
  534.         String name[];
  535.         String passClear = "???";
  536.  
  537.         private User(String fileLine) {
  538.             String[] data = fileLine.split(":");
  539.             salt = data[1].substring(0, 2);
  540.             hash = data[1];
  541.             name = data[4].split("\\s+");
  542.         }
  543.  
  544.         private User() {
  545.  
  546.         }
  547.  
  548.         @Override
  549.         public String toString() {
  550.             String names = "";
  551.             for (String part : name) {
  552.                 names = names + " " + part;
  553.             }
  554.  
  555.             String print = salt + " " + hash + " " + names + " " + passClear;
  556.             if (cracked) {
  557.                 return "YES " + print;
  558.             }
  559.             return "NO  " + print;
  560.         }
  561.     }
  562.    
  563.    
  564.  
  565. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement