Página 1 de 1

Lógica Testar Senha Variável

Enviado: 25 Set 2021 16:07
por fladimir
Minha questão é criar um código para que vá testando senhas de 1 posição até 4 posições

minha ideia foi:

Criar um dicionario de dados tipo

cDicionario = "abcde" // vamos fazer somente assim pra não complicar, supondo q a possivel senha seja composta apenas com esses caracteres

Blz, ai não consigo montar uma logica para q vá armazenando as combinacoes e testando maior q 2 posições, até 2 posições blz, agora maior q 2 posições da um nó na cabeça kkk

Tipo a senha pode ser por exemplo "cbea"

Então vai começar testando
a
b
c
d
e
depois
aa
ab
...
ae
até
ee

Até 2 posições até q consegui fazer, o codigo abaixo seria uma ideia, mas acredito q talvez tenha q usar array e recursividade
o problema maior é de 3 posições em diante
pq teria q testar

Código: Selecionar todos

a a a
a a b
...
a a e
depois
a b a
...
a b e
...
a e e
b a a
b a b
...
b a e
b b a
...
b b e
até
e e e
e depois começar a quarta posição
a a a a
...

FUNCTION TestaBruteForce
	PRIVATE         sDictionary := "abcde"
	PRIVATE               sPass := "cbea"
	PRIVATE sCombinacaoAnterior := ""
	PRIVATE            nPosFixo := 1
	PRIVATE              lAchou := .F.
	PRIVATE nTentativa := 0

	FOR nJ := 1 TO 4 // Tamanho da Senha
		Bruteforce()
		IF lAchou 
			QUIT
		END
	END

********************************************************************************
STATIC PROCEDURE BruteForce()
	LOCAL nTotDict := Len(sDictionary)
	FOR nI := 1 TO nTotDict
		    sLetra := SUBSTR(sDictionary, nI, 1)
		sTentativa := sCombinacaoAnterior + sLetra

		nTentativa++
		Mensag(hb_cStr(nTentativa) +' '+ sTentativa) // vai mostrando uma janela com a sequencia da tentativa e a combinacao 
		
		IF sPass = sTentativa
			Alert("senha localizada", sTentativa)
			lAchou := .T.
			RETURN
		ELSE 
			IF nI = nTotDict //  terminou variacao
				IF nPosFixo = nTotDict 
					// aki teria q ir pra outra sequencia nova 
				ELSE
					sCombinacaoAnterior := PegaCharFixo()
					bruteforce()
				END
			END
		END
	NEXT
RETURN
********************************************************************************
STATIC PROCEDURE PegaCharFixo()
	LOCAL nTotDict := Len(sDictionary)
	LOCAL sLetra   := SUBSTR(sDictionary, nPosFixo, 1)
	nPosFixo++
RETURN sLetra
Até chegar na senha de 4 posições


Se eu fizer com WHILE encadeado ou for nex encadeado até 4 posições funciona, mas gostaria de fazer utilizando função para q a rotina service para qualquer tamanho de senha e tb q fosse testando começando com tamanho de senah 1 pq não sei se a senha é 1 posição, 2, 3 ou 4 então tem q ir combinando conforme o tamanho da senha.

Alguém já fez isso ou tem alguma ideia de como eu poderia resolver essa questão

Na verdade parece fácil, mas do tamanho 3 pra frente q complica, quem puder tenta pra ver não é facil não.

Lógica Testar Senha Variável

Enviado: 25 Set 2021 16:22
por Itamar M. Lins Jr.
Olá!
Da forma que vc está querendo começa:
"aaaa" depois "aaab" depois "aaba" depois "abaa" ... nisso precisa rodar todas as possibilidades.
Pq ele faz a senha até 4 e joga(faz if minha_senha == sua_senha) para ver se bate com a senha.

Tem brute force que faz isso aleatório.

Saudações,
Itamar M. Lins Jr.

Lógica Testar Senha Variável

Enviado: 25 Set 2021 17:51
por JoséQuintas
Sei lá se é isto, é praticamente somar de 1 em 1, transformado em base quantidade de letras.

Código: Selecionar todos

#define CHAR_LIST "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

procedure main()

   LOCAL aSenha

   SetMode(40,100)
   CLS
   Altd()
   aSenha := Array(3)
   Afill( aSenha, 0 )

   DO WHILE .T.
      ? CalculaSenha( aSenha )
      IF ! Soma1( @aSenha, 1 )
         EXIT
      ENDIF
   ENDDO
   Inkey(0)

   RETURN

FUNCTION Soma1( aSenha, nPos )

   aSenha[ nPos ] += 1
   IF aSenha[ nPos ] > Len( CHAR_LIST )
      IF nPos == Len( aSenha )
         RETURN .F.
      ENDIF
      aSenha[ nPos ] := 1
      RETURN Soma1( @aSenha, nPos + 1 )
   ENDIF

   RETURN .T.

FUNCTION CalculaSenha( aSenha )

   LOCAL cTxt, nItem

   cTxt := ""
   FOR EACH nItem IN aSenha
      cTxt += iif( nItem == 0, "", Substr( CHAR_LIST, nItem, 1 ) )
   NEXT

   RETURN cTxt

O código vai somando 1 em 1, só que ao invés de base decimal ou hexadecimal, é base o que estiver no array. CHAR_LIST
Começa desde 1 única letra, até o tamanho máximo do array de números. aSenha

Nota: editei o post algumas vezes pra correção.

Lógica Testar Senha Variável

Enviado: 26 Set 2021 13:31
por Claudio Soto
Este codigo crea por fuerza bruta todas las combinaciones posible entre los cuatro caracteres de la matriz

Código: Selecionar todos

clave := { "a", "b", "c", "d"}

FOR i1 = 1 TO LEN( clave )
   FOR i2 = 1 TO LEN( clave )
      FOR i3 = 1 TO LEN( clave )
         FOR i4 = 1 TO LEN( clave )
              password := clave[ i1 ] + clave[ i2 ] + clave[ i3 ] + clave[ i4 ] 
              ? password
         NEXT
      NEXT
   NEXT
NEXT

Lógica Testar Senha Variável

Enviado: 26 Set 2021 13:40
por fladimir
obrigado pessoal

Lógica Testar Senha Variável

Enviado: 26 Set 2021 16:13
por JoséQuintas
Se prepara, porque a quantidade é grande. Só fazer as contas.
Se existir rotina de conversão de base, é só fazer de 1 em 1 e converter a base, começando no zero.
Se misturar números, ou outros símbolos, a coisa aumenta muito.

Pra 26 símbolos, somente letras:
Senha vazia = 1
1 letra = ( 26^1 ) + 1 = 27
2 letras = ( 26^2 ) + 27 = 703
3 letras = ( 26^3 ) + 703 = 18.279
4 letras = ( 26^4 ) + 18279 = 475.255
5 Letras = ( 26^5 ) + 475255 = 12.356.631

Poderia ser algo assim:

Código: Selecionar todos

FOR nCont = 0 TO 999999999
   Senha := ConverteBase( nCont )
NEXT
Igual tem binário, decimal, hexadecimal, etc, vai ter essa base com n símbolos.
Só decidir quantos resultados vai querer, ou decidir pelo tamanho.
Também pode gravar como Int() ou numérico, e só converter a senha que usar para numérico, ao invés de gravar convertido.
Ou gravar mesmo só as usadas, tendo em mente que de 1 em 1 não sobra nenhuma, assim economiza espaço.