PHP force brute générateur de mot de passe

Je veux être en mesure d'entrer un numéro et un mot de passe, construite à partir d'une chaîne de caractères ou des caractères uniques. Donc, si j'ai deux caractères dans la chaîne : $string = "AB"; ce sont les résultats souhaités :

-in- | -out-
 0  |  A
 1  |  B
 2  | AA
 3  | AB
 4  | BA
 5  | BB
 6  | AAA
 7  | AAB
 8  | ABA
 9  | ABB
 10 | BBB

Et ainsi de suite. Voici mon code actuel :

for($i = 1; $i < 100; $i++)
{
    echo createString ($i, "AB")."<br/>";
}
function createString ($id, $chars) //THE ISSUE <---
{
    $length = getLength($id, $chars);
    //echo "LENGTH : ".$length."<br/><br/>";
    $string = "";
    for($i = 0; $i < $length; $i++)
    {
        $a = round(($id - 1)/pow($length, $i)); //THE ISSUE <-----
        $local = local($a, strlen($chars));
        $string = $chars{$local - 1}." : ".$string;
    }
    return $string;
}
function local ($num, $max)
{
    $num += $max;
    while($num > $max)
    {
        $num -= $max;
    }
    return $num;
}
/*
 get the length of the output by inputing the "in" and defining the possible characters
*/
function getLength ($id, $chars)
{
    $charNUM = 1;
    $LR = -1;
    $HR = 0;
    while(true)
    {
        $LR = $HR;
        $HR = pow(strlen($chars), $charNUM) + $LR;
        $LR += 1;
        //echo $LR." : ".$HR." : ".$charNUM."<br/>";
        if($id >= $LR && $id <= $HR)
        {
            return $charNUM;
        }
        if($id < $LR)
        {
            return false;
        }
        $charNUM ++;
    }
}

Que les sorties :

B : 
A : 
A : B : 
B : A : 
B : B : 
A : A : 
A : B : B : 
A : B : A : 
A : A : B : 
A : A : A : 
A : A : B : 
A : B : A : 
A : B : B : 
A : B : A : 
B : A : B : B : 
B : A : B : A : 
B : A : B : B : 
B : A : B : A : 
B : A : A : B : 
B : A : A : A : 
B : A : A : B : 
B : A : A : A : 
B : A : B : B : 
B : A : B : A : 
B : B : B : B : 
B : B : B : A : 
B : B : A : B : 
B : B : A : A : 
B : B : A : B : 
B : B : A : A : 
B : B : A : B : B : 
B : B : A : B : A : 
B : B : A : B : B : 
B : B : A : A : A : 
B : B : A : A : B : 
B : B : A : A : A : 
B : B : A : A : B : 
B : B : A : A : A : 
B : B : B : B : B : 
B : B : B : B : A : 
B : B : B : B : B :

Et ainsi de suite. Mais il a des répétitions. Je vais avoir des problèmes avec la fonction createString(). Je veux accéder à un mot de passe quelque part en bas de la force brutale mot de passe de la table sans l'avoir pré-calculé. Je ne veux pas d'une pré-calculés tableau et d'accéder simplement à un point.

pas de répéter comme ça, mais il retourne la même pense, par exemple: AAA et AAA, AAA = AAA
Puis-je droit: Vous voulez rendre un certain Nombre dans un système où vous définissez vos chiffres par l'intermédiaire d'une chaîne. Donc la base de votre système serait la longueur de la chaîne et de la i-ième digit le char à la i-ème position dans la chaîne?
c'est l'idée. dans le code où j'ai la balise //<- la QUESTION est de savoir où est compilé.
Vous devriez poster votre solution comme une réponse et de l'accepter.
Votre solution me donne(ideone.com/Fh4tR): A, B, BA, BB, AA, AB, ABA, ABB, AAA, BAB, BBA, BBB ... de sorte qu'il semble ne pas s'adapter à votre sortie désirée.

OriginalL'auteur Patrick Lorio | 2011-08-11

4

Je vais poster ici le code de traduire n'importe quel nombre entier positif à un système tout entier positif donné de base (>1) le retour de la valeur de chaque chiffre.
```
function convert($number, $base)
{
$return = array();
do{
$return[] = $number % $base;
$number = floor($number / $base);
}while($number != 0);
return $return;
}
```
De sorte que vous appelez utiliser cette fonction comme suit:
```
function createString($i, $base)
{
$res = convert($i, strlen($base));
$str = "";
foreach($res as $digit)
{
$str = $base[$digit] . $str;
}
return $str;
}
```
De l'essayer. Il est mis en forme un peu différente de celle de votre sortie, mais doit être lisible.

