Esto no será una respuesta completa, ya que una respuesta completa no es posible: una credencial puede ser cualquier cosa que desee convertir en una credencial. Pero suponiendo que las credenciales sean sensatas, podemos discutir dos cosas:
-
El primer documento que usted menciona simplemente hace un esquema en el que provoca un acceso no autorizado una alarma (palabra de código incorrecta en el papel) que desactiva la tecla. En términos de implementación, esto no es muy diferente de: "después de tres inicios de sesión fallidos, la contraseña está bloqueada" .
La novedad del artículo es que hacen un esquema de claves completo (con un análisis formal del esquema).
-
El segundo documento habla sobre algo completamente diferente. Es solo una enumeración de cómo los sistemas que publican datos del usuario en la web (por ejemplo, github o bitbucket, pero bien podría ser facebook) intentan encontrar que dentro de los datos publicados hay cadenas que parecen credenciales a otra parte. Esto es bastante similar a lo que scumblr se puede configurar para hacer. Su lista de técnicas incluye puntos bastante simples:
- búsqueda de palabras clave (por ejemplo,
BEGIN RSA PRIVATE KEY )
- coincidencia de patrón (por ejemplo, búsqueda de cadenas codificadas en base64)
- heurística (coincidencia de patrón pero usando contexto)
- búsqueda de fuente (coincidencia de patrón pero utilizando suposiciones basadas en el tipo de código fuente que está buscando)
Estas cosas funcionan, recuerdo haber recibido un correo electrónico de BitBucket cuando, una vez, envié mi clave de API de AWS a un repositorio. Pero en cuanto a su implementación como una herramienta específica, creo que solo son scripts que se invocan como ganchos de git. Mira esta imagen en el papel:
El"módulo de detección de clave" se llama entre un compromiso de usuario y el compromiso real al repositorio público.
Github y BitBucket ciertamente tienen una base de datos de patrones que probablemente sean credenciales. Y también tienen un par de algoritmos heurísticos. Los puntos 1 (búsqueda por palabra clave) y 2 (coincidencia de patrón) son triviales de implementar con grep, los puntos 3 (heurística) y 4 (búsqueda de fuente) requieren una gran cantidad de datos preexistentes que solo lugares como Github y BitBucket tendrían. / p>
Finalmente, tenga en cuenta que incluso el documento sostiene que las heurísticas y la búsqueda de fuentes producen falsos negativos y falsos positivos. Por lo tanto, aquí no hay una solución mágica.
Si hubiera necesitado algo para comprobar si los usuarios de mi sitio web publicaban sus credenciales en algún lugar por accidente, intentaría usar los puntos 1 (coincidencia de palabras clave) y 2 (coincidencia de patrones) y luego simplemente crearía un algoritmo heurístico que no dependiera en tanto en los datos preexistentes. En camino sería probar la complejidad de Kolmogorov (consulte esta vieja pregunta sobre la complejidad de las cadenas a partir de más información ).
El supuesto es que las credenciales complejas tendrán una gran cantidad de entropía por byte, ya que deberían ser difíciles de fuerza bruta. Esta es una mala suposición en algunos casos: por ejemplo, las cadenas codificadas en base64 tienen poca complejidad en comparación con su longitud. Tendremos que capturar cadenas base64 en la fase de coincidencia de patrón (fase 2).
Aquí hay un algoritmo heurístico trivial (usa zlib para aproximarse a la complejidad de Kolmogorov, que no es particularmente cercano) usando el supuesto anterior:
#!/usr/bin/env python3
from io import BytesIO
import zipfile
strings = [ b'password password password password'
, b'correct horse batter staple'
, b'HdtfhhaissdogkanfhhwnaHDnbahdnSGENdkfQWee=='
, b'hZjJIdkXndjaodk='
, b'\x89\x12\x03\x561w\x10'
]
for s in strings:
fp = BytesIO()
zf = zipfile.ZipFile(fp, 'w', zipfile.ZIP_DEFLATED)
zf.writestr('f', s)
zf.close()
print('%50s' % s, float(len(fp.getvalue())) / float(len(s)) )
Y su salida:
b'password password password password' 3.257142857142857
b'correct horse batter staple' 4.777777777777778
b'HdtfhhaissdogkanfhhwnaHDnbahdnSGENdkfQWee==' 3.3255813953488373
b'hZjJIdkXndjaodk=' 7.375
b'\x89\x12\x03V1w\x10' 15.571428571428571
Como se esperaba, funciona bien para separar cadenas simples de cadenas que son conjuntos de bytes más o menos aleatorios. Sin embargo, funciona mal en cadenas base64 e incluso en algunas frases de contraseña.