Help with Cudahashcat mask.

Hello all.

First off all sorry for my bad english.:P

I am trying 2 make a mask in cudahashcat for crack techniccolor routers.

Have checked alot of different off those routers and notice that in most of the model and version it contains only a 10 long password for wpa and only diggits and numbers.

Have run the cuda with this settigs.

Code:

---

optirun cudahashcat64 -m 2500 -a 3 /root/handshake.hccap -1 ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ?1?1?1?1?1?1?1?1?1?1

---

And that works perfect exept the fact that it would take "time>10 years" to bruteforce all combos:P

So i wounder if its possible to add some more rules in cuda haschcat like "only 2 same character in a row" "only 2 repeat (like abab)" and so on to reduce the number of combinations, couse i dont think a password will have like 3 a in a row.

I cant find any options in cudahashcat that will let me do this.

I have a script i tried 2 add in cudahashcat but i cant make it work, but i make it work with pyrit i think, but pyrit dont show combos remaining or time remaining:/

The script is

Code:

---

#!/usr/bin/perl
 
=head1 NAME
 
wg.pl
 
 
=head1 AUTHOR
 
Matteo Redaelli
E-MAIL: [email protected]
WEB:    http://digilander.iol.it/reda
 
 
=head1 DESCRIPTION
 
This is a Word Generator: you can apply some useful options to filter the
words
 
=head1 USAGE
 
type  perl wg.pl -h
 
 
=head1 HISTORY
 
 
2000-01-06: the first lines of this script
 
2000-01-11 added getopt
 
2000-01-21: adjusted default parameters
 
2002-03-05: new option -n
 
2002-03-06: new option -s
 
2002-03-07: reorganization of all source code, more documentation
       
 
 
=head1 LICENSE
 
This package is free software; you can redistribute it and/or
modify it under the same terms as Perl itself, i.e., under the
terms of the "Artistic License" or the "GNU General Public License".
 
 
=head1 DISCLAIMER
 
This package is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the "GNU General Public License" for more details.
 
 
=cut
 
use Getopt::Std;
use strict;
 
#use integer;
 
sub char2string {
 
    # string generator: if I pass 'a' and 5, I'll get 'aaaaa'
    sprintf "%s", @_[0] x @_[1];
}
 
sub occurs {
    my $pat    = @_[0];
    my $astring = @_[1];
 
    my $tot = $astring =~ s/$pat//g;
 
    #        print "tot $tot\n";
    #
    return $tot;
}
 
sub few_repeatitions {
    my $astring = @_[0];
    my $max    = @_[1];
    my $len    = length($astring);
    my $tot    = 0;
 
    my $mid = int( $len / 2 );
 
    for ( my $step = 2 ; $step <= $mid ; $step++ ) {
        for ( 0 .. $len - $step ) {
            my $letters = substr( $astring, $_, $step );
 
            #        print "$letters\n";
            $tot = occurs( $letters, $astring );
            return $tot if $tot > $max;
        }
    }
    return 0;
}
 
sub nple {
    my $astring = @_[0];
    my $len    = length($astring);
    my $tot    = 0;
    my $in      = 0;
    my $last    = ' ';
 
    for ( 0 .. $len - 1 ) {
        my $letter = substr( $astring, $_, 1 );
 
        #        print "$astring  $letter $last\n";
        if ( ( $letter cmp $last ) == 0 ) {
 
            #                        print "$letter =  $last, $in, $tot";
            if ( $in == 0 ) {
                $in = 1;
                $tot++;
            }
 
        }
        else {
            $in = 0;
        }
 
        $last = $letter;
    }
    return $tot;
 
}
 
sub substring {
    my $string1 = @_[0];
    my $string2 = @_[1];
 
    $_ = $string2;
 
    if (/$string1/) {
        return 0;
    }
    else {
        return 1;
    }
}
 
my %opts;
 
getopts( 'a:c:ehl:n:o:r:tu:v:z:', \%opts );
 
usage(0) if $opts{'h'};
$opts{'u'} and $opts{'v'} or usage(1);
 
