Possiveis algoritmos de codficacao de senhas telefonicas
            acessadas por tons dtmf e metodos para quebra-las.
                       
                                                   por augur - LTdG -



   Inicialmente  eh necessario  salientar q  senhas baseadas  em tons  dtmf  sao
   um esquema   de   criptografia    fraco   pois   conta   com,    no   maximo,
   apenas     12**tamanho_do_numero      possibilidades(12       elevado       a
   tamanho_do_numero)  isso considerando  #  e  * como  partes  da  senha, coisa
   q  eh  muito rara.  entao, criptograficamente, a senha padrao de  telefone eh
   considerada como baixa  nivel criptografico tornando sua quebra trivial.

   Neste texto descreverei os mais comuns metodos de criptografia usados de  uma
   maneira generica, bem  como suas possibilidades  de quebra. bem,  ehh... agoa
   vamos ao q realmente interessa.

1--------------------------------------------------------------------  

   O   tipo  comum  de   senha  nao   segue   nenhum   padra  criptografico,  eh
   composto   por simplesmente numeros  aleatorios. eh  o metodo,  por  incrivel
   que pareca,  mais chato de quebrar sendo sua exploracao basicamete ataques de
   forca  bruta   (tentar numeros  sequenciais  ou aleatorios  ateh  encontrar o
   numero     correto).     normalmente     segue    padroes  de    digitos como
   repeticoes(normais(111111),          duplas(121212)),      ...)ou     numeros
   consecultivos(12345,    54321,     123654,     654123,...).  A  equacao_tempo
   necessario     para     quebrar     tal     cifra     eh      aproximadamente
   (10**tamanho_do_numero)*tempo_de_uma_discagem)+tempo_de_espera segundos.


2--------------------------------------------------------------------

   Algoritmo de checagem do digito do lado. esse eh um pouco dificil pois nao se
   baseia em  equacoes matematica,  e sim  formas aleatorios.  eh pouco usado(eu
   mesmo soh vi uma vez num sistema coreano) mas eh bom saber sua geracao.  esse
   sistema se baseia em regras geradas pelo administrador do sistema em q ele eh
   usado, sendo usado uma tabela com todas as relacoes entre os digitos.  embora
   soh seja realmente codificavel n/2 digitos de uma string de tamanho n, eh  um
   sistema muito bom e frustrante para alguem tentando quebra-lo de maneira  nao
   aleatoria(e aleatoria tb). vou demostrar um exemplo das cifras deste sistema.

   Suponha uma  senha de  n digitos  onde n=6.  o valor  da senha  seria 172436.
   suponha q este numero seja validado baseado na tabela de vericacao a seguir:

   1-7   2-4   3-6   4-7   5-9   6-7   7-3   8-0   9-2   0-1

   Logo  o  numero  acima eh  valido  pq  o digito  nas  posicao  x e  x+1  para
   x=1;x<7;x=+2 se  relacionam. pos  1/dig 1,  pos 2/dig  7(verdadeiro dentro da
   tablea) e assim em diante.


3--------------------------------------------------------------------

   Algoritmo de digitos de verificacao. estes sao os melhores. os algoritmos  de
   checagem baseados em bits de verificacao(como o cartao de credito e cpf)  sao
   os melhores de quebrar pois geralmente implantar um sistema como esse tira  a
   nessecidade de um banco de dados com todos os usuarios, sendo a checagem o  q
   vai  permitir ou  nao seu  login. mas  mesmo contendo  um banco  de dados  eh
   realmente facil achar aleatoriamente um numeor no banco, desde q este  numero
   seja  validado.  A  possibilidade  maior eh  de  achar  apenas  um digito  de
   verificacao(como o cartao de credito) e dessa forma a exploracao eh ridicula.
   vamos considerar um algoritmo semelhante ao do cartao de credito, mas voltado
   para senhas de seis digitos. supondo q SENHA eh uma string contendo um  valor
   de seis digitos a ser checado o possivel algoritmo de checagem seria:

   for(i=1;i<SENHA.length();i++){
   int temp=Integer.parseInt(senha.charAt(i-1));
   if((i+1%2)==0){ HASH[i-1]=temp; } else { HASH[i-1]=(temp*2>9):(temp*2)-9?(temp*2); }
   }
   for(i=0;i<SENHA.length()-1;i++){ int soma+=HASH[i]; }
   if((soma%10)==0){ FUNCAO_CODIGO_VALIDO } else { FUNCAO_CODIGO_INVALIDO }
 
   Como se  pode ver,  o algoritmo  soh checa  a validade  do algoritmo,  nao  a
   existencia do numero num possivel  banco de dados, exatamente como  o  cartao
   de credito faz. A consequencia mais obvia disso eh o metodo de exploracao   q
   soh precisa de, no maximo, 10(dez) possibilidades para ser quebrada, uma  vez
   q o vc repete os primeiros digitos e varia o ultimo para gerar a validacao.

   Uma segunda possibilidades  desse algoritmo eh  a checagem com  dois ou  tres
   bits  de  verificacao.  o principio  de  quebra  eh o  mesmo  mas  se  levara
   10**qtde_digitos_verificacao   tentantivas   para   quebralos(2     tentativa
   10**2=100, 3 tentativas 10**3=1000, ...).


4--------------------------------------------------------------------

   Algoritmo hibrido de validacao. usando  algoritmo para validar uma string  de
   tamanho n*2 usando n digitos de validacao. esse eh fodah! embora o  algoritmo
   de verificacao seja geralmente baseado no  padrao de checagem de bit, este  o
   usa em posicoes  diferentes do padrao,  unindo dois tipos  de verificacao(por
   isso o hibrido).

    Um exemplo disso,  eu jah encontrei  num telefone militar  de um pais  q nao
    convem dizer, ele seguia  o padrao AXBYCZ onde  para o digito A  3 possiveis
    digitos X eram aceitaveis, e este digitos X era validado baseado nos digitos
    B e C, que  validavam os digitos Y  e Z. Foi um  sistema q deu muita  dor de
    cabeca, mas eh realmete raro de encontrar.

    A  tabela de  geracao q  ele usa  eh muito  complexa, baseada  na teoria  da
    permutacao onde o valor de todos  os digitos fazem diferenca. nao vou  falar
    muito sobre esta pois  tenho pouco conhecimento sobre  ela e nao eh  a coisa
    mais facil do mundo tentar escrever um algoritmo de checagem generico, nem a
    mais segura tentar explorar.

    Bem  por ora  eh soh...  tao logo  eu obtenha  acesso a  outros metodos  de
    criptografia usada  em senhas  telefonicas eu  atualizarei este  texto. ah a
    linguagem q  eu usei  para exemplificar  o sistema  de checagem  e em outros
    ponto  desse texto  eh java  entao valeu  aih galera  da sun.  eu queria  tb
    agradecer a Agrawal, Kayal e Saxena os lokos indianos q geraram o  algoritmo
    de validacao  de numeros  primos... heehee  logo logo  vai aparecer neguinho
    quebrando pgp, rsa e des em dez minutos com um palm... heehee

    LTdG - todos os direitos pirateados