Actualización del proyecto 2020

Scallion fue un proyecto hobby para aprender OpenCL y RSA. Actualmente no mantenemos scallion. Se ha deteriorado de dos maneras importantes:

1. Tor ha migrado a direcciones Onion v3, las cuales scallion no soporta. Las direcciones v2 antiguas dejarán de funcionar en octubre de 2021. El nuevo estándar usa primitivas criptográficas diferentes y es en general más complicado. El truco que usamos para generar lotes de claves RSA en la GPU no funciona de la misma manera para las nuevas claves ECDSA requeridas. Es posible generar claves ECDSA similares (pero no compatibles) en la GPU, para la generación de direcciones Bitcoin. Vea vanitygen-plus o el más antiguo oclvanitygen. Para una lista de herramientas de vanity gen (basadas en CPU) que funcionan para servicios ocultos Tor v3, vea esta publicación de blog.
2. La versión de OpenSSL de la que dependemos ha quedado obsoleta y no está disponible en la mayoría de los SO modernos. No es sencillo actualizarla, ya que usamos algunas funciones matemáticas de bajo nivel en OpenSSL que no están disponibles en los enlaces de C# para las versiones más nuevas. Personalmente ejecuto Scallion usando el dockerfile de nvidia, que está basado en Ubuntu 16.04 Xenial, el cual aún incluye la versión obsoleta de OpenSSL. Sin embargo, esto solo es una opción para usuarios de GPU Nvidia. También podrías intentar compilar la biblioteca OpenSSL antigua y enlazarla directamente, o ejecutar una versión anterior de tu SO desde un USB en vivo o MV (con paso a través de PCI-e).

Con suficiente atención y esfuerzo, sería posible superar ambos desafíos mencionados. Podríamos implementar soporte para el algoritmo de generación de claves ECDSA en GPU para obtener soporte Tor v3. Podríamos actualizar OpenSSL y reemplazar las funciones matemáticas con otra biblioteca, o hacer nuestro propio envoltorio de código administrado para la biblioteca OpenSSL. Sin embargo, probablemente sería mejor agregar soporte para direcciones onion v3 a un proyecto mantenido como vanitygen-plus.

Scallion

Scallion te permite crear claves GPG personalizadas y direcciones .onion (para los servicios ocultos de Tor) usando OpenCL.

Scallion se ejecuta en Mono (probado en Arch Linux) y .NET 3.5+ (probado en Windows 7 y Server 2008).

Scallion se encuentra actualmente en etapa beta y en desarrollo activo. No obstante, creemos que está listo para su uso. Se esperan mejoras principalmente en rendimiento, interfaz de usuario y facilidad de instalación, no en el algoritmo general utilizado para generar claves.

Scallion está disponible bajo la licencia MIT. Si usas código de este proyecto en tus propios proyectos, agradeceríamos que nos lo hicieras saber en [email protected].

FAQ

Aquí hay algunas preguntas frecuentes y sus respuestas:

• ¿Por qué generar claves GPG?

  Scallion se usó para encontrar colisiones para cada ID de clave de 32 bits en el conjunto fuerte de Web of Trust, demostrando lo inseguros que son los IDs de clave de 32 bits. Hubo/hay una charla en DEFCON (video) y se puede encontrar información adicional en https://evil32.com/.

• ¿Cuáles son los caracteres válidos?

  Las direcciones .onion de Tor usan Base32, que consiste en todas las letras y los dígitos del 2 al 7, inclusive. No distinguen entre mayúsculas y minúsculas.

  Las huellas digitales GPG usan hexadecimal, que consiste en los dígitos 0-9 y las letras A-F.