# setup parameters
 
my $va_list = $opts{'v'};
my @va_list = split( //, $va_list );    # convert string to an array
 
my $min_depth = $opts{'l'} ? int( $opts{'l'} ) : 1;
my $max_depth = $opts{'u'} ? int( $opts{'u'} ) : 1;
 
usage(2) if $min_depth > $max_depth;
 
my $prefix    = $opts{'a'} ? $opts{'a'}        : '';
my $postfix    = $opts{'z'} ? $opts{'z'}        : '';
my $max_occurs = $opts{'o'} ? int( $opts{'o'} ) : $opts{'u'};
my $max_cons  = $opts{'c'} ? int( $opts{'c'} ) : $opts{'u'};
my $max_nple  = $opts{'n'};
my $max_reps  = $opts{'r'};
 
usage(3)
  if $min_depth < 1
      || $max_depth < 1
      || $max_occurs < 1
      || $max_cons < 1
      || $max_nple < 0
      || $max_reps < 0;
 
if ( $opts{'t'} ) {
    print "Options:\n";
    foreach my $key ( sort keys %opts ) { print "$key -> $opts{$key}\n"; }
    print "Global vars:\n";
    print_vars();
}
 
for ( $min_depth .. $max_depth ) {
    wg( $_, "" );
}
 
sub print_vars {
    print "min_depth = $min_depth\n";
    print "max_depth =  $max_depth\n";
    print "max_occurs = $max_occurs\n";
    print "max_cons = $max_cons\n";
    print "max_nple = $max_nple\n";
    print "max_reps = $max_reps\n";
}
 
#
# word generator
#
sub wg {
    my $max_depth = @_[0];
    my $myprefix  = @_[1];
    my $elem;
    if ( $max_depth == 0 ) {
        print "$prefix$myprefix$postfix\n";
        if ( $opts{e} == 1 ) {
            system "$prefix$myprefix$postfix\n";
        }
    }
    else {
 
        #                print " n = $opts{'n'} r = $opts{'r'} \n";
        #
 
        #                suggestion: the generation of the words is more variuos if
        #                I change the order of the list of the letters (@va_list)
 
        foreach $elem (@va_list) {
 
            my $newstring = "$myprefix$elem";
 
            return
              if ( $opts{'c'}
                && substring( char2string( $elem, $max_cons ), $myprefix ) ==
                0 );
            return if ( $opts{'n'} && nple($newstring) > $max_nple );
            return
              if ( $opts{'r'}
                && few_repeatitions( $newstring, $max_reps ) != 0 );
            return
              if ( $opts{'o'} && occurs( "$elem", $newstring ) > $max_occurs );
 
            wg( $max_depth - 1, "$myprefix$elem" );
        }
    }
}
 
sub usage {
    my $rc = @_[0];
 
    die <<END_USAGE
 
USAGE: perl $0 options
 
options are:
        -a string: prefix
        -c number: max consecutive letters (how many consecutive 'a' do you want?)
        -e : submit the output string to the operating system
        -h : help
        -l number: min length of the word
        -o number: max number of occurrencies of a letter
        -n number: max number of n-ple  (AA, BBB, CCC, DDDD)
        -r number: max number of repeatitions (ABCABABBCDBCD has 5 repeatitions: 3 reps of AB and 2 of BCD)
        -t : trace on
        -u number: max length of the word
        -v string: list of valid characters (es, "01" "abcdef")
        -z string: postfix
 
possible return code are:
        0, ok
        1, not all parameters
        2, min length (-l) is greater than max lenght (-u)
        3, at least one parameter is lower than 1
Return code: $rc
END_USAGE
 
}

---

And i run it with pyrit like this

Code:

---

perl script.pl -c 2 -l 10 -o 3 -n 2 -r 3 -u 10 -v "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" | pyrit -e essid -i - -r /root/handshake.cap attack_passthrough

---

Is there anyway to run this script with cudahashcat somehow??

Many thanks// squash