Certains expamle de sortie pour la base "AB":
```
0 -> A    
1 -> B
2 -> BA
3 -> BB
4 -> BAA
5 -> BAB
6 -> BBA
7 -> BBB
8 -> BAAA
9 -> BAAB
10-> BABA
11-> BABB
12-> BBAA
13-> BBAB
14-> BBBA
15-> BBBB
```
Notez que cela ne vous donne pas les résultats que vous avez indiqué dans votre "résultats escomptés", parce que votre sortie n'a pas été un comptage en base 2 du système.

OriginalL'auteur Nobody
3

Bon vieux récursivité
```
$string = "AB";
$characters = str_split($string, 1);
function mutate ($characters, $count) {
var_dump($characters);
if (!$count) return $characters;
$result = $tmp = mutate($characters, $count -1);
foreach ($characters as $char) {
foreach ($tmp as $current) {
$result[] = $current . $char;
}
}
return $result;
}
```
Bonjour, j'ai essayé votre code, il est très joli. Je l'ai essayé pour 7 lettre et a obtenu erreur fatale toute la mémoire, l'extracteur, j'ai donc mis plus de mémoire et il s'est écrasé mon ordinateur. Il est très lourd de la paix de code.
oha, il y a longtemps ^^ tout d'Abord, il pourrait être causé par vos paramètres: Peut-être la limite de la mémoire est simplement (inutile) de petite taille. L'algorithme peut créer une énorme quantité de chaînes de caractères dans la mémoire, donc le plus causé le problème d'origine: Il est juste beaucoup de trucs voulu. Vous pouvez utiliser une base de données pour pousser actuellement indésirables les chaînes de loin pour utilisation ultérieure.

OriginalL'auteur KingCrunch

Solution:

function id_encode($id, $chars) {
$len = strlen($chars);
$i = 1;
$str = array();
while ($id >= 0) {
$str[] = $chars[ $id / pow($len, $i - 1) % $len ];
$id -= pow($len, $i);
$i++;
}
return strrev(implode('', $str));
}
function id_decode($str, $chars) {
$len = strlen($chars);
$chars = array_flip(str_split($chars));
$strs = str_split(strrev($str));
$i = 0;
foreach ($strs as $key => $char) {
if (!$i) {
$id = $chars[ $char ];
}
else {
$id += pow($len, $i) * ($chars[ $char ] + 1);
}
$i++;
}
return $id;
}

Exemple:

$chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_';
$id = 42599293;
$string = id_encode($id, $chars);
echo 'id:          ' . $id . PHP_EOL;
echo 'id_encode(): ' . $string . PHP_EOL;
echo 'id_decode(): ' . id_decode($string, $chars) . PHP_EOL;

De sortie:

id:          42599293
id_encode(): bHFm9
id_decode(): 42599293

Exemple 2:

$chars = 'AB';
$len = strlen($chars);
for ($i = 0; $i < 50; $i++) {
if ($i) {
if (!($i % $len)) {
echo PHP_EOL;
}
else {
echo ', ';
}
}
$str = id_encode($i, $chars);
$id = id_decode($str, $chars);
echo $i . '=' . $str . '=' . $id;
}

Sortie 2:

0=A=0, 1=B=1
2=AA=2, 3=AB=3
4=BA=4, 5=BB=5
6=AAA=6, 7=AAB=7
8=ABA=8, 9=ABB=9
10=BAA=10, 11=BAB=11
12=BBA=12, 13=BBB=13
14=AAAA=14, 15=AAAB=15
16=AABA=16, 17=AABB=17
18=ABAA=18, 19=ABAB=19
20=ABBA=20, 21=ABBB=21
22=BAAA=22, 23=BAAB=23
24=BABA=24, 25=BABB=25
26=BBAA=26, 27=BBAB=27
28=BBBA=28, 29=BBBB=29
30=AAAAA=30, 31=AAAAB=31
32=AAABA=32, 33=AAABB=33
34=AABAA=34, 35=AABAB=35
36=AABBA=36, 37=AABBB=37
38=ABAAA=38, 39=ABAAB=39
40=ABABA=40, 41=ABABB=41
42=ABBAA=42, 43=ABBAB=43
44=ABBBA=44, 45=ABBBB=45
46=BAAAA=46, 47=BAAAB=47
48=BAABA=48, 49=BAABB=49

De crédit pour id_encode() va à @PatrickLorio. id_decode() a été construit par moi-même avec le calcul à la main:
PHP force brute générateur de mot de passe

Je pense qu'après, il est possible d'optimiser id_encode() en prenant la n-ième racine de la carte d'identité... peut-être que je trouve le temps de vérifier.

OriginalL'auteur mgutt

Vous devez vous connecter pour publier un commentaire.