• ¿Se pueden usar ASICs de Bitcoin (ej. Jalapeno, KnC) para acelerar este proceso?

  Lamentablemente, no. Si bien el proceso que usa Scallion es conceptualmente similar (incrementar un nonce y verificar el hash), los detalles son diferentes (SHA-1 frente a doble SHA-256 de Bitcoin). Además, los ASICs de Bitcoin son tan rápidos porque están extremadamente adaptados a las aplicaciones de minería de Bitcoin. Por ejemplo, aquí está la hoja de datos del CoinCraft A-1, un ASIC que nunca salió, pero es probablemente indicativo del enfoque general. El microcontrolador envía trabajo en forma de los últimos 128 bits de un bloque de Bitcoin, el estado intermedio del hash de los bits anteriores, una dificultad objetivo y el nonce máximo a probar. El ASIC elige la ubicación para insertar el nonce, y elige qué bloques cumplen con el hash. Scallion tiene que insertar el nonce en una ubicación diferente, y verifica una coincidencia de patrón en lugar de simplemente "menor que XXXX".

• ¿Cómo se pueden usar múltiples dispositivos?

  Ejecuta múltiples instancias de Scallion. 😄 Las búsquedas de Scallion son probabilísticas, por lo que no repetirás trabajo con el segundo dispositivo. El soporte multidispositivo real no sería demasiado difícil, pero tampoco agregaría mucho. He ejecutado varias instancias de scallion en tmux o screen con gran éxito. Solo necesitarás abortar manualmente todos los trabajos cuando uno encuentre un patrón (o escribir un script de shell que monitoree el archivo de salida y los mate a todos cuando vea resultados).

Dependencias

• OpenCL y los controladores relevantes instalados y configurados. Consulte la documentación de su distribución.
• OpenSSL. Para Windows, se incluyen las DLL x86 precompiladas
• Solo en Windows, VC++ Redistributable 2008

Descarga de binarios

¿Solo quieres la última versión binaria? Consíguela aquí.

Compilar en Linux

Requisitos previos

• Obtén la última versión de mono para tu distribución de Linux:

  http://www.mono-project.com/download/

• Instala las dependencias comunes:

  root@kitploit:~

  sudo apt-get update
  sudo apt-get install libssl-dev mono-devel
  

• Compilación AMD/OpenSource sudo apt-get install ocl-icd-opencl-dev

• Compilación Nvidia sudo apt-get install nvidia-opencl-dev nvidia-opencl-icd

• Finalmente msbuild scallion.sln

Docker Linux (solo GPUs nvidia)

1. Ten el tiempo de ejecución del contenedor nvidia-docker

2. Construye el contenedor:

   root@kitploit:~

   docker build -t scallion -f Dockerfile.nvidia .
   

3. Ejecuta:

   root@kitploit:~

   docker run --runtime=nvidia -ti --rm scallion -l
   

   captura de pantalla de la salida esperada

Compilar en Windows

1. Abre 'scallion.sln' en VS Express for Desktop 2012
2. Compila la solución, yo hice todo en modo debug.

Uso

Reiniciar Scallion durante una búsqueda no perderá "progreso". Es una búsqueda probabilística y Scallion no hace "progreso"

Listar dispositivos

$ mono scallion/bin/Debug/scallion.exe -l

Generar un hash

$ mono scallion/bin/Debug/scallion.exe -d 0 prefix
Cooking up some delicious scallions...
Using kernel optimized from file kernel.cl (Optimized4)
Using work group size 128
Compiling kernel... done.
Testing SHA1 hash...
CPU SHA-1: d3486ae9136e7856bc42212385ea797094475802
GPU SHA-1: d3486ae9136e7856bc42212385ea797094475802
Looks good!
LoopIteration:40  HashCount:671.09MH  Speed:9.5MH/s  Runtime:00:01:10  Predicted:00:00:56  Found new key! Found 1 unique keys.
<XmlMatchOutput>
  <GeneratedDate>2014-08-05T07:14:50.329955Z</GeneratedDate>
  <Hash>prefix64kxpwmzdz.onion</Hash>
  <PrivateKey>-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQCmYmTnwGOCpsPOqvs5mZQbIM1TTqOHK1r6zGvpk61ZaT7z2BCE
