Entropy, una herramienta CLI para escanear archivos y encontrar líneas de alta entropía

 (github.com/EwenQuim)
2 puntos por GN⁺ 2024-06-06 | 1 comentarios | Compartir por WhatsApp
  • Entropy es una herramienta CLI que escanea líneas de alta entropía en bases de código grandes para encontrar cadenas que parecen valores secretos
  • Las líneas de alta entropía se tratan como candidatas con alta probabilidad de ser secretos, con foco en encontrar valores secretos expuestos dentro de la base de código
  • La instalación y ejecución se ofrecen mediante instalación desde el código fuente con Go, go run, Homebrew y Docker
  • Con las opciones de ejecución -top, -ext y -ignore-ext se puede definir la cantidad de resultados, las extensiones incluidas y las extensiones excluidas
  • Al ejecutar con Docker, hay que montar el directorio actual en /data y agregar /data al final del comando para que escanee el sistema de archivos local

Qué hace Entropy

  • Entropy es una herramienta CLI que escanea una base de código para encontrar líneas de alta entropía
  • Como las líneas de alta entropía suelen ser valores secretos, ayuda a detectar filtraciones de secretos en la base de código

Formas de instalación y ejecución

  • Instalar con Go

    • La forma recomendada de instalación es compilar desde el código fuente usando Go
    • Después de instalarlo, se ejecuta con el comando entropy
go install github.com/EwenQuim/entropy@latest
entropy
  • También se ofrece una forma de ejecutarlo en una sola línea
go run github.com/EwenQuim/entropy@latest

  • Instalar con Homebrew

    • El comando de instalación con Homebrew es el siguiente
brew install ewenquim/repo/entropy
entropy

  • Ejecutar con Docker

    • La ejecución con Docker consiste en montar el directorio actual en /data dentro del contenedor
docker run --rm -v $(pwd):/data ewenquim/entropy /data

Ejemplos de opciones principales

  • -h: permite ver las opciones disponibles
entropy -h
  • -top: especifica cuántos resultados principales mostrar
  • -ext: especifica las extensiones que se van a escanear
entropy -top 20 -ext go,py,js
  • -ignore-ext: especifica las extensiones que se excluirán
  • Se pueden pasar archivos y carpetas juntos como argumentos
entropy -top 5 -ignore-ext min.js,pdf,png,jpg,jpeg,zip,mp4,gif my-folder my-file1 my-file2

Puntos a tener en cuenta al usar Docker

  • La opción -v de Docker se usa para montar el directorio actual dentro del contenedor
  • /data es el directorio base donde la herramienta busca archivos
  • Si no se agrega /data al final del comando, buscará dentro del contenedor en lugar del sistema de archivos local
docker run --rm -v $(pwd):/data ewenquim/entropy -top 20 -ext go,py,js /data
docker run --rm -v $(pwd):/data ewenquim/entropy -top 5 /data/my-folder /data/my-file

Lecturas relacionadas

