SHARE
TWEET

HybridMaker

JunoSeferis Jul 1st, 2014 244 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #!usr/bin/perl
  2. my $NumArgs = $#ARGV + 1;#Determine the number of arguments the user has given us
  3. if ($NumArgs <= 1) {
  4.         #Our user has only entered some information. Display help screen.
  5.         header();
  6.         exit();}
  7. if ($NumArgs == 2) {   
  8.         my $dictfile = $ARGV[0]; #Host is the first argument supplied
  9.         my $complexlvl = $ARGV[1]; #Username is the 2nd argument supplied
  10.         print "Working...\n";
  11.        
  12.         if ($complexlvl == 1) {
  13.         #Minimal complexity; all we want to do is
  14.         #1 Plain word
  15.         #2 Plain with 2 digits at the end
  16.         #3 Convert to Uppercase with 2 digits at the end
  17.         #4 Front-End Cap with 2 digits at the end
  18.        
  19.         #Open dictionary file for processing
  20.         open DICTLIST, $dictfile or die$!;
  21.         my @listwords = DICTLIST;
  22.         while (my $curword = <DICTLIST>) {
  23.                 chomp($curword);
  24.                 my $outfile = 'hybrid.txt'; #Set hydrid output file
  25.                 open(HYBRID, ">>$outfile"); #Open file for writing
  26.                 #Output as PLAIN
  27.                 print HYBRID "$curword\n";
  28.                 #Output as PLAN with Front-End Cap
  29.                 print HYBRID ucfirst($curword) . "\n";
  30.                 #Output as PLAIN with all Caps
  31.                 print HYBRID uc $curword . "\n";
  32.                 #Output as plain w/ 2 digits
  33.                 for $i (0 .. 9) {
  34.                         print HYBRID "$curword" . $i . "\n";   
  35.                         }
  36.                 for (0 .. 99) {
  37.                         my $i = sprintf qq{%02d}, $_;
  38.                         print HYBRID "$curword" . $i . "\n";
  39.                         }
  40.                 #Output as Front-End Cap w/ 2 digits
  41.                 my $toprint = ucfirst lc $curword;
  42.                 for $i (0 .. 9) {
  43.                         print HYBRID "$toprint" . $i . "\n";   
  44.                         }
  45.                 for (0 .. 99) {
  46.                         my $i = sprintf qq{%02d}, $_;
  47.                         print HYBRID "$toprint" . $i . "\n";
  48.                         }
  49.                 #Output as Uppercase w/ 2 digits
  50.                 my $toprint = uc $curword;
  51.                 for $i (0 .. 9) {
  52.                         print HYBRID "$toprint" . $i . "\n";   
  53.                         }
  54.                 for (0 .. 99) {
  55.                         my $i = sprintf qq{%02d}, $_;
  56.                         print HYBRID "$toprint" . $i . "\n";
  57.                         }
  58.                         #Done for this iteration
  59.                 close(HYBRID);
  60.                 }
  61.         } #End routine for Lvl 1
  62.  
  63.         ######  ROUTINE 2  #########
  64.         if ($complexlvl == 2) {
  65.         #Marginal complexity; all we want to do is
  66.         #1 Plain word & !
  67.         #2 Plain with 2 digits at the end & !
  68.         #3 Convert to Uppercase with 2 digits at the end & !
  69.         #4 Front-End Cap with 2 digits at the end  & !
  70.        
  71.         #Open dictionary file for processing
  72.         open DICTLIST, $dictfile or die$!;
  73.         my @listwords = DICTLIST;
  74.         while (my $curword = <DICTLIST>) {
  75.                 chomp($curword);
  76.                 my $outfile = 'hybrid.txt'; #Set hydrid output file
  77.                 open(HYBRID, ">>$outfile"); #Open file for writing
  78.                 #Output as PLAIN & !
  79.                 print HYBRID "$curword!\n";
  80.                 #Output as PLAN with Front-End Cap & !
  81.                 print HYBRID ucfirst($curword) . "!\n";
  82.                 #Output as PLAIN with all Caps & !
  83.                 print HYBRID uc $curword . "!\n";
  84.                 #Output as plain w/ 2 digits & !
  85.                 for $i (0 .. 9) {
  86.                         print HYBRID "$curword" . $i . "!\n";  
  87.                         }
  88.                 for (0 .. 99) {
  89.                         my $i = sprintf qq{%02d}, $_;
  90.                         print HYBRID "$curword" . $i . "!\n";
  91.                         }
  92.                 #Output as Front-End Cap w/ 2 digits & !
  93.                 my $toprint = ucfirst lc $curword;
  94.                 for $i (0 .. 9) {
  95.                         print HYBRID "$toprint" . $i . "!\n";  
  96.                         }
  97.                 for (0 .. 99) {
  98.                         my $i = sprintf qq{%02d}, $_;
  99.                         print HYBRID "$toprint" . $i . "!\n";
  100.                         }      
  101.                 #Output as Uppercase w/ 2 digits & !
  102.                 my $toprint = uc $curword;
  103.                 for $i (0 .. 9) {
  104.                         print HYBRID "$toprint" . $i . "!\n";  
  105.                         }
  106.                 for (0 .. 99) {
  107.                         my $i = sprintf qq{%02d}, $_;
  108.                         print HYBRID "$toprint" . $i . "!\n";
  109.                         }
  110.                         #Done for this iteration
  111.                 close(HYBRID);
  112.                 }
  113.         } #End routine for Lvl 2               
  114.        
  115.         ######  ROUTINE 3  #########
  116.         if ($complexlvl == 3) {
  117.                 #Open dictionary file for processing
  118.                 open DICTLIST, $dictfile or die$!;
  119.                 my @listwords = DICTLIST;
  120.                         while (my $curword = <DICTLIST>) {
  121.                         chomp($curword);
  122.                         my $outfile = 'hybrid.txt'; #Set hydrid output file
  123.                         open(HYBRID, ">>$outfile"); #Open file for writing
  124.                         #Begin processing of the word and generate variations  
  125.                                         my $totalword = '';
  126.                                         my $foundchar = 0; #Variable to cancel variations past one
  127.                                         for $i (0 .. length($curword)) {
  128.                                         my $curchar = substr($curword, $i, 1);
  129.                                         #Begin replacing the first letter found ONLY
  130.                                                 my $addchar = $curchar; #Default to current character, replace ONLY if a match found.
  131.                                                 if (($curchar eq 'a') or ($curchar eq 'A')) {
  132.                                                         if ($foundchar < 1) {
  133.                                                         $addchar = 4;
  134.                                                         $foundchar = ($foundchar + 1);
  135.                                                         }                                                      
  136.                                                 }
  137.                                                 elsif (($curchar eq 'b') or ($curchar eq 'B')) {
  138.                                                         if ($foundchar < 1) {
  139.                                                         $addchar = 8;
  140.                                                         $foundchar = ($foundchar + 1);
  141.                                                         }
  142.                                                 }
  143.                                                 elsif (($curchar eq 'e') or ($curchar eq 'E')) {
  144.                                                         if ($foundchar < 1) {
  145.                                                         $addchar = 3;
  146.                                                         $foundchar = ($foundchar + 1);
  147.                                                         }
  148.                                                 }
  149.                                                 elsif (($curchar eq 'g') or ($curchar eq 'G')) {
  150.                                                         if ($foundchar < 1) {
  151.                                                         $addchar = 9;
  152.                                                         $foundchar = ($foundchar + 1);
  153.                                                         }
  154.                                                 }
  155.                                                 elsif (($curchar eq 'i') or ($curchar eq 'I')) {
  156.                                                         if ($foundchar < 1) {
  157.                                                         $addchar = 1;
  158.                                                         $foundchar = ($foundchar + 1);
  159.                                                         }
  160.                                                 }
  161.                                                 elsif (($curchar eq 'l') or ($curchar eq 'L')) {
  162.                                                         if ($foundchar < 1) {
  163.                                                         $addchar = 1;
  164.                                                         $foundchar = ($foundchar + 1);
  165.                                                         }
  166.                                                 }
  167.                                                 elsif (($curchar eq 'o') or ($curchar eq 'O')) {
  168.                                                         if ($foundchar < 1) {
  169.                                                         $addchar = 0;
  170.                                                         $foundchar = ($foundchar + 1);
  171.                                                         }
  172.                                                 }
  173.                                                 elsif (($curchar eq 's') or ($curchar eq 'S')) {
  174.                                                         if ($foundchar < 1) {
  175.                                                         $addchar = 5;
  176.                                                         $foundchar = ($foundchar + 1);
  177.                                                         }
  178.                                                 }
  179.                                                 elsif (($curchar eq 't') or ($curchar eq 'T')) {
  180.                                                         if ($foundchar < 1) {
  181.                                                         $addchar = 7;
  182.                                                         $foundchar = ($foundchar + 1);
  183.                                                         }
  184.                                                 }
  185.                                                 elsif (($curchar eq 'z') or ($curchar eq 'Z')) {
  186.                                                         if ($foundchar < 1) {
  187.                                                         $addchar = 2;
  188.                                                         $foundchar = ($foundchar + 1);
  189.                                                         }
  190.                                                 }
  191.                         #Add current character to list and repeat
  192.                         $totalword = ($totalword . $addchar);
  193.                         }
  194.                         #Output as PLAIN
  195.                         print HYBRID "$totalword\n";
  196.                         #Output as PLAIN with Front-End Cap
  197.                         print HYBRID ucfirst($totalword) . "\n";
  198.                         #Output as PLAIN with all Caps
  199.                         print HYBRID uc $totalword . "\n";     
  200.                 #Done for this iteration       
  201.                 close(HYBRID);
  202.                 }
  203.         } #End routine for Lvl 3
  204.        
  205.         ######  ROUTINE 4  #########
  206.         if ($complexlvl == 4) {
  207.                 #Open dictionary file for processing
  208.                 open DICTLIST, $dictfile or die$!;
  209.                 my @listwords = DICTLIST;
  210.                         while (my $curword = <DICTLIST>) {
  211.                         chomp($curword);
  212.                         my $outfile = 'hybrid.txt'; #Set hydrid output file
  213.                         open(HYBRID, ">>$outfile"); #Open file for writing
  214.                         #Begin processing of the word and generate variations  
  215.                                         my $totalword = '';
  216.                                         for $i (0 .. length($curword)) {
  217.                                         my $curchar = substr($curword, $i, 1);
  218.                                         #Begin replacing the first letter found ONLY
  219.                                                 my $addchar = $curchar; #Default to current character, replace ONLY if a match found.
  220.                                                
  221.                                                 if (($curchar eq 'a') or ($curchar eq 'A')) {
  222.                                                         $addchar = 4;
  223.                                                 }
  224.                                                 elsif (($curchar eq 'b') or ($curchar eq 'B')) {
  225.                                                         $addchar = 8;
  226.                                                 }
  227.                                                 elsif (($curchar eq 'e') or ($curchar eq 'E')) {
  228.                                                         $addchar = 3;
  229.                                                 }
  230.                                                 elsif (($curchar eq 'g') or ($curchar eq 'G')) {
  231.                                                         $addchar = 9;
  232.                                                 }
  233.                                                 elsif (($curchar eq 'i') or ($curchar eq 'I')) {
  234.                                                         $addchar = 1;
  235.                                                 }
  236.                                                 elsif (($curchar eq 'l') or ($curchar eq 'L')) {
  237.                                                         $addchar = 1;
  238.                                                 }
  239.                                                 elsif (($curchar eq 'o') or ($curchar eq 'O')) {
  240.                                                         $addchar = 0;
  241.                                                 }
  242.                                                 elsif (($curchar eq 's') or ($curchar eq 'S')) {
  243.                                                         $addchar = 5;
  244.                                                 }
  245.                                                 elsif (($curchar eq 't') or ($curchar eq 'T')) {
  246.                                                         $addchar = 7;
  247.                                                 }
  248.                                                 elsif (($curchar eq 'z') or ($curchar eq 'Z')) {
  249.                                                         $addchar = 2;
  250.                                                 }
  251.                         #Add current character to list and repeat
  252.                         $totalword = ($totalword . $addchar);
  253.                         }
  254.                         #Output as PLAIN
  255.                         print HYBRID "$totalword\n";
  256.                         #Output as PLAIN with Front-End Cap
  257.                         print HYBRID ucfirst($totalword) . "\n";
  258.                         #Output as PLAIN with all Caps
  259.                         print HYBRID uc $totalword . "\n";
  260.                 #Done for this iteration       
  261.                 close(HYBRID);
  262.                 }
  263.         } #End routine for Lvl 4       
  264.        
  265.         ######  ROUTINE 5  #########
  266.         if ($complexlvl == 5) {
  267.                 #Open dictionary file for processing
  268.                 open DICTLIST, $dictfile or die$!;
  269.                 my @listwords = DICTLIST;
  270.                         while (my $curword = <DICTLIST>) {
  271.                         chomp($curword);
  272.                         my $outfile = 'hybrid.txt'; #Set hydrid output file
  273.                         open(HYBRID, ">>$outfile"); #Open file for writing
  274.                         #Begin processing of the word and generate variations  
  275.                                         my $totalword = '';
  276.                                         my $foundchar = 0; #Variable to cancel variations past one
  277.                                         for $i (0 .. length($curword)) {
  278.                                         my $curchar = substr($curword, $i, 1);
  279.                                         #Begin replacing the first letter found ONLY
  280.                                                 my $addchar = $curchar; #Default to current character, replace ONLY if a match found.
  281.                                                 if (($curchar eq 'a') or ($curchar eq 'A')) {
  282.                                                         if ($foundchar < 1) {
  283.                                                         $addchar = 4;
  284.                                                         $foundchar = ($foundchar + 1);
  285.                                                         }                                                      
  286.                                                 }
  287.                                                 elsif (($curchar eq 'b') or ($curchar eq 'B')) {
  288.                                                         if ($foundchar < 1) {
  289.                                                         $addchar = 8;
  290.                                                         $foundchar = ($foundchar + 1);
  291.                                                         }
  292.                                                 }
  293.                                                 elsif (($curchar eq 'e') or ($curchar eq 'E')) {
  294.                                                         if ($foundchar < 1) {
  295.                                                         $addchar = 3;
  296.                                                         $foundchar = ($foundchar + 1);
  297.                                                         }
  298.                                                 }
  299.                                                 elsif (($curchar eq 'g') or ($curchar eq 'G')) {
  300.                                                         if ($foundchar < 1) {
  301.                                                         $addchar = 9;
  302.                                                         $foundchar = ($foundchar + 1);
  303.                                                         }
  304.                                                 }
  305.                                                 elsif (($curchar eq 'i') or ($curchar eq 'I')) {
  306.                                                         if ($foundchar < 1) {
  307.                                                         $addchar = 1;
  308.                                                         $foundchar = ($foundchar + 1);
  309.                                                         }
  310.                                                 }
  311.                                                 elsif (($curchar eq 'l') or ($curchar eq 'L')) {
  312.                                                         if ($foundchar < 1) {
  313.                                                         $addchar = 1;
  314.                                                         $foundchar = ($foundchar + 1);
  315.                                                         }
  316.                                                 }
  317.                                                 elsif (($curchar eq 'o') or ($curchar eq 'O')) {
  318.                                                         if ($foundchar < 1) {
  319.                                                         $addchar = 0;
  320.                                                         $foundchar = ($foundchar + 1);
  321.                                                         }
  322.                                                 }
  323.                                                 elsif (($curchar eq 's') or ($curchar eq 'S')) {
  324.                                                         if ($foundchar < 1) {
  325.                                                         $addchar = 5;
  326.                                                         $foundchar = ($foundchar + 1);
  327.                                                         }
  328.                                                 }
  329.                                                 elsif (($curchar eq 't') or ($curchar eq 'T')) {
  330.                                                         if ($foundchar < 1) {
  331.                                                         $addchar = 7;
  332.                                                         $foundchar = ($foundchar + 1);
  333.                                                         }
  334.                                                 }
  335.                                                 elsif (($curchar eq 'z') or ($curchar eq 'Z')) {
  336.                                                         if ($foundchar < 1) {
  337.                                                         $addchar = 2;
  338.                                                         $foundchar = ($foundchar + 1);
  339.                                                         }
  340.                                                 }
  341.                         #Add current character to list and repeat
  342.                         $totalword = ($totalword . $addchar);
  343.                         }
  344.                         #Print final word & !
  345.                         print HYBRID "$totalword!\n";
  346.                         #Output as PLAIN with Front-End Cap
  347.                         print HYBRID ucfirst($totalword) . "!\n";
  348.                         #Output as PLAIN with all Caps
  349.                         print HYBRID uc $totalword . "!\n";
  350.                 #Done for this iteration       
  351.                 close(HYBRID);
  352.                 }
  353.         } #End routine for Lvl 5
  354.        
  355.         ######  ROUTINE 6  #########
  356.         if ($complexlvl == 6) {
  357.                 #Open dictionary file for processing
  358.                 open DICTLIST, $dictfile or die$!;
  359.                 my @listwords = DICTLIST;
  360.                         while (my $curword = <DICTLIST>) {
  361.                         chomp($curword);
  362.                         my $outfile = 'hybrid.txt'; #Set hydrid output file
  363.                         open(HYBRID, ">>$outfile"); #Open file for writing
  364.                         #Begin processing of the word and generate variations  
  365.                                         my $totalword = '';
  366.                                         for $i (0 .. length($curword)) {
  367.                                         my $curchar = substr($curword, $i, 1);
  368.                                         #Begin replacing the first letter found ONLY
  369.                                                 my $addchar = $curchar; #Default to current character, replace ONLY if a match found.
  370.                                                
  371.                                                 if (($curchar eq 'a') or ($curchar eq 'A')) {
  372.                                                         $addchar = 4;
  373.                                                 }
  374.                                                 elsif (($curchar eq 'b') or ($curchar eq 'B')) {
  375.                                                         $addchar = 8;
  376.                                                 }
  377.                                                 elsif (($curchar eq 'e') or ($curchar eq 'E')) {
  378.                                                         $addchar = 3;
  379.                                                 }
  380.                                                 elsif (($curchar eq 'g') or ($curchar eq 'G')) {
  381.                                                         $addchar = 9;
  382.                                                 }
  383.                                                 elsif (($curchar eq 'i') or ($curchar eq 'I')) {
  384.                                                         $addchar = 1;
  385.                                                 }
  386.                                                 elsif (($curchar eq 'l') or ($curchar eq 'L')) {
  387.                                                         $addchar = 1;
  388.                                                 }
  389.                                                 elsif (($curchar eq 'o') or ($curchar eq 'O')) {
  390.                                                         $addchar = 0;
  391.                                                 }
  392.                                                 elsif (($curchar eq 's') or ($curchar eq 'S')) {
  393.                                                         $addchar = 5;
  394.                                                 }
  395.                                                 elsif (($curchar eq 't') or ($curchar eq 'T')) {
  396.                                                         $addchar = 7;
  397.                                                 }
  398.                                                 elsif (($curchar eq 'z') or ($curchar eq 'Z')) {
  399.                                                         $addchar = 2;
  400.                                                 }
  401.                         #Add current character to list and repeat
  402.                         $totalword = ($totalword . $addchar);
  403.                         }
  404.                         #Print final word
  405.                         print HYBRID "$totalword!\n";
  406.                         #Output as PLAIN with Front-End Cap
  407.                         print HYBRID ucfirst($totalword) . "!\n";
  408.                         #Output as PLAIN with all Caps
  409.                         print HYBRID uc $totalword . "!\n";
  410.                 #Done for this iteration       
  411.                 close(HYBRID);
  412.                 }
  413.         } #End routine for Lvl 6       
  414.        
  415.  
  416. #END OF ALL COMPLEXITY LEVEL ROUTINES
  417. close(DICTLIST);
  418. } #End main function
  419. print "List generated!\n";
  420. exit();
  421. sub header{
  422. print qq{
  423. ----------------------------------------------------------------------
  424.                           Hybrid Maker                   
  425.                         Custom Built by Juno                     
  426.                               NBTDOTM                                
  427. ----------------------------------------------------------------------
  428. Usage: hybrid [dictionary] [complexity level]
  429.  
  430. Example: hybrid passwords.txt 3
  431.  
  432. This program will take a standard dictionary file (no combo lists) and
  433. create hybrid variations based off of each word in the supplied list.
  434. Additionally, the user may select a level of complexity to control the
  435. size of the output.  For example, the password 'test' will
  436. result in the follow variations:
  437. Lvl 1 (332 variations): test, Test, TEST, test0-99, Test0-99, TEST0-99
  438.         Common caps variation(CCV) with 2 digit numeric bruteforce appended.
  439. Lvl 2 (332 variations): test!, Test!, TEST!, test0-99!, Test0-99!, TEST0-99!
  440.         Same as Lvl 1 with an exclamation mark appended.
  441. Lvl 3: Replaces first possible letter found with hybrid equivilent.
  442.         Example: 'Password' becomes 'P4ssword'.  No appended numbers. CCV.
  443. Lvl 4: Replaces every possible letter with hybrid equivilent.
  444.         Example: 'Password' becomes 'P455w0rd'.  No appended numbers. CCV.
  445. Lvl 5: Replaces first possible letter with hybrid equivilent and appends !.
  446.         Example: 'Password' becomes 'P4ssword!'. CCV.
  447. Lvl 6: Replaces all possible letters with hybrid equivilents and appends !.
  448.         Example: 'Password' becomes 'P455w0rd!'. CCV.
  449.                
  450. The generated file is named hybrid.txt and placed in the current
  451. directory.  This program may also be run again with another complexity
  452. level; the results will simply be appended to hybrid.txt.  Cheers!
  453. };
  454. }
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