FPvdTdkZ4tQ3/95ufjhPx7EVDjeJ/JUbT0QAW/YflzUfFJuBli0J2eUJzhhiHpC/
1d3rb6Uhnwvv3xSnfG8m7LeI/Ao3FLtyZFgGZPwsw3BZYyJn3sD1mJIJrQIEB/ZP
ZwKBgCTUQTR4zcz65zSOfo95l3YetVhfmApYcQQd8HTxgTqEsjr00XzW799ioIWt
vaKMCtJlkWLz4N1EqflOH3WnXsEkNA5AVFe1FTirijuaH7e46fuaPJWhaSq1qERT
eQT1jY2jytnsJT0VR7e2F83FKINjLeccnkkiVknsjrOPrzkXAkEA0Ky+vQdEj64e
iP4Rxc1NreB7oKor40+w7XSA0hyLA3JQjaHcseg/bqYxPZ5J4JkCNmjavGdM1v6E
OsVVaMWQ7QJBAMweWSWtLp6rVOvTcjZg+l5+D2NH+KbhHbNLBcSDIvHNmD9RzGM1
Xvt+rR0FA0wUDelcdJt0R29v2t19k2IBA8ECQFMDRoOQ+GBSoDUs7PUWdcXtM7Nt
QW350QEJ1hBJkG2SqyNJuepH4PIktjfytgcwQi9w7iFafyxcAAEYgj4HZw8CQAUI
3xXEA2yZf9/wYax6/Gm67cpKc3sgKVczFxsHhzEml6hi5u0FG7aNs7jQTRMW0aVF
P8Ecx3l7iZ6TeakqGhcCQGdhCaEb7bybAmwQ520omqfHWSte2Wyh+sWZXNy49EBg
d1mBig/w54sOBCUHjfkO9gyiANP/uBbR6k/bnmF4dMc=
-----END RSA PRIVATE KEY-----
</PrivateKey>
  <PublicModulusBytes>pmJk58BjgqbDzqr7OZmUGyDNU06jhyta+sxr6ZOtWWk+89gQhBT73U3ZGeLUN//ebn44T8exFQ43ifyVG09EAFv2H5c1HxSbgZYtCdnlCc4YYh6Qv9Xd62+lIZ8L798Up3xvJuy3iPwKNxS7cmRYBmT8LMNwWWMiZ97A9ZiSCa0=</PublicModulusBytes>
  <PublicExponentBytes>B/ZPZw==</PublicExponentBytes>
</XmlMatchOutput>
init: 491ms / 1 (491ms, 2.04/s)
generate key: 1193ms / 6 (198.83ms, 5.03/s)
cpu precompute: 10ms / 6 (1.67ms, 600/s)
total without init: 70640ms / 1 (70640ms, 0.01/s)
set buffers: 0ms / 40 (0ms, 0/s)
write buffers: 3ms / 40 (0.08ms, 13333.33/s)
read results: 67442ms / 40 (1686.05ms, 0.59/s)
check results: 185ms / 40 (4.63ms, 216.22/s)

9.50 million hashes per second

Stopping the GPU and shutting down...

Búsqueda multipatrón

Scallion soporta encontrar uno o más de múltiples patrones mediante una sintaxis de regex primitiva. Solo se admiten clases de caracteres (ej. [abcd]). El carácter . representa cualquier carácter. Las direcciones Onion siempre tienen 16 caracteres de largo y las huellas GPG siempre tienen 40 caracteres. Puedes encontrar un sufijo colocando $ al final de la coincidencia (ej. DEAD$). Finalmente, la sintaxis de tubería (ej. pattern1|pattern2) se puede usar para encontrar múltiples patrones. Buscar múltiples patrones (dentro de lo razonable) NO producirá una disminución significativa de velocidad. Muchas expresiones regulares producirán un solo patrón en la GPU y no resultarán en reducción de velocidad.

