Embed Size (px)
Citation preview
Sección de códigos , trucos y ejemplos para visual basic
267 - Hacer Login en programa y encriptar el Password
<Volver> - Anterior - Siguiente
Ejemplo para iniciar el programa pidiendo un password que se almacena en el registro con la clave encriptada
La rutina para encriptar y desencriptar cadenas que usa este ejemplo, fue hecha por Harvey Triana.
El proyecto que hice lo podés descargar desde este enlace:
Iniciar programa con Password encriptado
...y A continuación se describe resumidamente los formulario y las funciones que utiliza el proyecto de ejemplo.
El poyecto tiene 4 formulario y un módulo bas.
El mismo inicia mediante un procedimiento Sub Main que está ubicado en el módulo bas. Dentro del Sub Main primero lee del registro si hay una contraseña. Si la hay, carga el formulario de Login que es el siguiente:
Formulario de Login
00615421140940 FORID:11 Buscar
Al presionar el botón Entrar, se envia como parámetro a la función llamada " Login ", el password escrito en el Textbox. La función retorna True o False si es correcta o no.
Function Login(PassWord As String) As Boolean
Si la contraseña es correcta, descarga el formulario de Loign y se carga el formulario principal del programa.
Formulario para cambiar la Clave
Para cambiar la contraseña, hay un formulario similar al anterior llamado frmCambiarClave que es el siguiente:
En este formulario, al presionar Aceptar se llama a la función Cambiar_Password
'Función que cambia el Password (Recibe la contraseña vieja, contraseña y confirmación)
'-----------------------------------------------------------------------------
Function Cambiar_Password(Old_Password As String, _
New_Password As String, _
Confirm_Password As String) As Boolean
La función también es de tipo Boolean, y retorna True si se han ingresado los datos correctos o False si no son correctos, por ejemplo si la contraseña vieja no coincide.
Eliminar la clave
Para eliminar la clave hay una Sub muy simple llamada Eliminar_Password
Formulario para crear un nuevo Password
Este formulario se llama FrmNuevoPassword, y la función que usa para crear y establecer la nueva clave se llama Nuevo_Password ..que tiene dos parámetros:
Function Nuevo_Password(El_Password As String, PassConfirm As String) As Boolean
Si el password y la confirmación enviadas son correctas, la función devuelve True y añade la clave al registro, de lo contrario devuelve False
Módulo
Por último el módulo tiene, aparte de las funciones dichas antes, dos propiedades y la función que permite encriptar y desencriptar la contraseña.
La propiedad para leer la clave
Public Property Get ElPassword() As String
'Lee del registro la clave encriptada
ElPassword = GetSetting(App.EXEName, SECCION, CLAVE, "")
End Property
.. para establecerla:
Public Property Let ElPassword(ByVal sPass As String)
Dim PassEncrip As String
'Primero Encripta
PassEncrip = Encriptar(sPass, sPass, ENCRYPT)
'Luego Guarda en el registro
Call SaveSetting(App.EXEName, SECCION, CLAVE, PassEncrip)
End Property
y la función para encriptar y desencriptar de Harvey Triana se llama " Encriptar " y tiene tres parámetros:
Function Encriptar( _
UserKey As String, Text As String, Action As Single _
) As String
La primera es la clave, la segunda la cadena a encriptar (que en este caso también es la clave) y el tercer parámetro es la acción a realizar, es decir Codificar o Decodificar ( El valor 1 Encripta y el valor 2 Desencripta )
Recursos Visual basic 6.0 - Relacionados
Formulario de Login usando una base de datos y Ado
Encriptar y desencriptar datos de una base de datos
Buscar en Recursos vb
00615421140940 FORID:11 Buscar
Recursos visual basic - Buscar - Privacidad - Copyright © 2005 - 2009 - www.recursosvisualbasic.com.ar
Inicio Ejemplos vb Ocx - Activex Api vb Tutoriales - Manuales Código fuente vb.net
Encriptar una contraseña en visual basic.
Visual Basic 25 febrero 2008
Esta función te permite comprobar la contraseña de un usuario contra una base de datos sin necesidad de conocerla. El proceso inverso no es posible.
La función está basada en otras que he recopilado por internet y he adecuado a los
sistemas de información de mi empresa. Es correcta y cumple la ley de protección de datos ya que el administrador no conocerá la contraseña del usuario y queda almacenada en formato ilegible.
Desde que este algoritmo fue público, los usuarios deben evitar el uso de palabras individuales como contraseñas, ya que un programa “cracker” podría iniciar un bucle a través de un diccionario ortográfico y aplicar esta función para tratar de coincidir con el valor hashed. Para mas seguridad los usuarios deberían utilizar por lo menos dos palabras, y tal vez utilizar dígitos y signos de puntuación en la contraseña. Ya sabéis que a los hackers hay que ponérselo lo mas difícil posible, estas recomendaciones se las hago a mis usuarios pero otra cosa es que me hagan caso, seguro que unos cuantos de ellos tienen el nombre del marido o del hijo como contraseña.
Su uso se hace enviándole el usuario y la contraseña a la función para que te devuelva el valor hash y se contrasta con el valor almacenado en la base de datos.
Función:
Function HashPassword(ByVal vsUserId As String, ByVal vsPassword As String) As Double
Const uHASH_DEPTH = 6Static k(uHASH_DEPTH) As Integer
Dim S As StringDim I As IntegerDim J As IntegerDim k1 As IntegerDim N As IntegerDim fHash As DoubleDim fTemp As Double
‘ Si la contraseña está en blanco,‘ el valor de hash sigue siendo cero.‘ Por lo tanto significa “sin contraseña”.fHash = 0#
If vsPassword <> “” Then‘ Si incluyes el nombre del usuario como parte del hash,‘ dos usuarios con la misma contraseña no tendrán el mismo‘ valor de hash:S = vsPassword & vsUserId‘s = UCase$(s) ‘ Activa esta linea para convertir a mayúsculasN = Len(S)
k(1) = Asc(Mid$(S, 1, 1))For J = 2 To uHASH_DEPTHk1 = 1 + (k(J – 1) Mod N)k(J) = Asc(Mid$(S, k1, 1))
If k(J) = k(J – 1) Then
k(J) = k(J) + 1End IfNext J
For I = 1 To NfTemp = IFor J = 1 To uHASH_DEPTHk1 = 1 + ((I + k(J)) Mod N)fTemp = fTemp * Asc(Mid$(S, k1, 1))Next J
fHash = fHash + fTempNext IEnd If
HashPassword = fHashEnd Function
Uso de la función en el programa:
En la siguiente linea se hace una comparación entre la cadena hash que se supone que tenemos almacenada en la base de datos y la que ha tecleado el usuario.
bPwdOk es un boleano que nos dice si coincide el hash que tenemos almacenado en nuestra base de datos con el que ha tecleado el usuario.
bPwdOk = (StrComp(tabla!Pwd, HashPassword(txtUsuario.Text, txtPwd.Text), vbTextCompare) = 0)
tabla!pwd : campo que hemos obtenido a través de un recordset de la base de datos en la que está almacenado el valor hash de la contraseña del usuario.
txtUsuario.text : valor de la caja de texto del UserId, en el caso del gráfico D-SUAREZ. txtPwd.text : el valor de la caja de texto que contiene la contraseña que ha escrito el
usuario.
Vota este artículo:
(No Ratings Yet)
Posts anterior y posterior:
« Atomz (Juego)
Desgarrador relato de un amigo sobre la eutanasia. »
Posts Relacionados:
canalvisualbasic Web de recursos de Visual basic. Desproteger hoja de Excel con contraseña. enviar email con visual basic la web de dragon
En esta misma categoría:
Previo: « Capturar el usuario de Red desde Visual Basic. Siguiente: Leer y escribir de un archivo INI. Visual Basic »
2 Respuestas a “Encriptar una contraseña en visual
Encriptación de Cadenas
Algunos Procedimiento Visual Basic para Codificar y Decodificar Información
Por Harvey Triana
La Encriptación, es un tema de la programación bien interesante, de hecho se trata de una alta ciencia de la informática, que pasa por arte, inclusive hoy se trata de una tecnología. Encriptación es una palabra rara en español, quizá fea, no obstante se emplea en documentación técnica.
Buscando en el cajón de los recuerdos, encontré un par de procedimientos para Codificación / Decodificación con QuickBasic. Desaforadamente desconozco al programador de tales procedimientos. Después de traducir las rutinas para que trabajasen en Visual Basic me di cuenta que tenían fallas de programación, sin embargo la documentación del código me llevo a captar la idea del autor y ponerla a funcionar perfectamente. Tales procedimientos se exponen en este documento.
Algo de Teoría
Recuerdo que alguien comentaba que codificar era muy sencillo, simplemente cambias unas letras por otras, y el receptor del mensaje conoce este secreto. También, aumentar o disminuir un número discreto a los códigos ASCII, suele ser otra sugerencia. Estas estrategias pasan a ser infantiles tratamientos del problema, y no presentan problema alguno para un decodificador experto y malo.
La encriptación se hace a través de la aplicación de cierto tratamiento a los códigos ASCII de los mensajes, de manera que el tratamiento inverso será el único camino práctico para decodificar el mensaje.
¿Cómo se mantiene indescifrable una cadena codificada?. Se trata de combinar la clave de encriptación con el mensaje de manera que las probabilidades de decodificar el mensaje, sin conocer la clave, sean virtualmente infimas, es decir, el tan prolongado el trabajo de desciframiento que no existen esperanzas próximas. Por ejemplo cuando un cristal ornamental se rompe violentamente, es casi imposible volver a juntar las piezas para obtener la pieza original.
Como una cita teórica, uno de los algoritmos de codificación se basa en la función números primos. Por ejemplo resulta fácil multiplicar dos números primos, sean a = 11927 y b = 20903, de manera que a • b = c = 249310081. Pero resulta muy difícil determinar a y b a partir de c. Matemáticamente esto se hace a través del procedimiento conocido como Descomposición Factorial. En el ejemplo c viene a ser la codificación, mientras a y b son la clave de decodificación. Esta estrategia es la base de un ingenioso y sofisticado sistema de encriptación llamado Criptosistema RSA (en honor a sus autores). de hecho este es el mejor sistema de encriptación y es posible que sea aplicado en las comunicaciones masivas de Internet en un futuro. Siguiendo con mí ejemplo, en un caso real, se trata de cifras de alrededor de 250 dígitos, lo cual teóricamente requiere de millones de años para descomponer factorialmente. Una anécdota citada en el libro Camino al Futuro (2ª edición) de Mr. Gates, cuenta que un reto publico de descifrar una clave de 129 dígitos fue superado al coordinar un trabajo de varias computadoras e Internet, para finalmente lograr la respuesta en menos de un año. En el reto los autores predecían que su mensaje jamás sería desvelado. El libro mencionado hace una exposición más detallada de este tema. Por supuesto, este articulo no llegará tan lejos.
Dos Procedimientos de Encriptación
La Encriptación tiene dos elementos: Un mensaje, y una clave privada de acceso entre el emisor y el receptor, con la cual se puede descifrar el mensaje. El procedimiento de encriptación produce un mensaje o archivo cifrado. Presento dos procedimientos escritos en Visual Basic, catalogados como verdaderas maneras de encriptación.
Modelo EncryptionString
EncryptionString, es un clásico sistema el cual toma el mensaje y una clave del usuario, y a través de una combinación de estos dos parámetros se produce una cadena codificada. Mantengo la explicación original del método:
Texto a codificar: ENCRYPTIONCaracteres del Texto: E N C R Y P T I O NCódigos ASCII: 69 78 67 82 89 80 84 73 79 78Contraseña KEY: K E Y K E Y K E Y KCaracteres de KEY: 75 69 89 75 69 89 75 69 89 75Suma de Códigos ASCII: 144 147 156 157 158 169 159 142 168 153En caracteres: “ œ ? © Ÿ ? ¨ ™� �
Texto codificado: “œ?©Ÿ?¨™ � �
El modo para usar la función EncryptionString es el siguiente:
'//CodificaTextoCodificado = EncryptString(TextoOriginal, Contraseña, ENCRYPT)
'//DecodificaTextoOriginal = EncryptString(TextoCodificado, Contraseña, DECRYPT)
La ventaja de esta técnica es que es muy flexible de usar e intuitiva. Sin tener la máxima seguridad, es muy segura. Escribir un programa para encriptar archivos resulta bastante simple por aquello de la contraseña. No ocurre lo mismo con el siguiente procedimiento: ChrTran.
El código de EncryptionString es el siguiente:
DefInt A-ZOption Explicit
'//For Action parameter in EncryptStringPublic Const ENCRYPT = 1, DECRYPT = 2
'---------------------------------------------------------------------' EncryptString' Modificado por Harvey T.'---------------------------------------------------------------------Public Function EncryptString( _ UserKey As String, Text As String, Action As Single _ ) As String 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 '//Get UserKey characters n = Len(UserKey) ReDim UserKeyASCIIS(1 To n) For i = 1 To n UserKeyASCIIS(i) = Asc(Mid$(UserKey, i, 1)) Next '//Get Text characters ReDim TextASCIIS(Len(Text)) As Integer For i = 1 To Len(Text) TextASCIIS(i) = Asc(Mid$(Text, i, 1)) Next '//Encryption/Decryption 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 rtn = rtn + Chr$(Temp) 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 '//Return EncryptString = rtnEnd Function
Modelo ChrTran
ChrTran es violentamente complicado de violar, de hecho imposible. Virtualmente las probabilidades de descifrar un mensaje son del orden de 255! (255 factorial), un numero sin fin en la práctica (por ejemplo las calculadoras comunes soportan solo hasta 69!).
Tengo que confesar que tuve que reescribir ChrTran porque presentaba errores de programación y mucho código para optimizar, el resultado es sorprendente. Ni que decir que no tenía en cuenta que en español usamos tildes y eñes.
Como su abreviación lo dice ChrTran transpone caracteres, usa dos claves de 255 caracteres (la carta ASCII) y produce un texto codificado de origen aleatorio. Toma cada carácter del texto, encuentra su posición en la primera clave, e intercambia este carácter por el carácter en la misma posición de la segunda clave. Es complicado de asimilar.
Lo más difícil de ChrTran es el manejo de las claves. La primera clave (la sarta de búsqueda) podría ser publica (mejor debiera decir debe ser publica). Mientras que la segunda clave es una sarta aleatoria de la carta ASCII.
El modo de manejar ChrTran es el siguiente:
ClaveAleatoria = RandomChart() '// Se podría usar la sarta de búsqueda, ClaveDeBúsqueda, como'// otra cadena aleatoria con ClaveDeBúsqueda = RandomChart()'// aqui se mantiene un nivel de Encriptación flexible, más no'// inseguro, al hacer ClaveDeBúsqueda como la secuencia 0 a 255'// de la carta ASCII:For i = 0 To 255 ClaveDeBúsqueda = ClaveDeBúsqueda + Chr$(i)Next '//CodificaTextoCodificado = ChrTran(TextoOriginal, ClaveDeBúsqueda, ClaveAleatoria)
'//DecodificaTextoOriginal= ChrTran(TextoCodificado, ClaveAleatoria, ClaveDeBúsqueda)
En la primera línea se usa RandonChart, la cual es una función que retorna la carta ASCII en un orden aleatorio.
Como posiblemente se deduce, usar ChrTran para escribir un programa que trabaje encriptación, representa una labor bastante especializada, pero por supuesto nada del otro mundo.
El código de ChrTran es el siguiente:
DefInt A-ZOption Explicit
'//---------------------------------------------'// Return a random string of ASCII Chart.'// Used by ChrTran. By Harvey T.'//---------------------------------------------Public Function RandomChart() 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 RandomChart = RndStrEnd Function
'---------------------------------------------------------------------' ChrTran' Optimizing by Harvey T.'---------------------------------------------------------------------Public Function ChrTran(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 ChrTran = rtnEnd Function
Aplicación de Ejemplo
La figura que encabeza este articulo muestra la cara de la aplicación EncryptProject, la cual es una herramienta que utiliza las técnicas de encriptación descritas y lo creé con el propósito de proteger código Visual Basic. Es decir, supón que trabajas en un proyecto grande, en un equipo de programación y deseas mantener en privado ciertos módulos. Generalmente yo organizo mis proyectos por módulos, en carpetas aparte, así, EncryptProject tiene la finalidad de encriptar los módulos Visual Basic de esta carpeta. Así, cuando voy a trabajar, decodifico, cuando me voy encripto.
Si desea usar EncryptProject , debe tener en cuanta esta precuación:
Backup your files (in another disc or with password) before encrypt project.No forget your password, it's without it reversing !Encrypt only work over: Bas, Frm, Cls, Ctl, html files
Es decir, como una percusión, debiera tener al menos una copia aparte del proyecto. Pero no se atemorice, el programa es seguro, lo peor que le podría pasar al que lo use es olvidar la contraseña (EncryptProject pide verificación de la contraseña antes de codificar). Recomiendo para empezar, hacer una prueba sencilla con un proyecto simple.
Dos pasos y salimos. Hagamos una prueba simple. Cree una carpeta, copie o cree u proyecto Visual Basic en ella.
Encriptando
Abra EncryptProject, y escriba la trayectoria completa de la carpeta (si lo prefiere, arrastre un archivo cualquiera de la carpeta desde el Explorador de archivos de Windows a la caja de texto Project Folder).
Escriba la contraseña y use el comando [Encrypt]. Se pedirá la verificación de la contraseña. Después de confirmar, se encriptará el proyecto.
Edin Sagastume
Este blog
Acceso desde aquí
Sitios de interes
Encripta/Desencriptar cadenas (Visual Basic)
Las siguientes funciones les van a servir para Encriptar y Desencriptar cadenas de caracteres con Password.
Rem Encripta una cadena de caracteres.Rem S = Cadena a encriptarRem P = PasswordFunction EncryptStr(ByVal S As String, ByVal P As String) As StringDim I As Integer, R As StringDim C1 As Integer, C2 As Integer
If Len(P) > 0 ThenFor I = 1 To Len(S)C1 = Asc(Mid(S, I, 1))If I > Len(P) ThenC2 = Asc(Mid(P, I Mod Len(P) + 1, 1))
C2 = Asc(Mid(P, I, 1))
C1 = C1 + C2 + 64If C1 > 255 Then C1 = C1 - 256R = R + Chr(C1)
EncryptStr = REnd Function
Rem Desencripta una cadena de caracteres.Rem S = Cadena a desencriptarRem P = PasswordFunction UnEncryptStr(ByVal S As String, ByVal P As String) As StringDim I As Integer, R As StringDim C1 As Integer, C2 As Integer
If Len(P) > 0 ThenFor I = 1 To Len(S)C1 = Asc(Mid(S, I, 1))If I > Len(P) Then
Ver también:
Encriptacion de password en visual »
C2 = Asc(Mid(P, I Mod Len(P) + 1, 1))
C2 = Asc(Mid(P, I, 1))
C1 = C1 - C2 - 64If Sgn(C1)=-1 Then C1 = 256 + C1R = R + Chr(C1)
UnEncryptStr = REnd Function
Saludos ;-)
Autor Enviado por: Hurricane - Enviado con fecha: 28-04-2005 01:03:05.
Preguntar sobre un Truco | Ver más Trucos
Ejemplo 1
Código fuente realizado por Harvey Triana ( Si querés visitar su sitio web --> Harvey Triana )
Este es un algoritmo que permite encriptar y desencriptar cadenas de caracteres
La función se llama EncryptString y tiene tres parámetros:
'---------------------------------------------------------------------
' EncryptString
' Modificado por Harvey T.
'---------------------------------------------------------------------
Public Function EncryptString( _
UserKey As String, Text As String, Action As Single _
) As String
El parámetro UserKey es la clave.
El parámetro Text es el texto a encriptar o desencriptar.
El parámetro Action indica QUE hacer, ..es decir Encriptar o desencriptar. ( El valor ENCRYPT es para encriptar y el valor DECRYPT para desencriptar)
Código fuente de la función:
Texto plano Copiar código fuente Imprimir
1. Option Explicit 2. 3. '//For Action parameter in EncryptStrin
g 4. Const ENCRYPT = 1 5. Const DECRYPT = 2 6. 7. '--------------------------------------
------------------------------- 8. ' EncryptString 9. ' Modificado por Harvey T. 10. '-----------------------------------
---------------------------------- 11. 12. Public Function EncryptString( _ 13. UserKey As String, Text As Strin
g, Action As Single _ 14. ) As String 15. Dim UserKeyX As String 16. Dim Temp As Integer 17. Dim Times As Integer 18. Dim i As Integer 19. Dim j As Integer 20. Dim n As Integer 21. Dim rtn As String 22. 23. '//Get UserKey characters 24. n = Len(UserKey) 25. ReDim UserKeyASCIIS(1 To n) 26. For i = 1 To n 27. UserKeyASCIIS(i) = Asc(Mid$
(UserKey, i, 1)) 28. Next 29. 30. '//Get Text characters 31. ReDim TextASCIIS(Len(Text)) As I
nteger 32. For i = 1 To Len(Text) 33. TextASCIIS(i) = Asc(Mid$
(Text, i, 1))
34. Next 35. 36. '//Encryption/Decryption 37. If Action = ENCRYPT Then 38. For i = 1 To Len(Text) 39. j = IIf(j + 1 >= n, 1, j
+ 1) 40. Temp = TextASCIIS(i) + Us
erKeyASCIIS(j) 41. If Temp > 255 Then 42. Temp = Temp - 255 43. End If 44. rtn = rtn + Chr$(Temp) 45. Next 46. ElseIf Action = DECRYPT Then 47. For i = 1 To Len(Text) 48. j = IIf(j + 1 >= n, 1, j
+ 1) 49. Temp = TextASCIIS(i) - Us
erKeyASCIIS(j) 50. If Temp < 0 Then 51. Temp = Temp + 255 52. End If 53. rtn = rtn + Chr$(Temp) 54. Next 55. End If 56. 57. '//Return 58. EncryptString = rtn 59. End Function 60.
Ejemplo 2
Este otro código fuente fue enviado por Miguel Cejas.
El mismo, tiene dos funciones, una para encriptar y la otra para desencriptar. El único parámetro que requieren las funciones, .. es el dato en cuestión a codificar o decodificar
Colocar un CommandButton en el formulario y agregar un módulo
Option Explicit
'//For Action parameter in EncryptStringConst ENCRYPT = 1Const DECRYPT = 2
'---------------------------------------------------------------------' EncryptString' Modif icado por Harvey T.'---------------------------------------------------------------------
bas al proyecto
Código fuente en el form1
Texto plano Copiar código fuente Imprimir
1. Option Explicit 2. Private Sub Command1_Click() 3. 4. Dim ValorEncriptado As Variant 5. Dim ValorDesencriptado As Variant 6. 7. ' Encripta _ 8. '''''''''''''''''''''''''''''''''' 9. ValorEncriptado = Encriptar
("Recursos visual basic") 10. 11. ' Visualiza la cadena encriptada 12. MsgBox "Dato encriptado: " & Val
orEncriptado, vbInformation 13. 14. ' Desencripta 15. 16. ''''''''''''''''''''''''''''''''
''' 17. ValorDesencriptado = Desencripta
r(ValorEncriptado) 18. 19. ' Muestra el valor decodificado 20. MsgBox ValorDesencriptado, vbInf
ormation 21. 22. 23. End Sub
Código fuente en el módulo bas
Texto plano Copiar código fuente Imprimir
1. Option Explicit
Option ExplicitPrivate Sub Command1_Click() Dim ValorEncriptado As Variant Dim ValorDesencriptado As Variant ' Encripta _ '''''''''''''''''''''''''''''''''' ValorEncriptado = Encriptar("Recursos visual basic")
2. 3. Private Function ConvToHex(x As Intege
r) As String 4. If x > 9 Then 5. ConvToHex = Chr(x + 55) 6. Else 7. ConvToHex = CStr(x) 8. End If 9. End Function 10. 11. ' función que codifica el dato 12. ''''''''''''''''''''''''''''''''''''
''''''''''''''''''''''' 13. Function Encriptar(DataValue As Var
iant) As Variant 14. 15. Dim x As Long 16. Dim Temp As String 17. Dim TempNum As Integer 18. Dim TempChar As String 19. Dim TempChar2 As String 20. 21. For x = 1 To Len(DataValue) 22. TempChar2 = Mid(DataValue, x
, 1) 23. TempNum = Int(Asc(TempChar2)
/ 16) 24. 25. If ((TempNum * 16) < Asc(Tem
pChar2)) Then 26. 27. TempChar = ConvToHex(Asc
(TempChar2) - (TempNum * 16)) 28. Temp = Temp & ConvToHex(
TempNum) & TempChar 29. Else 30. Temp = Temp & ConvToHex(
TempNum) & "0" 31. 32. End If 33. Next x 34. 35. 36. Encriptar = Temp 37. End Function 38. Private Function ConvToInt(x As Stri
ng) As Integer 39. 40. Dim x1 As String 41. Dim x2 As String 42. Dim Temp As Integer 43. 44. x1 = Mid(x, 1, 1) 45. x2 = Mid(x, 2, 1) 46. 47. If IsNumeric(x1) Then 48. Temp = 16 * Int(x1) 49. Else 50. Temp = (Asc(x1) - 55) * 16
51. End If 52. 53. If IsNumeric(x2) Then 54. Temp = Temp + Int(x2) 55. Else 56. Temp = Temp + (Asc(x2) - 55) 57. End If 58. 59. ' retorno 60. ConvToInt = Temp 61. 62. End Function 63. 64. ' función que decodifica el dato 65. ''''''''''''''''''''''''''''''''''''
'''''''''''''''''''''''''' 66. Function Desencriptar(DataValue As V
ariant) As Variant 67. 68. Dim x As Long 69. Dim Temp As String 70. Dim HexByte As String 71. 72. For x = 1 To Len(DataValue) Step
2 73. 74. HexByte = Mid(DataValue, x,
2) 75. Temp = Temp & Ch
r(ConvToInt(HexByte)) 76. 77. Next x 78. ' retorno 79. Desencriptar = Temp 80. 81. End Function
Ejemplo 3
Sencillo módulo de clase que encripta y desencripta un password o
Option Explicit
Private Function ConvToHex(x As Integer) As String If x > 9 Then ConvToHex = Chr(x + 55) Else ConvToHex = CStr(x) End IfEnd Function
cadena utilizando un simple algorítmo
Formulario de prueba
Descargar módulo clsEncriptPass
Ejemplo 4
Ejemplo enviado por Luis Nuñez de Chile que permite encriptar strings o cadenas de caracteres en vb
Para el poyecto colocar en el formulario dos controles textbox ( txtEntrada y txtSalida )y dos commandbutton ( Command1 y Command2 ) como se ve en este gráfico
Código fuente en el form
Texto plano Copiar código fuente Imprimir
1. Option Explicit 2. 3. 4. Private s As String 5. 6. '**************************** 7. '**** CALCULA LA SEMILLA **** 8. '**************************** 9. Private Function Semilla(strClave As St
ring) As String 10. 11. Dim lngSemilla1 As Long 12. Dim lngSemilla2 As Long 13. Dim j As Long 14. Dim i As Long 15. lngSemilla1 = 0 16. lngSemilla2 = 0
17. j = Len(strClave) 18. 19. For i = 1 To Len(strClave) 20. 21. lngSemilla1 = lngSemilla1 +
Asc(Mid$(strClave, i, 1)) * i 22. lngSemilla2 = lngSemilla2 +
Asc(Mid$(strClave, i, 1)) * j 23. j = j - 1 24. 25. Next 26. 27. Semilla = LTrim$(Str$
(lngSemilla1)) + "," + LTrim$(Str$(lngSemilla2))
28. 29. End Function 30. 31. '****************** 32. '**** CODIFICA **** 33. '****************** 34. Private Function Codificar(strCadena
As String, strSemilla As String) As String
35. 36. Dim lngIi1 As Long 37. Dim lngIi2 As Long 38. Dim i As Long 39. Dim j As Long 40. lngIi1 = Val(Left$(strSemilla, I
nStr(strSemilla, ",") - 1)) 41. lngIi2 = Val(Mid$(strSemilla, In
Str(strSemilla, ",") + 1)) 42. 43. For i = 1 To Len(strCadena) 44. 45. lngIi1 = lngIi1 - i 46. lngIi2 = lngIi2 + i 47. 48. If (i Mod 2) = 0 Then 49. 50. Mid(strCadena, i, 1) = C
hr$((Asc(Mid$(strCadena, i, 1)) - lngIi1) And &HFF)
51. 52. Else 53. 54. Mid(strCadena, i, 1) = C
hr$((Asc(Mid$(strCadena, i, 1)) + lngIi2) And &HFF)
55. 56. End If 57. 58. Next 59. 60. Codificar = strCadena 61. 62. End Function 63.
64. '******************** 65. '**** DECODIFICA **** 66. '******************** 67. Private Function DeCodificar(strCade
na As String, strSemilla As String) As String
68. 69. Dim lngIi1 As Long 70. Dim lngIi2 As Long 71. Dim i As Long 72. Dim j As Long 73. lngIi1 = Val(Left$(strSemilla, I
nStr(strSemilla, ",") - 1)) 74. lngIi2 = Val(Mid$(strSemilla, In
Str(strSemilla, ",") + 1)) 75. 76. For i = 1 To Len(strCadena) 77. 78. lngIi1 = lngIi1 - i 79. lngIi2 = lngIi2 + i 80. 81. If (i Mod 2) = 0 Then 82. 83. Mid(strCadena, i, 1) = C
hr$((Asc(Mid$(strCadena, i, 1)) + lngIi1) And &HFF)
84. 85. Else 86. 87. Mid(strCadena, i, 1) = C
hr$((Asc(Mid$(strCadena, i, 1)) - lngIi2) And &HFF)
88. 89. End If 90. 91. Next 92. 93. DeCodificar = strCadena 94. 95. End Function 96. 97. Private Sub cmdCodificar_Click() 98. 99. txtSalida.Text = Codificar(txtEn
trada.Text, s) 100. txtEntrada.Text = "" 101. 102. End Sub 103. 104. Private Sub cmdDecod_Click() 105. 106. txtEntrada.Text = DeCodificar(tx
tSalida.Text, s) 107. txtSalida.Text = "" 108. 109. End Sub 110. 111. Private Sub Form_Load() 112.
113. s = Semilla("hola") 114. Command1.Caption = "Codificar" 115. Command2.Caption = "Decodificar"
116. 117. End Sub
Ejemplo 5
Ejemplo enviado por SKL , de un formulario para encriptar y desencriptar una cadena de caracteres, recorreindo cada caracter y cambiándole el código Ascii
Descargar proyecto
Enlaces relacionados
Encriptar datos de un campo de una base de
Option Explicit
Private s As String
'****************************'**** CALCULA LA SEMILLA ****'****************************Private Function Semilla(strClave As String) As String
datos Access
Buscar en Recursos vb
00615421140940 FORID:11 Buscar
