Bem

ficava imaginando como um brute force trabalhava como ele fazia os testes como

aa, ab, ac, ad, ae, af, etc...
Queria saber como ele gerava essas string's.
Bem com sabemos, cada letra tem um respectivo valor na tabela Ascii por exemplo, a letra A o valor em Ascii dela é 65 a letra B o valor dela é 66, ou seja, baseado nesses valores que é gerado as listas.

Abaixo uma tabela Ascii.

Caracter	Decimal	Hexadecimal	Binário
NUL	00	00	0000 0000
SOH	01	01	0000 0001
STX	02	02	0000 0010
ETX	03	03	0000 0011
EOT	04	04	0000 0100
ENQ	05	05	0000 0101
ACK	06	06	0000 0110
BEL	07	07	0000 0111
BS	08	08	0000 0100
HT	09	09	0000 1001
LF	10	0A	0000 1010
VT	11	0B	0000 1011
FF	12	0C	0000 1100
CR	13	0D	0000 1101
SO	14	0E	0000 1110
SI	15	0F	0000 1111
DLE	16	10	0001 0000
D1	17	11	0001 0001
D2	18	12	0001 0010
D3	19	13	0001 0011
D4	20	14	0001 0100
NAK	21	15	0001 0101
SYN	22	16	0001 0110
ETB	23	17	0001 0111
CAN	24	18	0001 1000
EM	25	19	0001 1001
SUB	26	1A	0001 1010
ESC	27	1B	0001 1011
FS	28	1C	0001 1100
GS	29	1D	0001 1101
RS	30	1E	0001 1110
US	31	1F	0001 1111
Espaço	32	20	0010 0000
!	33	21	0010 0001
"	34	22	0010 0010
#	35	23	0010 0011
$	36	24	0010 0100
%	37	25	0010 0101
&	38	26	0010 0110
'	39	27	0010 0111
(	40	28	0010 1000
)	41	29	0010 1001
*	42	2A	0010 1010
+	43	2B	0010 1011
,	44	2C	0010 1100
-	45	2D	0010 1101
.	46	2E	0010 1110
/	47	2F	0010 1111
0	48	30	0011 0000
1	49	31	0011 0001
2	50	32	0011 0010
3	51	33	0011 0011
4	52	34	0011 0100
5	53	35	0011 0101
6	54	36	0011 0110
7	55	37	0011 0111
8	56	38	0011 1000
9	57	39	0011 1001
:	58	3A	0011 1010
;	59	3B	0011 1011
<	60	3C	0011 1100
=	61	3D	0011 1101
>	62	3E	0011 1110
?	63	3F	0011 1111
@	64	40	0100 0000
A	65	41	0100 0001
B	66	42	0100 0010
C	67	43	0100 0011
D	68	44	0100 0100
E	69	45	0100 0101
F	70	46	0100 0110
G	71	47	0100 0111
H	72	48	0100 1000
I	73	49	0100 1001
J	74	4A	0100 1010
K	75	4B	0100 1011
L	76	4C	0100 1100
M	77	4D	0100 1101
N	78	4E	0100 1110
O	79	4F	0100 1111
P	80	50	0101 0000
Q	81	51	0101 0001
R	82	52	0101 0010
S	83	53	0101 0011
T	84	54	0101 0100
U	85	55	0101 0101
V	86	56	0101 0110
W	87	57	0101 0111
X	88	58	0101 1000
Y	89	59	0101 1001
Z	90	5A	0101 1010
[	91	5B	0101 1011
	92	5C	0101 1100
]	93	5D	0101 1101
^	94	5E	0101 1110
_	95	5F	0101 1111
`	96	60	0110 0000
a	97	61	0110 0001
b	98	62	0110 0010
c	99	63	0110 0011
d	100	64	0110 0100
e	101	65	0110 0101
f	102	66	0110 0110
g	103	67	0110 0111
h	104	68	0110 1000
i	105	69	0110 1001
j	106	6A	0110 1010
k	107	6B	0110 1011
l	108	6C	0110 1100
m	109	6D	0110 1101
n	110	6E	0110 1110
o	111	6F	0110 1111
p	112	70	0111 0000
q	113	71	0111 0001
r	114	72	0111 0010
s	115	73	0111 0011
t	116	74	0111 0100
u	117	75	0111 0101
v	118	76	0111 0110
w	119	77	0111 0111
x	120	78	0111 1000
y	121	79	0111 1001
z	122	7A	0111 1010
{	123	7B	0111 1011
|	124	7C	0111 1100
}	125	7D	0111 1101
~	126	7E	0111 1110
DELETE	127	7F	0111 1111

Bem a lógica inicial é temos um valor inicial e um valor final vamos dar o exemplo que o valor inical seja 97, letra a, e o valor final seja 100, letra d. A primeira sequência é bem simples apenas todas as letras

a b c d

Depois de ser gerado o último caracter que no caso é d vai ser adicionado um letra com o valor inical, no caso a.

aa

Bem depois disso dever ser modificado apenas o último caracter gerando:

aa ab ac ad

Quando o valor chegar em d o caracter anterior deve ser modificado para o próximo caracter e todo o restante deve ser inicializado.

ba bb bc bd

Vamos pegar um exemplo um pouco maior abcaab o próxima sequência seria:

abcaab abcaac abcaad

Quando chegar em d vai ser modificado o anterior e inicializando do o resto

abcaba abcabb abcabc abcabd

Bem chegou em d vai ser modificando o anteiror e inicializado todo o resto

abcaca abcacb abcacc abcacd

Bem vamos imaginar a seguinte situação

abddd

Enquanto é a letra d vai voltando um caracter modificando assim o caracter b para c acaaa e inicializando todo o resto

acaaa acaab acaac acaad

A lógica de criar todos os tipos de strings seria essa. Desenvolvi um código em vb6 para ilustrar todo se raciocínio. Crie um novo projeto adicione um Text com o nome Text1 e um Timer com o nome Timer1 coloque o interval do timer1 para 1000.

Abaixo uma breve explicação de como funciona o código.
Começando pelas as váriaveis públicas.

Dim index As Integer

A váriavel index vai conter o valor de qual posição da string vai ser modificada por exemplo

aabcd

O valor que será modificado seria a string c, então o meu index nesse momento seria 4, que é a posição da letra c.

Dim str As String

Apenas vai armazenar a string atual.

Dim strFinal As String

Apenas vai armazenar a ultima string da sequência por exemplo, se estamos com a string atual abca então a strFinal vai ter dddd. Ela é usada para saber se chegou no final da sequência ou não.

Dim lenStr As Integer

Apenas vai conter o valor do tamanho máximo de caracteres

Dim ultimoChar As Integer

Valor em ascii do ultimo valor, como usamos no exemplo anterior 100 que seria a letra d

Dim primeiroChar As Integer

Valor em ascii do primeiro valor, como usamos no exemplo anterior 97 que seria a letra a

Essa função vai modificar o character para a próximo valor por exemplo se passo a seguinte chamada

mudarProximoChar("aacd", 3)

vai ser retornado

aada

Observe que após a letra modificada no caso c tudo inicialiaza, ou seja, volta para o primeiro caracter que é no nosso caso a.
Um outro exemplo

mudarProximoChar("addd", 1)

Seria retornado

baaa

O objetivo desse função é modificar o character informado no index e inicializar todas o restante.

Private Function mudarProximoChar(str As String, index As Integer) As String Dim chrInt As Integer Dim tmp As String chrInt = Asc(Mid(str, index, 1)) 'vou tirar o char Int chrInt = chrInt + 1 'mudo para a próxima letra If chrInt = ultimoChar Then MsgBox "Char invalido" End If 'se for no inicio da string If index = 1 Then 'vai substituir somente o primeiro tmp = Chr(chrInt) Else 'se o caracter tiver no meio tmp = Mid(str, 1, index - 1) & Chr(chrInt) 'vai substituir o caracter qeu tiver no meio End If 'vou substituir daqui para frente com valores novos para não complicar o analizador 'vai ficara asim se mudei esse caracter é porque os anterios já estão modificados 'por exemplo 'vou modificar o b de aabee o proximo tem que ser 'aacaa 'para o proximo ser aacab While Len(str) <> Len(tmp) tmp = tmp & Chr(primeiroChar) Wend mudarProximoChar = tmp End Function

A função gerarTodosStr ela apenas vai gerar todos os caracter anexando na string informada por exemplo.

gerarTodosStr("ihhi")

Seria retornado:

ihhia ihhib ihhic ihhid

Ou seja, vai ser gerado todas as combinações baseado na string informada.

Private Sub gerarTodosStr(tmp As String) Dim tmpInt As Integer tmpInt = primeiroChar While tmpInt <= ultimoChar 'coloco no text o char atual Me.Text1.Text = Me.Text1.Text & tmp & Chr(tmpInt) & vbNewLine tmpInt = tmpInt + 1 Wend End Sub

Bem a função iniStr é bem simples apenas pega o tamanho da string e inicializa ela por exemplo, é feito a seguinte chamda

iniStr("abcda")

Seria retornado no nosso caso

aaaaa

Ou seja, apenas inicializa baseado no primeiro valor informado.

Private Function iniStr(tmp As String) As String Dim contador As Integer Dim tmpStr As String contador = Len(tmp) While contador <> 0 tmpStr = tmpStr & Chr(primeiroChar) contador = contador - 1 Wend iniStr = tmpStr End Function

A Função pegarProximoIndex vai analiza a string informada e vai retornar qual é o character é igual a ultimo char, no nosso caso d.
Se não achar ninguém que é igual a o ultimo char ai ser retornado 1.

Private Function pegarProximoIndex(str As String) As Integer Dim contador As Integer contador = Len(str) 'vou tá percorrendo a string para ver se alguém já terminou se tá no ultimo char While Mid(str, contador, 1) = Chr(ultimoChar) And contador > 1 contador = contador - 1 Wend pegarProximoIndex = contador End Function

Agora a maior função é um timer que faz a ligação de todas as outras.

Private Sub Timer1_Timer() If Len(str) > 0 Then ' se não for o inicio If str = strFinal Then 'fim do index If Len(str) = lenStr Then 'se for igual o tamamaho máximo foi atingido MsgBox "tamanho máximo atingido" Me.Timer1.Enabled = False 'desativa o timer Else 'se o tamanho máximo não atinguir então 'vou gerenciar baseado no tamanho da string com o index 'vai se iniciar em 1 e vai até o tamanho da string 'quando o index chegar no tamanho da string e tiver no ultimo caracter 'vai ser adicionado mais um caraacter se não tiver no tamanho máximo 'vou ter uma várivel chamada strFinal onde vai ter 'o ultimo tipo de caracter.. para fazer a compararção vai ser gerada aqui 'vou addicionar um caracter a mais str = str & Chr(primeiroChar) 'inicializo a string final strFinal = "" 'gera a string final baseado no tamanho da str vai ser gerado a strFinal 'por exemplo str = gcg strFinal = ddd While Len(str) <> Len(strFinal) strFinal = strFinal & Chr(ultimoChar) Wend 'vou inicializar toda a string str = iniStr(str) 'inicializar o index index = 1 End If End If Else 'se for o inicio da string str = Chr(primeiroChar) strFinal = Chr(ultimoChar) End If 'gera todas as sequencias gerarTodosStr (str) 'vou mudar para o proximo caracter str = mudarProximoChar(str, index) 'vou usar uma funçaõ para analizar qual caracter vai ter que ser modificado index = pegarProximoIndex(str) End Sub

O evento abaixo apenas inicializa os itens, poderia fazer algo mais dinâmico pegar os valores de um Text ou algo similar.

Private Sub Form_Load() index = 1 'Primeiro caracter lenStr = 3 'tamanho máximo ultimoChar = 126 'o ultimo vai incluir todos os caracteres primeiroChar = 33 'o primeiro char End Sub

Baseado nesse principio desenvolvi um programa que gera strings e converte para md5 podendo assim criar um 'banco de dados' para quando se deparar com um md5 você poderar encontrar o seu valor descriptografado.
http://alucard.dxs.googlepages.com/GeraString.zip

Valuew...