1 comentarios

 
GN⁺ 2024-06-06
Opiniones en Hacker News

  • Interesante. Si yo lo hiciera, creo que lo haría de esta forma, basándome en el principio de que la alta entropía no se comprime bien
    perl -lne 'next unless $_; $z = qx(echo "$_" | gzip | wc -c); printf "%5.2f %s\n", $z/length($_), $_'
    Aunque este enfoque usa cada línea como si fuera un diccionario, en lugar de usar el archivo completo, así que las líneas muy cortas no se comprimen bien y eso causa algunos problemas
    Reaccionó ante una línea como return map { $_ > 1 ? 1 : ($_ < 0 ? 0 : $_) } @vs;, y aunque es código válido, en realidad sí parece tener una entropía bastante alta
    En cambio, también se podía engañar agregando comentarios en inglés natural para que no detectara líneas de alta entropía
    Estoy en movimiento, así que no puedo revisarlo en detalle, pero sería interesante comparar este comando de Perl con esta herramienta. La ventaja del comando de Perl es que corre de inmediato en casi cualquier máquina que no sea Windows, así que no necesita ser especialmente potente para que la gente lo adopte

    • Hace mucho aprendí Go resolviendo problemas de Advent of Code, y cada vez que resolvía uno, mi compañero de casa me insistía en que le mostrara el código y luego reescribía en una sola línea de Ruby mis soluciones de 10 a 50 líneas en Go
      Mientras tanto se burlaba de Go y de mis programas torpes; sin querer, ese día también aprendí bastante Ruby
    • Medir el tamaño del archivo con todas las líneas excepto la que se está probando, y luego volver a medirlo después de agregar esa línea, podría ser un indicador más justo por la diferencia de tamaño
      También se podrían concatenar todos los archivos de código y probar línea por línea en todo el repositorio, aunque probablemente sería demasiado lento
    • Usaría un compresor mejor que gzip, pero he usado este truco varias veces
      xz o zstd podrían ser mejores opciones, y desde la perspectiva de que la mejor tasa de compresión equivale a una mejor estimación de entropía, también se pueden mirar los ganadores del Hutter Prize [1]
      [1] http://prize.hutter1.net/
    • Me pregunto si existe alguna herramienta de línea de comandos, como zip, que permita predefinir un diccionario con uno o más archivos y luego comprimir archivos pequeños usando ese diccionario
      Claro que, al descomprimir, también habría que pasar ese diccionario como entrada aparte
    • Uso el secret scanner de Yelp como hook de pre-commit, y se configura bastante fácil con el mecanismo de instalación de pre-commit

  • Este problema se trasciende poniendo todas las contraseñas de base de datos como abcd

    • En nuestra base de código, esta herramienta detectó "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890" como una línea de alta entropía
    • Usuario: postgres
      Contraseña: postgres
    • Me recuerda a https://xkcd.com/936/. "correct horse battery staple" parece una simple cadena de palabras comunes, así que supongo que tendría baja entropía

  • Me pregunto si hay algún buen artículo sobre cómo se usa la entropía para este tipo de tareas. Hace tiempo que tengo curiosidad sobre cómo la usa la gente en la práctica y si funciona, pero nunca me puse a investigarlo
    Para empezar, ni siquiera queda claro cómo definir la “entropía” del texto. Aquí es algo simple como -Sum(x log(x)), es decir, x = countOccurences(char) / len(text), pero me surgen varias dudas sobre qué tan bien funciona realmente
    ¿Qué tan larga tiene que ser la cadena? ¿El lenguaje natural tiene una entropía casi constante? ¿Hay un enfoque mejor?
    Por ejemplo, "vorpal" “claramente” debería tener menos entropía que "hJ6&:a". La segunda parece usar un conjunto de caracteres mucho más grande que el lenguaje natural y, aunque no fuera así, el orden de los caracteres importa: la primera suena como una palabra real aunque sea una palabra inventada por Carroll
    Pero esta “entropía” que todo el mundo usa no sabe nada de eso. Ambas tendrían exactamente la misma “entropía”
    Quizá funcione lo suficientemente bien para otro buscador de contraseñas en GitHub, pero me pregunto si hay algo mejor. ¿Existe alguna métrica que mida la aleatoriedad del texto de una forma más significativa?
    Hay decenas de proyectos de este tipo y todos usan “entropía” como si fuera obvio, pero nunca vi una investigación seria sobre el tema

    • La entropía es una medida de la complejidad o el desorden de una señal. Lo interesante es que ese desorden es relativo a una base o diccionario adecuado
      Algo puede parecer complejo en una codificación, pero tener baja entropía en la codificación correcta
      Para determinar con precisión la entropía de una señal, hay que conocer la base correcta o inferirla a partir del contexto
      Para hacer más potente la herramienta del artículo original, convendría tener algunos diccionarios precalculados para rangos típicos de texto, como código fuente o lenguaje natural, y comparar la compresibilidad codificando la cadena con cada diccionario
      Las cadenas de alta entropía, como los secretos, no se comprimirían bien con ninguno de los diccionarios disponibles
    • La entropía de una cadena específica no es un concepto matemático riguroso. Por definición, una cadena ya conocida solo puede tener un valor, así que su “entropía” es de 0 bits
      Podemos distinguir datos aleatorios de datos no aleatorios porque, de todos los estados posibles, solo un subconjunto pequeño se considera útil para los humanos, y tenemos cierta idea de cómo se ve ese subconjunto, lo que nos permite estimar mediante qué proceso se generó una cadena específica
      Por supuesto, pruebas estadísticas como https://en.wikipedia.org/wiki/Diehard_tests son lo suficientemente buenas para distinguir datos de baja entropía de datos de alta entropía, pero los generadores seudoaleatorios modernos no tienen problema en pasar todas esas pruebas, aunque la “entropía” real sea apenas la semilla y la complejidad del algoritmo
    • La complejidad de Kolmogórov de una cadena arbitraria no es computable

  • Herramientas que vale la pena ver también:
    trufflehog: https://github.com/trufflesecurity/trufflehog
    detect-secrets: https://github.com/Yelp/detect-secrets
    semgrep secrets: https://semgrep.dev/products/semgrep-secrets -- es de pago, pero según el caso puede estar incluido en una licencia existente

    • Para encontrar cadenas interesantes y secretos, PyWhat también vale la pena: https://github.com/bee-san/pyWhat
    • noseyparker también está bien: https://github.com/praetorian-inc/noseyparker
      Creo que estas soluciones son mucho mejores para encontrar secretos que un enfoque simple basado en entropía.
      Es cierto que la entropía es más general, pero estas herramientas ya están bien establecidas y se han validado con muchísimos conjuntos de datos.

  • Hace unos años me ayudó DrJones al preguntar qué era una cadena de alta entropía[0] y enlazar un buen artículo relacionado[1].
    [0] https://news.ycombinator.com/item?id=13304641
    [1] https://www.splunk.com/en_us/blog/security/random-words-on-e...

  • Me recordó al programa ent, que llevo usando desde hace mucho.
    https://fourmilab.ch/random/

  • Sería útil que también revisara todo el historial de git del proyecto. Aunque un secreto se haya commiteado y luego eliminado, todavía puede quedar en el historial.

  • No entiendo por qué hay que instalar Go para ejecutar esta herramienta. ¿No era una de las ventajas de Go que los desarrolladores podían distribuir un binario único que simplemente funcionara?

    • Al ser una herramienta de seguridad, confiar en un binario desde el principio va en contra del objetivo. Si está el código fuente, al menos tienes la opción de revisar qué hace realmente.
    • Quería subirla a Homebrew, pero rechazaron el PR, así que parece que tendré que crear mi propio brew tap o convencerlos de aceptarlo.
      También planeo crear una imagen de Docker.
      Sinceramente, no esperaba que se volviera tan popular, así que el repositorio todavía no está 100% listo.
    • El contenedor de Docker ya está disponible y está documentado en la página de inicio.

  • Un modelo de lenguaje como Llama 3 podría modelar el grado de sorpresa por token y detectar las zonas más sorprendentes, es decir, las de mayor entropía.
    Como en uno de los ejemplos, el alfabeto completo puede tener alta entropía desde cierto punto de vista, pero un modelo de lenguaje familiarizado con código no consideraría nada sorprendente que una base de código tenga el alfabeto Base62 como constante.