Criptografando e DecriptoGrafando textos - Dicas, Aprenda Como fazer, Tutorial e Livros.

Tutomania - Dicas, Aprenda Como fazer, Tutorial e Livros

Login:
Senha:
Salvar |  Cadastre-se

 

Home | Arquivo | Envio | Games | Tutomania!

NAVEGAÇÃO

«« Anterior Próximo »»

LINKS PATROCINADOS

ACESSO RÁPIDO

  Todos os Destaques
  Os Mais Acessados
  Ultimos enviados
  Jogos
  Enviar um Artigo

CATEGORIAS

  Animais (474)
  Arte e Cultura (2236)
  Casa e Propriedade (137)
  Ciência e Tecnologia (1013)
  Comércio (38)
  Concursos (88)
  Conhecimentos Gerais (896)
  Culinária e Gastronomia (669)
  Diversos... (444)
  Economia (99)
  Eletrônicos (539)
  Esportes (96)
  Fotografia (53)
  Games (795)
  Governo (32)
  Indústria (19)
  Informática (2140)
  Internet (247)
  Lazer / Diversão (123)
  Legislação (156)
  Multimídia (222)
  Natureza (58)
  Saúde (400)
  Ser Humano e Sociedade (855)
  TuTo GaMeS! (159)
  Utilidade Pública (94)
  Veículos e Transporte (114)


[+] Índice completo...

PENSAMENTO DA VEZ

Não tenho certeza de nada, mas a visão das estrelas me faz sonhar
Vincent Van Gogh

ANUNCIOS

Informática / Programação / Visual Basic

Criptografando e DecriptoGrafando textos

Criptografando e DecriptoGrafando textos


DOCUMENTO:


ESTATÍSTICAS:

Visualizações: 236
Comentários: 0 (Comentar)
Nota: (Dar Nota)
Valor: 10 crédito(s)
Enviado por: gigante (2)
Publicado em: 01/03/06 21:59hs.

LINKS PATROCINADOS:

DOCUMENTO:

Temos basicamente os seguintes elementos :

1- Um texto a codificar
2- Uma chave de criptografia (chave simétrica)

O objetivo é usar a chave de conhecimento restrito para cifrar o texto. O caminho de volta somente é possível (na teoria) para quem conhece a chave. O que o código faz é obter os caracteres ASC do texto e da chave através da soma dos dois números obter um novo número que será convertido em texto e que será o texto criptografado. Ilustrando teríamos: 

Texto a Codificar macoratti
Códigos ASCII 109 97 99 111 114 97 116 116 105
Chave privada KEY
Caaracteres da chave 75  69  89  75   69  89   75   69  89
Soma dos caracteres 184 166 174 180 189 166 191 185 180
Conversão para  Caracteres ¸¦®´½¦¿¹´

Executando o código com os comandos de debug teríamos o seguinte resultado na janela Immediate:

KEY=> 75 69 89
macoratti => 109 97 99 111 114 97 116 116 105
Criptografando
184 ¸
166 ¸¦
174 ¸¦®
180 ¸¦®´
189 ¸¦®´½
166 ¸¦®´½¦
191 ¸¦®´½¦¿
185 ¸¦®´½¦¿¹
180 ¸¦®´½¦¿¹´

Obs: KEY é chave que usei para este código você pode usar qualquer outra chave desde que seja menor que o texto a ser cifrado.

Vamos agora ao código do projeto:

Inicie um novo projeto no Visual Basic do tipo Standard EXE e no formulário padrão inclua os seguintes controles :

  • 3 TextBox
  • 4 CommandButton
  • 2 Label

Conforme a figura abaixo:

Inclua um módulo no seu projeto com o nome de cripto.bas e insira nele o seguinte código:

Option Explicit
'//Define os parametros para as ações em EncryptString
Public Const ENCRYPT = 1, DECRYPT = 2

Public Function EncryptString(UserKey As String, Text As String, Action As Single) As String
    
    'define as variaveis usadas
    Dim UserKeyX As String
    Dim Temp     As Integer
    Dim Times    As Integer
    Dim i        As Integer
    Dim j        As Integer
    Dim n        As Integer
    Dim rtn      As String
    
    '//Obtem os caracteres da chave do usuário
    'define o comprimento da chave do usuario usada na criptografia
    n = Len(UserKey)
    
    'redimensiona o array para o tamanho definido
    ReDim userKeyASCIIS(1 To n)
    
    'preenche o array com caracteres asc
    Debug.Print UserKey; "=> ";
    For i = 1 To n
        userKeyASCIIS(i) = Asc(Mid$(UserKey, i, 1))
        Debug.Print userKeyASCIIS(i); " ";
    Next
        
    '//redimensiona o array com o tamanho do texto
    'obtem o caractere de texto
    ReDim TEXTAsciis(Len(Text)) As Integer
    
    'preenche o array com caracteres asc
    Debug.Print
    Debug.Print Text; " => ";
    For i = 1 To Len(Text)
        TEXTAsciis(i) = Asc(Mid$(Text, i, 1))
        Debug.Print TEXTAsciis(i); " ";
    Next
    
    '//cifra/decifra
    Debug.Print
    Debug.Print "Criptografando"
    If Action = ENCRYPT Then
       For i = 1 To Len(Text)
           j = IIf(j + 1 >= n, 1, j + 1)
           Temp = TEXTAsciis(i) + userKeyASCIIS(j)
           If Temp > 255 Then
              Temp = Temp - 255
           End If
           Debug.Print Temp; " ";
           rtn = rtn + Chr$(Temp)
           Debug.Print rtn
       Next
    ElseIf Action = DECRYPT Then
       For i = 1 To Len(Text)
           j = IIf(j + 1 >= n, 1, j + 1)
           Temp = TEXTAsciis(i) - userKeyASCIIS(j)
           If Temp < 0 Then
              Temp = Temp + 255
           End If
           rtn = rtn + Chr$(Temp)
       Next
    End If
    
    '//Retorna o texto
    EncryptString = rtn