Algunos casos de uso con ejemplos:

• Generar un prefijo seguido de un número para mejor legibilidad:

  root@kitploit:~

    mono scallion.exe prefix[234567]
  

• Buscar varios patrones a la vez (n.b. -c hace que scallion continúe generando incluso cuando obtiene un acierto)

  root@kitploit:~

    mono scallion.exe -c prefix scallion hashes
    mono scallion.exe -c "prefix|scallion|hashes"
  

• Buscar el sufijo "badbeef"

  root@kitploit:~

    mono scallion.exe .........badbeef
    mono scallion.exe --gpg badbeef$ # Generate GPG key
  

• Ejemplo complicado autoexplicativo:

  root@kitploit:~

    mono scallion.exe "suffixa$|suffixb$|prefixa|prefixb|a.suffix$|a.test.$"
  

¿Cómo funciona Scallion?

A alto nivel Scallion funciona de la siguiente manera:

1. Generar clave RSA usando OpenSSL en la CPU
2. Enviar la clave a la GPU
3. Incrementar el exponente público de la clave
4. Hashear la clave
5. Si la clave hasheada no es una colisión parcial, ir al paso 3
6. Si la clave no pasa las comprobaciones de cordura recomendadas por PKCS #1 v2.1 (verificado en la CPU) ir al paso 3
7. ¡Nueva clave con colisión parcial!

El algoritmo básico se describe arriba. La velocidad / rendimiento es el resultado de una paralelización masiva, tanto en la GPU como en la CPU.

Velocidad / Rendimiento

Es importante darse cuenta de que Scallion realiza una búsqueda probabilística. Los tiempos reales pueden variar significativamente de lo predicho

La generación inicial de la clave RSA se realiza en la CPU. Un i7 Ivybridge puede generar 51 claves por segundo usando un solo núcleo. Cada clave puede proporcionar 1 gigahash de exponentes para minar y una CPU decente puede mantener el ritmo de varias GPU tal como está implementado actualmente.

El hasheo SHA1 se realiza en la GPU. Las tasas de hash para varias GPU que hemos probado se muestran a continuación (agrupadas por fabricante y ordenadas por potencia):

MH/s = millones de hashes por segundo

Vale la pena señalar que Intel ha lanzado controladores OpenCL para sus procesadores y se pueden encontrar colisiones cortas en la CPU.

Para calcular el número de segundos requeridos para una colisión parcial dada (en promedio), usa la fórmula:

Por ejemplo, en mi nVidia Quadro K2000M, veo alrededor de 90 MH/s. Con esa velocidad puedo generar un prefijo .onion de ocho caracteres en aproximadamente 1h 41m, 2^(5*8-1)/90 million = 101 minutos.

Tamaño del grupo de trabajo

Scallion usará el tamaño de grupo de trabajo preferido reportado por tus dispositivos por defecto. Este es un valor predeterminado razonable, pero experimentar con el grupo de trabajo puede aumentar el rendimiento.

Seguridad

Las claves generadas por Scallion son bastante similares a las generadas por shallot. Tienen exponentes públicos inusualmente grandes, pero pasan por el conjunto completo de comprobaciones de cordura recomendadas por PKCS #1 v2.1 a través de la función RSA_check_key de openssl. Scallion soporta varios tamaños de clave RSA, con kernels optimizados para 1024b, 2048b y 4096b. Otros tamaños de clave pueden funcionar, pero no han sido probados.

Agradecimientos / Referencias

• Scallion está basado en parte en shallot e inspirado por vanitygen
• La implementación OpenCL SHA-1 fue adaptada de NearSHA
• Incluye componentes de OpenTK y OpenSSL-net

Donaciones

Siéntete libre de dirigir donaciones a la dirección Bitcoin: 1FxQcu6vhpwsqcTjPsjK43CZ9vjnuk4Hmo