muchas gracias EdePC
justo lo que necesitaba
tema resuelto
El tema no está bien resuelto.
Es muy mala idea (y eso que este foro tiene un nombre muy específico), dejar user y password en texto plano en un fichero.
Como mínimo, en el fichero se deberían guardar el hash de ello, concatenados en el orden que prefieras.
tu en tu código trar leer sendos datos d elos textbox, deberías crear el hash de cada dato y concatenarlos en el mismo orden y forma que se hizo para guardarlo al fichero, solo si coincide es cuando debes dar por válido la concordancia.
Por supuesto, no lo hagas tan simple, aquí un ejemplo desde el que partir:
Private Const MAX As Integer = 63
Private Const XYZ As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ+0123456789-abcdefghijklmnopqrstuvwxyz" ' A-Z, +-, 0-9, a-z = 26+2+10+26 = 64 caracteres.
Private XYZToArray() As Byte
Private Const MAX_INTENTOS As Byte = 5
Private p_Intentos As Byte
'
Private Validado As Boolean ' Pasó o no la validación?...
Private Ruta As String ' Ruta del fichero que contiene las identidades contra las que se va a evaluar.
private sub command1_click()
If (Validar(TxtAlias.Text, TxtPassword.Text, Ruta) = True) Then
Validado = True
' AQUI: Haces lo que necesites hacer ...
Call Salir
Else
p_Intentos = (p_Intentos + 1)
If (p_Intentos < MAX_INTENTOS) Then
MsgBox "Error... falla el usuario y/o contraseña."
Else
call Salir
End If
TimEspera.Enabled = True
Do While (TimEspera.Enabled = True): Loop ' Exige cumplir la espera impuesta.
End If
end sub
sub form_load
Ruta = App.Path & "\Login.txt" ' cambiar al gusto
XYZToArray = StrConv(XYZ, vbFromUnicode)
TimEspera.Interval = 1000 ' Impide que pueda hacerse más de 1 intento por segundo (caso de listos que cierren la ventana)...
TimEspera.Enabled = True
Do While (TimEspera.Enabled = True): Loop
end sub
Private Sub Salir()
TimEspera.Enabled = False
Unload Me
End Sub
Private Function Validar(ByRef Alias As String, ByRef Password As String, ByRef Ruta As String)
Dim UserHash As String, PaswordHash As String, Hash As String
UserHash = Hashing(Trim$(Alias)) ' los hashes deben devolver no más de 32 caracteres.
PasswordHash = Hashing(Trim$(Password)) ' " " " "
Hash = Codificar(UserHash, PasswordHash)
Validar = VerificarIdentidad(Hash, Ruta)
End Function
' Es muy útil un temporizador para generar esperas y así hacer fracasar la fuerza bruta (por sí sola).
Private Sub TimEspera_Timer()
TimEspera.Enabled = False
' Con cada fallo se incrementa la espera en 2 segundos... El valor máximo de interval es 65.535 (algo más de 1 minuto).
TimEspera.Interval = (TimEspera.Interval + 2000)
End Sub
En la línea: "Hash = Codificar(UserHash, PasswordHash)", es para complicar el caso un algo más que:
la simple concatenación como en: "hash = userHash & PasswordHash", conviene hacer algo más, para complicar una fácil intrusión...
'Codificar' debería ser una función (más o menos compleja) que devuelve un string.
Finalmente en tu fichero, una sola línea debería contener dicho valor devuelto como 'hash', por tanto puede tener un largo distinto, pués ocupa una sola línea.
Con 'Line Input' se puede leer línea a línea un fichero... igualmente siempre considera eliminar espacios a ambos lados de un string leído de fichero.
Date cuenta que incluso aunque el fichero solo precisa tener 1 única identificación, el fichero podría contener (por ejemplo), 200 identificaciones generadas aleatoriamente, de modo que cualquier intento de intrusión en principio es más complicado que 'solo' abrir un fichero de texto plano, o abrir un texto plano y encontrar 'lo que es'.
Como se verifica la identidad con todas las posibles (supuestas identidades) contenidas en el fichero, si existe acaba por encontrarla y piensa que verificar 200 ni 2000 identidades es lento, además justamente las verificaciones de identidad son precisamente los algoritmos donde no interesa optimizar al máximo en velocidad, por asunto de no facilitar la tarea a estrategias de fuerza bruta.
Private Function VerificarIdentidad(ByRef Id As String, ByRef Ruta As String) As Boolean
Dim k As Long, ff As Integer
Dim idFile As String, Verificado As Boolean, OK As Boolean
ff = FreeFile
Open Ruta For Input Lock Read Write As #ff ' no se considera el caso de fallos de apertura de fichero
Do While Not EOF(ff)
Line Input #ff, idFile
If (Id = Trim$(ifFile)) Then ' nota que hay dferencia de capitalización 'corlo' es distinto de 'Corlo' y distinto de 'cOrlO', generan hashes diferentes.
If (OK = False) Then ' *** (Ver comentario más abajo)
Verificado = True: OK = True
End If
End If
Loop
Close #ff
On Error Resume Next
Id = Left$(XYZ, Len(Id)): Id = XYZ ' Borramos el contenido provisional de dichos valores.
idFile = Left$(XYZ, Len(idFile)): idFile = XYZ ' " " " " .
On Error GoTo 0 ' desactiva el manejador de errores activado en la funcion.
VerificarIdentidad = Verificado
End Function
No añado más código... con lo siguiente ya debe debe darte idea, para tu hacer modificaciones a tu antojo y elegancia:
' Realiza una modificación 'particularizada' donde concatena mitades de ambos hashes (donde al menos uno es previamente modificado) y añade alguna cosa más, finalmente s ele calcula el hash a este codificado que es lo que se devuelve.
' Esto impide que baste saber el tipo de hash aplicado para romper la identidad. Lo complica...
' Dado que en principio se desconoce por completo el tamaño del alias y de la cotraseña añade una capa de complejidad.
Private Function Codificar(ByRef H1 As String, ByRef H2 As String) As String
Dim h As String, k As Integer, j As Integer, i As Integer, n1 As Integer, n2 As Integer, v As Integer
n1 = Len(H1): n2 = Len(H2) ' tomamos el tamaño de cada cadena.
k = (n1 \ 2): j = (n2 \ 2)
v = (((k * j) + k) Mod MAX)
i = Sgn(n1 - n2) ' restamos ambos valores y nos quedamos con el signo.
Select Case i
Case 1 ' Hash de Alias es más largo que Hash de Password.
H1 = Xoring(H1, v)
h = Left$(H1, k) & Left$(n2, j) & Mid$(XYZ, j, k) & Right$(H1, n1 - k) & Right$(H2, n2 - j)
Case 0 ' Hash de Alias e sigual de largo que Hash de Password
H1 = Xoring(H1, v): H2 = Xoring(H2, v)
h = Left$(H1, k) & Left$(n2, j) & Mid$(XYZ, j, k) & Right$(H2, n2 - j) & Right$(H1, n1 - k)
Case -1 ' Hash de Alias es más corto que Hash de Password
H2 = Xoring(H2, v)
h = Left$(n2, j) & Left$(H1, k) & Mid$(XYZ, k, j) & Right$(H2, n2 - j) & Right$(H1, n1 - k)
End Select
Codificar = Hashing(h)
End Function
' Es una (no tan simple) codificación XOR, pero limitado a la elección de uno de los '64 caracteres', disponibles.
Private Function Xoring(ByRef Txt As String, ByVal Index As Integer) As String
Dim k As Integer, j As Integer
Dim X() As Byte, id() As Byte
'
id = StrConv(Txt, vbFromUnicode)
For k = 0 To UBound(id)
j = ((Index + k) Mod MAX)
id(k) = XYZToArray((XYZToArray(j) Xor id(k)) Mod MAX)
Next
Xoring = StrConv(id, vbUnicode)
For k = 0 To UBound(id) ' borrar contenido de array id (lo sobrescribimos con el contenido de XYZ.
id(k) = X(k)
Next
End Function
La funcion 'Hashing()' podría ser una llamada a un algotimo de resumen como 'Md5', 'RC4', o cualquier otro disponible, incluso una codificacón 'Base64', sería preferible a un text plano, la función ' Codificar' interpuesta entre los datos de origen y el dato final, lo complica lo suficiente como para que tareas de fuerza bruta, fracasen...
*** Esto supone que siempre se verifiquen todas las entradas del fichero, aún cuando ya la haya encontrado, y no que devuelva cuando la encuentre... el tiempo que tarda en encontrarlo, podría arrojar pistas sobre si está al comienzo o al final. De este modo, tarda lo mismo sea la primera o la última entrada. Es fácil demostrarlo y localizar la identidad concreta.
Imagina que el fichero tiene 100 entradas y yo añado entre cada línea del fichero 10.000 más.
Puedo hacer un bucle para hacer lo siguiente:
verificaridentidad, calcular tiempo utilizado y anotar tiempo y ciclo.
mover las primeras 10.001 lineas al final del fichero.
Tras los 100 ciclos (una por cada entrada), tendré 100 tiempos anotados, las diferencias de 'salir' cuando se encuentre una identificación válida queda reflejado en las respuestas que arroja dicho bucle, luego así es deducible cual es la identificación válida. Imagina (por simplicidad para comprenderlo), que la identidad correcta e sla primera línea... en el bucle uno tarda 1, luego como baja al final del fichero, el tiempo que marca será 100, en el siguiente ciclo, 99,98, 97...
Imaginemos que es la línea 50 la que contiene la identidad... en el primer ciclo tarda 50, en el segundo 49, en el 3º 48... lega un punto que es el menor de todos (cuando sea la línea 1ª como se describe en el parráfo anterior), cmo justo cuando tarda menos (es la primera y s epasa al final) coincide que será la última y tardará más, luego... la respuesta correcta se haya en el cclo cuya tiempo es el menor de todos y al que le sigue el ciclo cuyo tiempo es el mayor de todos (o casi en ambos casos, ya que posibles interrupcciones hardware (por ejemplo), pueden variar un poco el caso...
En cambio si siempre analiza todas las entradas, el tiempo es básicamente el mismo cada vez (inapreciable a efectos prácticos).
Otra forma es no leer las líneas en orden, si no crear un array con tantas entradas como líneas tenga el fichero y barajarlo 'desordenar el array' con una función aleatoria, luego se lee cada línea en el orden que marca el array... ahí si exige acceso aleatorio (para que la lectura de cada línea tenga un tiempo sin dependencia del orden que ocupa en el fichero), por lo que en tal caso 'Line Input', no sería el modo de lectura adecuado al caso.
Todavía incluso ocultando una identidad entre otras 200, es factible de ser descubierta, en un 'tiempo' equivalente al de una búsqueda binaria. Eso sí se requiere saber en todo momento que la cuenta que hace el login es la misma cada vez... si son varias cuentas las que se loguean, resultará más complicado (tiempo en el sentido de intentos).
Veamos, si abro el fichero y elimino la mitad primera de las líneas y guardo el fichero. Cuando intente loguearse ocurrirá una d edos cosas: logra identificarse, no logra identificarse.
Si logra identificarse, señala que la identidad está en la mitad que dejaste en el fichero, y si no logra identificarse (o bien se equivocó a introducir sus datos o bien) consta la identidad en la mitad retirada del fichero (por ello falla, no la encuentra).
Ahora contmaos solo con la mitad de líneas que sabemos que es correcta el resto son elimiandas... nuevamente de estas copiamos y cortamos la mitad, y se sigue el proceso hasta que el fichero solo contenga una única línea que es la que arroja la identidad correcta.
Una errada solución a la que cabría que se llegue sería comprobar antes de nada que el tamaño del fichero es el que se espera... pero esto puede también falsificarse, si tras eliminar la mitad del contenido interesado, lo remplazo con contenido aleatorio, el tamaño del fichero permanece invariable, pero básicamente sabe uno que en ese contenido aleatorio (o no aleatorio), no está la identifidad...
La solución para solventar este caso, consiste en hashear todo el fichero y ver que el mismo no ha sido modificado desde la última vez que se modificó. Esto es cuando se añade un login al mismo se hashea el fichero y se guarda dicho hash (preferiblemente en otro destino distinto al equipo). La desventaja es tener que guardar dicho dato fuera dle equipo, lo que le leva a uno a preguntarse, y por que nó guardar la identidad también fuera del equipo?. Si solo es uno, es igualmente válido pero si ha de tener muchas, la solución resultará engorrrosa (para un entorno no profesional que asumo es el caso).
Básicamente una solución infalible solo existe en dos situaciones:
- El hardware colabora: Si hay partes dle hardware del euipo que apoyan soluciones d eidentificación, pero deslocalizadas del S.O. (es decir como si poseyera un segundo procesador con un mini S.O. dedicado solo a mantener cuestiones seguridad y por tanto inaccesible e inalterable desde el otro procesador... y una conmutación en el equipo (un botón tecla, etc...), que permita saltar entre uno y otro S.O.
- El sistema de identificación se guarda fuera del equipo, de odo que cualquier intrusión ni siquiera tenga posibilidad de saber dónde o cómo localizarlo... por lo tanto no podrá probar ninguna técnica (aparte del pishing).
...pués el factor humano es y seguirá siendo un punto débil, antes se consideraba el punto más débil, pero a causa de la enorme cantidad de fallos descubierta en los diseños, se puede considerar que como trasl el diseño, está el ser humano, hereda el 'punto débil'... y por tanto es razonable considerar que están a la par.
No obstante considera que si hay demasiadas 'puertas' en cuanto a la seguridad es fácil que dado el valor del 'cebo' tras la puerta, se pierda fácilment el interés en intentar la intrusión... pero incluso aunque el valor del 'cebo' sea nulo, no conviene nunca dejar un texto plano... no es propio de programadores solo de idiotas.
(
nota: No he probado el código, lo he escrito al vuelo (después de enviar he corregido algo rápido de sintaxis, cono nombres de variables o constantes, etc..), puede que precise alguna corrección que queda a tu esfuerzo).
Autor
En línea