End Function

 

Obs: Remova os comandos Debug.Print quando for usar a rotina em seu projeto

O código da função EncryptString() faz exatamente o que explicamos , recebe um texto , uma chave e um parâmetro indicando qual a operação a ser realizada: cifrar ou decifrar.

O código do formulário que usa a função é o seguinte :

Private Sub cmdCripto_Click()
  '//Codifica
  txtCripto.Text = ""
  txtCripto.Text = EncryptString("KEY", txtOrigem.Text, ENCRYPT)
End Sub
Private Sub cmdDeCripto_Click()
  '//DeCodifica
  txtDeCripto.Text = ""
  txtDeCripto.Text = EncryptString("KEY", txtCripto.Text, DECRYPT)
End Sub
Private Sub cmdSair_Click()
  Me.Close
End Sub
Private Sub Command1_Click()
   txtOrigem.Text = ""
  txtCripto.Text = ""
  txtDeCripto.Text = ""
End Sub

 

O resultado da execução do projeto exibindo a cifragem e a decifragem é mostrado na figura abaixo:

Dentre os algorítimos de chave única são :

Algoritimo DES chave de 56 bits 16 passos XOR, SHIFT
Triple DES 112 ou 168 bits 48 passos XOR, SHIFT
IDEA 128 bits 8 passos XOR, adição , multiplicação
RCS até 2048 bits até 255 passos add, sub, XOR , rot

O método usado é muito simples e a efetuar o processo inverso também é muito fácil , para torná-lo mais robusto , implemente no código uma chave aleatória usando um chave pública.

Vamos então implementar um método um pouco mais seguro, ou seja , mais complicado de ser revertido.

Neste método vamos usar duas chaves : uma chave pública que pode ser de conhecimento geral e outra aleatória.

Inicie um novo projeto no Visual Basic do tipo Standard EXE e no formulário padrão inclua os seguintes controles :

  • 3 TextBox
  • 3 CommandButton

Acima temos o projeto exibindo o resultado da cifragem. Vamos ao código:

As duas funções principais que vão gerenciar a chave e fazer a cifragem são :

- caractereAleatorio()
- SegredoSeguro()

Option Explicit
Dim chavealeatoria As String
Dim chave As String

'--------------------------------------------------
' Retorna uma string randomica de caracteres ASCII
'--------------------------------------------------
Public Function caractereAleatorio() As String
    Dim Char    As String
    Dim RndStr  As String
    Dim n       As Integer
    
    Randomize Timer
    Do
       Char = Chr$(Int(Rnd * 256))
       If InStr(RndStr, Char) = 0 Then
          n = n + 1
          RndStr = RndStr + Char
       End If
    Loop Until n = 256
        
    caractereAleatorio = RndStr
End Function
Public Function SegredoSeguro(Text As String, SStr As String, EStr As String) As String
    Dim i   As Integer
    Dim rtn As String
    
    For i = 1 To Len(Text)
        rtn = rtn + Mid$(EStr, InStr(SStr, Mid$(Text, i, 1)), 1)
    Next
    SegredoSeguro = rtn
End Function

 

Para usar as funções basta colocar a chamada para cifrar e decifrar conforme abaixo:

Private Sub cmdCifrar_Click()
Dim i As Integer
chavealeatoria = caractereAleatorio()
    
For i = 0 To 255
    chave = chave + Chr$(i)
Next
    
'//Codifica
txtCifrado.Text = SegredoSeguro(txtOrigem.Text, chave, chavealeatoria)

End Sub

Private Sub cmdDecifrar_Click()
    
'//Decodifica
txtDecifrado.Text = SegredoSeguro(txtCifrado.Text, chavealeatoria, chave)

End Sub

 

A rotina acima usa o que costuma se chamar de chave assimétrica e gera uma cifragem bem mais complicada de ser revertida.

Nota : Mesmo este algoritimo, um pouco mais seguro, revela sua fragilidade no fato de não alternar o caractere cifrado para uma letra repetida no texto. Geralmente usa-se substituição e transposição para que este efeito seja conseguido e torne o processo inverso muito mais complicado. Para mais detalhes sobre o assunto procure por codificador de Feistel.

O VB.NET oferece várias classes que torna o tratamento deste assunto muito mais fácil para o desenvolvedor. Aguarde que em breve tratarei deste assunto sob a ótica .NET.

Por hoje é só isto... Até mais

VEJA TAMBÉM:

COMENTÁRIOS:

Este documento não possui comentários. Prestigie quem o enviou e comente.

Comentar:

Título:
Autor:   Anônimo (Efetue login para comentar identificado)
Comentário:    

OPÇÕES

ENTRE COM SEU LOGIN E SENHA

Olá visitante! Para interagir com este documento, você precisa estar logado.

Login:
Senha:  
Salvar Dados  |  Cadastre-se!

O cadastro é gratis! É muito fácil e rápido fazer o seu cadastro.

PARCEIROS


Mercado de Ações


Freelancer

Artigo Científico

Jogo Online Gratis

Desbloquear Celular

Jogos da Barbie

Torpedo Grátis

Receitas Online

Links Curtos

Hopedagem Grátis

Game Info

Jogos Online

Jogos de Atari

Casino Online

Casino

Nintendo 8 bits

Jogos Gratis

Home | Termos de Uso | Sobre o Tutomania | Publicidade | Contato
2005 - 2008 Tutomania ® Todos os Direitos Reservados.

Page Rank