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
Este documento não possui comentários. Prestigie quem o enviou e
.