elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


  Mostrar Temas
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 18
1  Foros Generales / Criptomonedas / Guarda tu direccion de Bitcoin aqui en: 7 Diciembre 2023, 23:44 pm
Muy buen dia uno de los usos que se le pueden dar a las direcciones bitcoin es la capacidad de firmar mensajes. Esto se puede utilizar para comprobar nuestra identidad en caso de que perdamos acceso a nuestra cuenta del foro, se podria recuperar si demuestras que puede firmar un mensaje con una direccion previamente guardada aqui.

Ejemplo:

direccion:
Código:
bc1qjyhcjacmpc9pg8wes82lktyrjcwk4sdvqtm7ky

mensaje:
Código:
albertobsd firmando un mensaje para elhacker.net el dia 7 de Diciembre del 2023

firma:
Código:
H25r390myHLOSZ9RbvN1b3iCzVv52ulBOfdhMfQPFT67PPIA53ySheDWDGbnt6sUqQmImG7JOReN3yGd3+3z0T0=

Con esta informacion cualquier persona con la aplicacion de Electrum o sparrow podria verificar que la firma es valida.

Ejemplo:



La idea es que alguien mas realize un quote de nuestro firma para que quede evidencia de la misma en la cuenta de alguien mas esto con el objetivo de que si nuestra cuenta es hackeada o comprometida de alguna forma, el atacante aunque pueda modificar nuestra firma en nuestro post, este no podra editar el post de otro usuario que qudaria como evidencia o respaldo de nuestra firma.

Formato:
Código:
direccion:
mensaje:
firma:
2  Seguridad Informática / Criptografía / PGP Tutorial en: 9 Octubre 2023, 16:03 pm
Muy buen dia dejare aqui una guia express para utilizar GPG, Aqui doy por entendido que ya lo tienen instalado en su sistema.

Crear una llave paso por paso:
Código:
gpg --full-gen-key --expert

Con este comando podremos crear una llave paso a paso, personalmente recomiendo una llave ed25519 ya que son llaves pequeñas, seguras para los estandadres modernos y muy rapidas de generar/firmar/cifrar

Para generar una llave ed25519 hay que seleccionar las opciones:

Código:
ECC and ECC

Luego

Código:
Curve 25519

Y el detalle de la expieracion de la key se lo dejo al criterio de cada quien.

NOTA IMPORTANTE, el proceso te va a pedir un password, Trata de que sea un password que recuerdes muy bien y de preferencia tenerlo respaldado, ya que si lo pierdes no habra manera de recuperar tu llave privada.

Listar llaves privadas

Código:
gpg --list-secret-keys

Esta es la llave que recien generamos solo con las llaves que aparecen en esta lista podremos firmar y cifrar documentos


Listar llaves publicas

Código:
gpg --list-keys

Esta es una lista de todas las llaves publicas que estan guardardas, generalmente solo aparece nuestra llave publica, pero si ya hemos importado la llave publica de alguien mas, esta tambien aparecera listada.

Importar llaves publicas de alguien mas

Código:
gpg --import their_public_key.asc

en el archivo their_public_key.asc (Que podria tener cualquier otro nombre) se encuentra la llave publica de otra persona y la podremos importar a nuestra lista para en el futuro poder cifrar mensajes que solo el destinatario pueda leer.

Pudes tratar de impotar mi llave publica, guarda el siguiente texto en un archivo de texto y luego importarlo con el comando anterior:


Mi llave publica es:
Código:
-----BEGIN PGP PUBLIC KEY BLOCK-----

mDMEZSGE8hYJKwYBBAHaRw8BAQdAVaD+e9jobVYRJtg0hs/FOaED+2U3WRMoNmzU
fVXrvaO0IWFsYmVydG9ic2QgPGFsYmVydG9ic2RAZ21haWwuY29tPoiQBBMWCAA4
FiEEcPyyF88mxDTnyu++7UQ4Plx1G84FAmUhhPICGwMFCwkIBwIGFQoJCAsCBBYC
AwECHgECF4AACgkQ7UQ4Plx1G87l+gD/QS6Pc9lafJIpl4v1sOJOG8nr5zg8/gep
lKx5evXvXMMBAOFupEvid0juHvIowTA090jophE49NNGuoJRw3FAGjgFuDgEZSGE
8hIKKwYBBAGXVQEFAQEHQCthQ0Ma0WnygqMLe9zBU9TZ4Blc0/nbBPBWKHWcTjdL
AwEIB4h4BBgWCAAgFiEEcPyyF88mxDTnyu++7UQ4Plx1G84FAmUhhPICGwwACgkQ
7UQ4Plx1G87wHQEAi8xRkg0MgFdVXXzIxckSdblvb5HV0un96fmBPZo1WOwA/0Xn
jyqFAOn1bvQrgo3oxN7sOjfpsaKhUaupv7/yvNMM
=GFvH
-----END PGP PUBLIC KEY BLOCK-----

Exportar tu llave publica o la de alguien mas

Código:
gpg --export --armor "Name or Email or KEY ID" > public_key.asc

Con este comando podras exportar tu llave publica o la de alguin mas (Previamente tu ya deberia de haberla importado).

Nota que la salida es redirigida a un archivo de texto public_key.asc.


Firmar un archivo de Texto

Código:
gpg --clearsign --local-user "Name or Email or KEY ID" -o signed_message.txt message.txt

Si quieres firmar un archivo de texto para autenticar que tu lo generaste o demotrar que tu tienes el control de determinada llave privada utiliza el comando anterior.
Al archivo a firmar es menssage.txt y el archivo resultando es signed_message.txt

menssage.txt
Código:
albertobsd firmando un mensaje para foro.elhacker.net el dia 8 de Octubre del 2023

signed_message.txt
Código:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

albertobsd firmando un mensaje para foro.elhacker.net el dia 8 de Octubre del 2023
-----BEGIN PGP SIGNATURE-----

iHUEARYIAB0WIQRw/LIXzybENOfK777tRDg+XHUbzgUCZSQEQAAKCRDtRDg+XHUb
zkLcAP9CeyNIUTWDhlg49ZHhk6fx86CEq9YJfv3ih1j0LRWKkwD+J4sT6EwaUJVu
ihKVfatmv3nVtvsR7eYUl10jzpsyVgE=
=lfJW
-----END PGP SIGNATURE-----

Verificar un mensaje de texto firmado

Código:
gpg --verify signed_message.txt

Puedes verificar mi mensaje firmado o el de alguien mas con el comando anterior

Código:
gpg: Signature made Mon Oct  9 07:46:40 2023 CST
gpg:                using EDDSA key 70FCB217CF26C434E7CAEFBEED44383E5C751BCE
gpg: Good signature from "albertobsd <...>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: 70FC B217 CF26 C434 E7CA  EFBE ED44 383E 5C75 1BCE

Haz caso omiso del warning lo que nos interesa es:
Citar
gpg: Signature made Mon Oct  9 07:46:40 2023 CST
gpg:                using EDDSA key 70FCB217CF26C434E7CAEFBEED44383E5C751BCE

Citar
Primary key fingerprint: 70FC B217 CF26 C434 E7CA  EFBE ED44 383E 5C75 1BCE

Si la llave coincide con la llave esperada entonces la persona que firmo el mensaje tiene control sobre la llave privada ligada al mismo.

Cifrar un mensaje para que solo pueda ser visto por un solo destinatario

Código:
gpg --encrypt --recipient "Recipient Name or Email or KEY ID" --armor --local-user "Recipient Name or Email or KEY ID" -o encrypted_message.asc message.txt

El archivo de entrada es message.txt y el de salida es encrypted_message.asc

Aqui pueden cifrar un mensaje para mi y si lo puedo descifrar les mandarare un mensaje para que lo descifren ustedes, si hacen esto solo respondan a este mensaje con el mensaje cifrado, no se olviden de publicar su llave publica tambien, aqui o de preferencia en el siguiente hilo: https://foro.elhacker.net/criptografia/pgpgpg_public_key_database_guarda_tu_llave_publica_aqui-t518947.0.html

Descifrar un mensaje Que te enviaron

Código:
gpg --decrypt encrypted_message.asc

No hay mucho que decir, si tu tienes la llave privada asociada a la llave publica que se utilizo como destinatario del mensaje cifrado, entonces tu seras capas de descifrar el mensaje.

Y por ultimo

Respaldar tu llave privada

Código:
gpg --export-secret-keys "Recipient Name or Email or KEY ID" > backup-key.asc

Es sumamente impoetante que respaldes tu llave privada en un archivo y este lo copies a una o dos unidades USB, el archivo backup tiene el mismo password que utilizaste la cuando lo creaste, asi que tambien es importante que respaldes este password ya que sin el PERDERAS el acceso a tu llave privada
3  Seguridad Informática / Criptografía / PGP/GPG Public Key Database: Guarda tu llave publica aqui en: 9 Octubre 2023, 02:16 am
Muy buen dia usuarios, me gustaria empezar este tema en este foro ya que no recuerdo verlo con anterioridad. Y si es que existe no encuentro el Tema.

La idea se trata de tener una base de datos o registro de las llaves PGP de los miembros. Con estas podran se podra firmar mensajes que requieran cierto tipo de autenticacion. He incluso enviar mensajes totalmente cifrados.

Otro uso que se puede dar, es en caso de perder acceso a tu correo electronico podrias demostrar que eres tu firmando un mensaje con tu llave y pidiendo el reseteo de tu cuenta del foro a un nuevo correo.

Instrucciones para generar trabajar con GPG:

-Crear una juego de llaves privadas/publicas.
-Firmar un mensaje
-Exportar llave publica.
-Impotar llave publica de alguien mas.
-Encryptar un mensaje que solo un destinatario pueda ver.

-Importar llave privada (Para Respaldo)



Con el fin de preserva las llaves de otros usarios, cada que alguien publique su llave publica, otro usuario deberia de realizar un Quote guardado la llave de ese usuario en un nuevo mensaje esto para evitar ediciones en caso de que la cuenta sea hackeada, aprovechando el mismo para  validar que el mensaje fimado sea correcto ejemplo y en su caso publicar tu propia llave publica

Mensaje de usuario Alice:
Código:
-----BEGIN PGP PUBLIC KEY BLOCK-----
<Llave de Alice>
-----END PGP PUBLIC KEY BLOCK-----
Código:
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256

Alice firmando mensaje para elhacker.net fecha 08/10/2023
-----BEGIN PGP SIGNATURE-----

<Signature>
-----END PGP SIGNATURE-----

Mensaje de usuario Bob:
Citar
Código:
-----BEGIN PGP PUBLIC KEY BLOCK-----
<Llave de Alice>
-----END PGP PUBLIC KEY BLOCK-----

Llave de Alice verificada.

Código:
-----BEGIN PGP PUBLIC KEY BLOCK-----
<Llave de BOB>
-----END PGP PUBLIC KEY BLOCK-----
4  Programación / Desarrollo Web / [Resuelto] alternativa a hash_pbkdf2 de PHP en javascript? en: 3 Agosto 2022, 17:29 pm
Hola tengo una pequeña duda de que alternativa utilizar a la función hash_pbkdf2 de PHP en javascript.

Ejemplo en PHP

Código
  1. <?php
  2. $salt = hex2bin("0123456789ABCDEF0123456789ABCDEF");
  3. $secret = hash_pbkdf2("sha512","secret",$salt,200000,0,false);
  4. echo "$secret\n";
  5. ?>
  6.  

Salida:
Código:
b14e5cb8d8ab9cabd2374a6d7a3dc6c1e8c2426fea3aaee98739d39c7e98661848fa22dc08e8734790fc4f88a007bd1a6e38ee4f70c7d3823bae8b848a9cedfa

Ya intente utilizar WebCrypto API y tambien CryptoJS y ninguno produce el mismo resultado, tal vez estoy haciendo las cosas mal no lo se, pero no mas no doy con la solucion

Código
  1. function test() {
  2. salt = hexToBytes("0123456789ABCDEF0123456789ABCDEF");
  3. password = "secret"
  4. secret = CryptoJS.PBKDF2(CryptoJS.enc.Utf8.parse(password), CryptoJS.enc.Utf8.parse(salt), { keySize: 512 / 32, iterations: 200000, hasher: CryptoJS.algo.SHA512});
  5. console.log(secret);
  6. }

Salida
Código:
4e334679d8a7368e0ed0d0699f164317931f4bf227c45989ed59b3ad2424bbe8b056298c0d56e08c810ce4e1ad7e34ab067ab1e9ee47a9ee69ab7ab3351ea126

Adicional a esto tengo el problema del Rendimiento en PHP originalmente tenia Un millon de Iteraciones y en PHP solo tardaba un segundo, pero estas funciones de JS tardaban mas de 2 minutos.

Saludos!
5  Programación / Programación C/C++ / Me cago en C/C++ en: 5 Marzo 2022, 19:49 pm
No se ofendan ni se enojen es titulo es clickbait, me encanta utilizar C tengo usándolo varios años (bastantes) y aun sigo aprendiendo cosas nuevas. C++ aun que conozco mucho de la teoria de las clases, me falta mucha practica, aun lo estoy aprendiendo, no termino de acostumbrándome a las nuevas clases de  estructuras de datos que ya tienen casi todo implementado.

Digo casi todo, por que aunque en C me gusta implementar todo desde 0, entiendo que en el mundo laboral no tendrás tiempo de hacer todo eso así que lo ideal seria utilziar C++ con un framwork ya trabajado y depurado por otros o en su defecto otro lenguaje mas friendly....

Para practicar C++ estoy haciendo muchos ejercicios de programación y también resolviendo algunos capture the flag en linea, pero se me presenta el siguiente problema y creo que se seguirá presentando.:

aunque la clase string ya esta muy depurada y implementada desde hace años, aun no tiene por defecto una funcion trim..... DE VERDAD?

Siendo tan facil utilizar en JAVA u otro lenguaje

Código
  1. s.trim()

PHP

Código
  1. trim(string $string, string $characters = " \n\r\t\v\x00"): string

Buscando en google me encuentro con que hay que implementar muchas cosas desde 0 aun ya teniendo

https://www.techiedelight.com/trim-string-cpp-remove-leading-trailing-spaces/
https://stackoverflow.com/questions/216823/how-to-trim-a-stdstring

Ok lo agrego no pasa nada.

En un capture te flag necesito hacer base64 encode y decode ... ¿Que creen? No hay una p**a funcion estandar para ello

Buscando en linea:

https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c
https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp/index

Siendo que también otros lenguajes ya lo tiene ahí listo para usar...

Código
  1. import base64
  2. base64_bytes = base64.b64encode(message_bytes)
  3.  

En C tienes que implementarlo desde 0 o depender de librerías externas.... si lo se, nada me cuesta agregar la librería y usarla... va no hay queja lo hago y listo, aun asi me sorprende que C++ no tenga ciertas cosas que ya están implementadas amplia-mente en otros lenguajes mas recientes que el mismo C++

Y esto solo es es mi primera hora que empezando a migrar mis códigos de C a C++

Esta es la razón por la que C++ no es tan popular, no se diga C.

En otros lenguajes como python o Java muchas veces no te tienes que preocupar por la asignación de memoria o la inicialización de ciertas variables entre otras cosas.

Eso es todo solo quería desahogarme un poco, seguire utilizando C/C++.. si alguien mas puede compartir su opinión, agrego una pregunta para abrir debate:

¿debería de enfocarme en python u otro lenguaje diferente a C++ en 2022?

Saludos!
6  Seguridad Informática / Criptografía / shared secret en bitcoin en: 27 Febrero 2022, 12:56 pm
Acabo de publicar una pequeña herramienta (Prueba de concepto) para calcular un secreto compartido entre Alice y Bob utilizando su llaves de bitcoin.

sharedsecret

Alicia (Tu) quiere enviar un archivo cifrado a Bob (Otra persona) Alicia tiene su propia llave privada y ademas conoce la llave Publica de Bob

Alicia utiliza esta herramienta de para caluclar el secreto compartido entre ambos y utilizar ese mismo secreto como llave

LLaves de Alicia para el ejemplo:

Código:
Private key: 18f619c4d16057d362ddfce772f551d46a2390517698226cff6e5bf67ac4b324 (Desconocida para Bob y para todo el mundo)
Public key : 03af6e50db92ce378c29df0ed9a04d3431bc06762aa37ec3ab42af147083630596 (Publica)

Llaves de Bob para el ejemplo:
Código:
Private key: bc9e78f140a76cbdcdbecc5ab0ec38b4db710edfa40dea342712c8a695fe8b22 (Desconocida for Alicia y para todo el mundo)
Public key : 022c8191049a3f2816bc95077b91caed87900d0cd2af3757004531face9c3b6082 (Publica)

Alicia ejecuta el programa:

Código:
./sharedsecret
A: private key (hex): 18f619c4d16057d362ddfce772f551d46a2390517698226cff6e5bf67ac4b324
B: public key : 022c8191049a3f2816bc95077b91caed87900d0cd2af3757004531face9c3b6082
Secret between A and B: 22fb667f3bc1a2153e3cef75df0ce757a1c86051c07ace6b0c30dc87f3358511 (DON'T SHARE, THIS IS SECRET)

Bob ejecuta el programa

Código:
./sharedsecret
A: private key (hex): bc9e78f140a76cbdcdbecc5ab0ec38b4db710edfa40dea342712c8a695fe8b22
B: public key : 03af6e50db92ce378c29df0ed9a04d3431bc06762aa37ec3ab42af147083630596
Secret between A and B: 22fb667f3bc1a2153e3cef75df0ce757a1c86051c07ace6b0c30dc87f3358511 (DON'T SHARE, THIS IS SECRET)

Alicia y Bob obtienen el mismo secreto, compartiendo unicamente sus llaves PUBLICAS

Alice procede a cifrar el archivo secreto input.txt with the password 22fb667f3bc1a2153e3cef75df0ce757a1c86051c07ace6b0c30dc87f3358511

Código:
openssl aes-256-cbc -salt -pbkdf2 -in input.txt -out input.txt.enc

Bob decifra el archivo secreto utilizando el mismo password: 22fb667f3bc1a2153e3cef75df0ce757a1c86051c07ace6b0c30dc87f3358511:

Código:
openssl aes-256-cbc -d -salt -pbkdf2 -in input.txt.enc -out message.txt



Como funciona esto?

En criptografia asimetrica cada usuario tiene su llave privada y su llave publica.

En curvas elipticas la llave privada es un numero cualquiera, menor que el Orden de la Curva.

Existe un punto generado G(x,y) el cual es la base para todas las llaves publicas de los usurios.

Si tu llave privada es K, tu llave Publica es K*G

Es virtualmente imposible obtener o calcular la llave privada K utilizando la llave Publica K*G, esto es asi por que la multiplicacion en Curvas elipticas no es como la multiplicacion que conocemos.

Alicia tiene su llave Publica: A*G

Bob tiene su llave Publica: B*G

Alicia calcula el secreto compartido entre ella y Bob, multiplicando la llave publica de Bob por su propia Llave Privada obteniendo el nuevo valor: A*B*G
Bob calcula el secreto compartido entre el y Alicia, multiplicando la llave publica de Alicia por su propia Llave Privada obteniendo el  nuevo valor: B*A*G

En este caso A*B*G es igual a B*A*G


No es comun que se utilize de la forma que mostre, pero de igual forma funciona, para ejercicio entre personas que estan iniciando en la criptografia viene bastante bien, ademas personalmente creo que las criptomonedas estan llevando la criptografia mas cerca a las personas, aunque muchos no se den cuenta de ello.

Quires probarlo? genera un par de llaves de bitcoin con el programa keygen que tengo en ese mismo repositorio en github y enviame un adjunto cifrado con el secreto compartido, mi publickey de bitcoin esta en mi firma.

Saludos!
7  Programación / Programación General / Evitar multiples for en incrementos variables Base58 Fuerza bruta en: 21 Enero 2022, 18:19 pm
Aunque creo que es una pregunta Noob, he buscado y no encuentro un ejemplo usable, la verdad no quiero codear tanto pero si he de hacerlo*quiero encontrar la forma mas eficiente.

Tengo un cadena donde faltan caraceteres Unos son totalmente desconocidos "*" y hay que hacerles fuerza bruta (Esta parte ya la tengo hecha)
Pero la misma cadena tiene algunos caraceters que son Probables "?" con ciertos caracteres posibles que no se alcanzan a ver ejemplos 8 y B. X, K y k, S y 5, Esta parte la manejo cada caracter "?"  con su lista individual de caraceters posibles y no es la misma para cada simbolo "?"

Ejemplo:

Código:
sV***??c8NSs1X85ws9Er?z9FwtdJ

Cada caracter "*" puede ser uno de los 58 caraceteres del base58 Esta parte la manejo mas o menos asi

Código
  1. do{
  2. //CODIGO
  3. }while(increment_base58(string,aux));

La solucion anterior es general para cualquier numero de * en el string dado

Pero la parte de los "?" es variable, para este ejemplo vamos a decir que los los ? pueden ser alguno de los siguientes caraceteres respectivamente:

Código
  1. const char *doubt_possibles[3] = {"ec","B28","XKk"};

Significa que el primer caracter "?" de Izquierda a Derecha puede ser e o c el segundo "?" puede ser  B, 2 u 8 (Imagen muy distorcionada) y el ultimo Signo "?" podria ser "X, K o k"

Esta solucion esta hardcodeada de la siguiente manera:

Código
  1. for(contadores[0] = 0; contadores[0] < strlen(doubt_possibles[0]) ; contadores[0]++) {
  2. current_string[doubt_locations[0]] = doubt_possibles[0][contadores[0]];
  3. for(contadores[1] = 0; contadores[1] < strlen(doubt_possibles[1]) ; contadores[1]++) {
  4. current_string[doubt_locations[1]] = doubt_possibles[1][contadores[1]];
  5. for(contadores[2] = 0; contadores[2] < strlen(doubt_possibles[2]) ; contadores[2]++) {
  6. current_string[doubt_locations[2]] = doubt_possibles[2][contadores[2]];
  7. //Otro Codigo
  8. do{
  9. //CODIGO
  10. }while(increment_base58(current_string,aux));
  11. }
  12. }
  13. }
  14.  

El problema con lo anterior es que si me mandan otra cadena diferente o cambia la cantidad de caracteres tengo que editar la mitad del codigo actual.

Mas o menos tengo un leve idea de como hacerlo de forma general, cualquier numero de ? y cualquier longitud de posibles, pero me pregunto cual seria su forma de abordar este problema sin utilizar tanto for, quedando algo asi:

Código
  1. do{ //Do para los "?" en lugar de tanto for....
  2. do{ // Do para los "*"
  3. //CODIGO
  4. }while(increment_base58(current_string,aux));
  5. }while(magic_function(current_string,aux2));
  6.  

Es decir como codificarian "magic_function"

Código
  1. bool magic_function(char *current_string,int aux2){
  2. // Que hay aqui?
  3. }
  4.  
8  Programación / Programación C/C++ / #if 0 ¿Se ejecuta? (Resuelto) en: 13 Abril 2021, 19:24 pm
Código
  1. #if 0
  2. //Code
  3. #endif

Es mi duda, Se ejecuta o no se ejecuta el codigo, Lo comento por que estoy migrando parte de una funcion en programa a otro:

Linea 210 de https://github.com/JeanLucPons/BSGS/blob/master/BSGS.cpp

Código
  1. #if 0
  2.      pp.y.ModSub(&Gn[i].x,&pp.x);
  3.      pp.y.ModMulK1(&_s);
  4.      pp.y.ModSub(&Gn[i].y);           // ry = - p2.y - s*(ret.x-p2.x);  
  5. #endif

Hay varias partes del codigo asi, y mi pregunta es, si no se ocupan para que estan ahi? Si fueran referencia yo las hubiese comentado en lugar de poner ese if 0


Edit

Acabo de comprobarlo, No, no se ejecuta

Código
  1. #include<stdio.h>
  2.  
  3. int main(){
  4. int  i = 10;
  5. printf("%i\n",i);
  6. #if 0
  7. i = 200;
  8. #endif
  9. printf("%i\n",i);
  10. }

Código:
C:\codigos>testif.exe
10
10

¿Por que esta ahí entonces ese segmento de código?

Saludos!
9  Seguridad Informática / Criptografía / Keyhunt en: 8 Abril 2021, 17:06 pm
Buenos días a todos. Quiero abrir este tema para presentar la herramienta que he estado desarrollando en los últimos meses.

Se llama keyhunt y sirve para buscar llaves privadas de criptomonedas (La mayoría de criptomonedas utilizan la misma curva elíptica y por eso se pueden atacar varios al mismo tiempo solo es cuestión de saber que datos se tiene y que se esta haciendo
)

keyhunt utiliza varios métodos para hacerlo y es bastante adaptable, podras desde tu android buscar resolver puzzles de hasta 1.6 bitcoin a una velocidadde Gigakeys/s o Terakeys/s

Link: https://github.com/albertobsd/keyhunt

Yo lo estoy utilizando para tratar de romper unos puzzles de los cuales ya abrí un hilo en este mismo subforo :Rompecabezas de Bitcoin, Medio millón USD en premios

Metodos disponibles

  • address
  • rmd160
  • xpoint
  • pub2rmd
  • bsgs

metodo address

Este método es el mas rudimentario ataque por fuerza bruta que pueda existir y consiste en buscar una privatekey que genere el address indicado.

Ejemplo del archivo de entrada:

Código:
1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
1CUNEBjYrCn2y1SdiUMohaKUi4wpP326Lb
19ZewH8Kk1PDbSNdJ97FP4EiCjTRaZMZQA
1EhqbyUMvvs7BfL8goY6qcPbD6YKfPqb7e
1E6NuFjCi27W5zoXg8TRdcSRq84zJeBW3k
1PitScNLyp2HCygzadCh7FveTnfmpPbfp8
1McVt1vMtCC7yn5b9wgX1833yCcLXzueeC
1M92tSqNmQLYw33fuBvjmeadirh1ysMBxK
1CQFwcjw1dwhtkVWBttNLDtqL7ivBonGPV
1LeBZP5QCwwgXRtmVUvTVrraqPUokyLHqe
1PgQVLmst3Z314JrQn5TNiys8Hc38TcXJu
1DBaumZxUkM4qMQRt2LVWyFJq5kDtSZQot
1Pie8JkxBT6MGPz9Nvi3fsPkr2D8q3GBc1
1ErZWg5cFCe4Vw5BzgfzB74VNLaXEiEkhk
1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW
1BDyrQ6WoF8VN3g9SAS1iKZcPzFfnDVieY
1HduPEXZRdG26SUT5Yk83mLkPyjnZuJ7Bm
1GnNTmTVLZiqQfLbAdp9DVdicEnB5GoERE
1NWmZRpHH4XSPwsW6dsS3nrNWfL1yrJj4w
1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum
14oFNXucftsHiUMY8uctg6N487riuyXs4h
1CfZWK1QTQE3eS9qn61dQjV89KDjZzfNcv
1L2GM8eE7mJWLdo3HZS6su1832NX2txaac
1rSnXMr63jdCuegJFuidJqWxUPV7AtUf7
15JhYXn6Mx3oF4Y7PcTAv2wVVAuCFFQNiP
1JVnST957hGztonaWK6FougdtjxzHzRMMg
128z5d7nN7PkCuX5qoA4Ys6pmxUYnEy86k
12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
19EEC52krRUK1RkUAEZmQdjTyHT7Gp1TYT
1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
1LhE6sCTuGae42Axu1L1ZB7L96yi9irEBE
1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR

Ejemplo de ejecucion:

Código:
./keyhunt -m address -f tests/1to32.txt -r 1:FFFFFFFF

Se especifica el rango de búsqueda del 1 al FFFFFFFF siempre en hexadecimal con -r 1:FFFFFFFF en este caso se especifica ese rango porque sabemos a priori que las address en la lista se encuentran en ese rango indicado, por que fueron address de puzzles anteriores y ya fueron resueltos.

Ejemplo de la salida:

Código:
[+] Version 0.1.20210328
[+] Setting mode address
[+] Opening file tests/1to32.txt
[+] Setting search for btc adddress
[+] Allocating memory for 32 elements: 0.00 MB
[+] Initializing bloom filter for 32 elements.
[+] Loading data to the bloomfilter
[+] Bloomfilter completed
[+] Sorting data
[+] 32 values were loaded and sorted
Thread 0 : Setting up base key: 0000000000000000000000000000000000000000000000000000000000000001
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000001
pubkey: 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
address: 1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000003
pubkey: 02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9
address: 1CUNEBjYrCn2y1SdiUMohaKUi4wpP326Lb
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000007
pubkey: 025cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc
address: 19ZewH8Kk1PDbSNdJ97FP4EiCjTRaZMZQA
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000008
pubkey: 022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01
address: 1EhqbyUMvvs7BfL8goY6qcPbD6YKfPqb7e
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000015
pubkey: 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5
address: 1E6NuFjCi27W5zoXg8TRdcSRq84zJeBW3k
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000031
pubkey: 03f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530
address: 1PitScNLyp2HCygzadCh7FveTnfmpPbfp8
(Output omitted)

metodo rmd160

Todas las address lagacy (Estas empiezan con 1) se pueden buscar también por su hash rmd160 previo al ser convertidas en base58

ejemplo del archivo de entrada:

Código:
751e76e8199196d454941c45d1b3a323f1433bd6
7dd65592d0ab2fe0d0257d571abf032cd9db93dc
5dedfbf9ea599dd4e3ca6a80b333c472fd0b3f69
9652d86bedf43ad264362e6e6eba6eb764508127
8f9dff39a81ee4abcbad2ad8bafff090415a2be8
f93ec34e9e34a8f8ff7d600cdad83047b1bcb45c
e2192e8a7dd8dd1c88321959b477968b941aa973
dce76b2613052ea012204404a97b3c25eac31715
7d0f6c64afb419bbd7e971e943d7404b0e0daab4
d7729816650e581d7462d52ad6f732da0e2ec93b
f8c698da3164ef8fa4258692d118cc9a902c5acc
85a1f9ba4da24c24e582d9b891dacbd1b043f971
f932d0188616c964416b91fb9cf76ba9790a921e
97f9281a1383879d72ac52a6a3e9e8b9a4a4f655
fe7c45126731f7384640b0b0045fd40bac72e2a2
7025b4efb3ff42eb4d6d71fab6b53b4f4967e3dd
b67cb6edeabc0c8b927c9ea327628e7aa63e2d52
ad1e852b08eba53df306ec9daa8c643426953f94
ebfbe6819fcdebab061732ce91df7d586a037dee
b907c3a2a3b27789dfb509b730dd47703c272868
29a78213caa9eea824acf08022ab9dfc83414f56
7ff45303774ef7a52fffd8011981034b258cb86b
d0a79df189fe1ad5c306cc70497b358415da579e
0959e80121f36aea13b3bad361c15dac26189e2f
2f396b29b27324300d0c59b17c3abc1835bd3dbb
bfebb73562d4541b32a02ba664d140b5a574792f
0c7aaf6caa7e5424b63d317f0f8f1f9fa40d5560
1306b9e4ff56513a476841bac7ba48d69516b1da
5a416cc9148f4a377b672c8ae5d3287adaafadec
d39c4704664e1deb76c9331e637564c257d68a08
d805f6f251f7479ebd853b3d0f4b9b2656d92f1d
9e42601eeaedc244e15f17375adb0e2cd08efdc9

Linea de busqueda:

Código:
./keyhunt -m rmd160 -f tests/1to32.rmd -r 1:FFFFFFFF -l compress

En este ejemplo anterior sabemos que las direcciones están comprimidas (Existen adress descomprimidas y comprimidas) esto se debe a que provienen de un public compress o compacto o sin compactar eso lo veremos en otro ejemplo mas adelante.

Ejemplo de salida:

Código:
[+] Version 0.1.20210328
[+] Setting mode rmd160
[+] Search compress only
[+] Opening file tests/1to32.rmd
[+] Allocating memory for 32 elements: 0.00 MB
[+] Initializing bloom filter for 32 elements.
[+] Loading data to the bloomfilter
[+] Bloomfilter completed
[+] Sorting data
[+] 32 values were loaded and sorted
Thread 0 : Setting up base key: 0000000000000000000000000000000000000000000000000000000000000001HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000001
pubkey: 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000003
pubkey: 02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000007
pubkey: 025cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000008
pubkey: 022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000015
pubkey: 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000031
(Output omited)


metodo xpoint

Este metodo permite hacer lo mismo que antes pero busca exclusivamente el valor X de la clave publica, saltándose los costosos pasos de el hash sha256, hash rmd160 y el base58 encode.

Ejemplo del archivo de entrada:

Código:
034eee474fe724cb631d19f24934e88016e4ef2aee80d086621d87d7f6066ff860 # - 453856235784
0274241b684e7c31e7933510b510aa14de9ac88ec3635bdd35a3bcf1d16da210be # + 453856235784
03abc6aff092b9a64bf69e00f4ec7a8b7ca51cfc6656732cbbc9f5674925b88609 # - 529328067324
034f4fe33b02c202b732d278f90eedc635af6f3be8a93c8d1cb0a01f6399aab2a4 # + 529328067324
03716ff57705e6446ac3e217c8c8bd9e9c8e58547457a6fe93ac254c37fd48afcb # - 14711740067
02ffa0769b0459c64b41f59f93495063ae031de0b846180bee37f921f20e141f60 # + 14711740067
03de1df5d801bbd5e7d86577bf14950f732fd41e586945d06d19e0fdea41a37d62 # - 549755814000
038d3711fd681e26c05b2f0cd423fa596e15054024e40add24a93bfa0c630531f1 # + 549755814000
03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4 # target


El primer valor es la llave publica comprimida o compacta, el segundo valor es un offset, esto es debido a que podemos crear varias copias de una llave publica a diferentes distancia de la misma, tal vez no conoceremos el valor de la privatekeys pero si podemos realizar varias operaciones matemáticas con los valores de las llaves publicas en este caso son valores que se encuentran sumándole o restándole otras llaves publicas con valores ya conocidos, en caso de encontrar alguna de las copias solo es cuestión de hacer sumas o restas para encontrar el valor de la llave original.

Ejemplo de lineal de ejecución:

Código:
./keyhunt -m xpoint -f tests/substracted40.txt -n 65536 -t 4 -b 40

En este caso especificamos que el area de busqueda sea en el bit numero 40 ya que los valores mostrados fueron estrados o sumados apartir del publickey del puzzle numero 40.

Ejemplo de salida:

Código:
[+] Version 0.1.20210330a
[+] Setting mode xpoint
[+] Setting 4 threads
[+] Min range: 8000000000
[+] Max range: ffffffffff
[+] Opening file tests/substracted40.txt
[+] Allocating memory for 6003 elements: 0.11 MB
[+] Initializing bloom filter for 6003 elements.
[+] Loading data to the bloomfilter
[+] Bloomfilter completed
[+] Sorting data
[+] 6003 values were loaded and sorted
Thread 3 : Setting up base key: 0000000000000000000000000000000000000000000000000000008001d00000
Thread 0 : Setting up base key: 00000000000000000000000000000000000000000000000000000080025b0000
HIT!! PrivKey: 000000000000000000000000000000000000000000000000000000800258a2ce
pubkey: 0274241b684e7c31e7933510b510aa14de9ac88ec3635bdd35a3bcf1d16da210be
Thread 1 : Setting up base key: 0000000000000000000000000000000000000000000000000000008002910000^C

Este es un ejemplo basico para obtener la llave privada orignal tenemos que sumarle a 800258a2ce hexadecimal el valor de + 453856235784 (decimal) en este caso el resultado es E9AE4933D6

El puzzle por ser resulto actualmente es de 120 bits y he utilizado este método y otros mas aun sin tener suerte aun

Metodo pub2rmd

Este método lo que hace es buscar por fuerza bruta la llave publica de address o hashes específicos, esto es util por que de conocer la llave publica de una dirección de los puzzles de 64, 65 y varios menores que 100 bits podremos fácilmente resolverlos.

La ventaja es que puedes puedes buscar al mismo tiempo la llave publica de todas las direcciones sin clave publica conocida.
La desventaja es que tiene la misma complejidad de encontrar una clave privada de 256 bits (prácticamente imposible en nuestro tiempo de vida)

Ejemplo de entrada:

Código:
3ee4133d991f52fdf6a25c9834e0745ac74248a4
20d45a6a762535700ce9e0b216e31994335db8a5
739437bb3dd6d1983e66629c5f08c70e52769371
e0b8a2baee1b77fc703455f39d51477451fc8cfc
61eb8a50c86b0584bb727dd65bed8d2400d6d5aa
f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8
bf7413e8df4e7a34ce9dc13e2f2648783ec54adb
105b7f253f0ebd7843adaebbd805c944bfb863e4
9f1adb20baeacc38b3f49f3df6906a0e48f2df3d
86f9fea5cdecf033161dd2f8f8560768ae0a6d14
783c138ac81f6a52398564bb17455576e8525b29
35003c3ef8759c92092f8488fca59a042859018c
67671d5490c272e3ab7ddd34030d587738df33da
351e605fac813965951ba433b7c2956bf8ad95ce
20d28d4e87543947c7e4913bcdceaa16e2f8f061
24cef184714bbd030833904f5265c9c3e12a95a2
7c99ce73e19f9fbfcce4825ae88261e2b0b0b040
c60111ed3d63b49665747b0e31eb382da5193535
fbc708d671c03e26661b9c08f77598a529858b5e
38a968fdfb457654c51bcfc4f9174d6ee487bb41
5c3862203d1e44ab3af441503e22db97b1c5097e
9978f61b92d16c5f1a463a0995df70da1f7a7d2a
6534b31208fe6e100d29f9c9c75aac8bf06fbb38
463013cd41279f2fd0c31d0a16db3972bfffac8d
c6927a00970d0165327d0a6db7950f05720c295c
2da63cbd251d23c7b633cb287c09e6cf888b3fe4
578d94dc6f40fff35f91f6fba9b71c46b361dff2
7eefddd979a1d6bb6f29757a1f463579770ba566
c01bf430a97cbcdaedddba87ef4ea21c456cebdb

Código:
./keyhunt -m pub2rmd -f tests/puzzleswopublickey.txt -q

Ejemplo de salida:

Código:
[+] Version 0.1.20210331
[+] Setting mode pub2rmd
[+] Set quiet thread output
[+] Opening file tests/puzzleswopublickey.txt
[+] Allocating memory for 29 elements: 0.00 MB
[+] Initializing bloom filter for 29 elements.
[+] Loading data to the bloomfilter total: 0.00 MB
[+] Bloomfilter completed
[+] Sorting data
[+] 29 values were loaded and sorted
Total 76546048 keys in 90 seconds: 850511 keys/s

metodo bsgs

Las siglas de este método son por baby step giant step y es un metodo bastate veloz para buscar llaves privadas. Ejemplo de entrada:

Código:
043ffa1cc011a8d23dec502c7656fb3f93dbe4c61f91fd443ba444b4ec2dd8e6f0406c36edf3d8a0dfaa7b8f309b8f1276a5c04131762c23594f130a023742bdde # 0000000000000000000000000000000000800000000000000000100000000000
046534b9e9d56624f5850198f6ac462f482fec8a60262728ee79a91cac1d60f8d6a92d5131a20f78e26726a63d212158b20b14c3025ebb9968c890c4bab90bfc69 # 0000000000000000000000000000000000800000000000000000200000000000

Linea de ejecucion:

Código:
./keyhunt -m bsgs -f tests/test120.txt -b 120


Ejemplo de salida:

Código:
[+] Version 0.1.20210328
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Opening file tests/test120.txt
[+] Added 2 points from file
[+] Bit Range 120
[+] Setting N up to 17592186044416.
[+] Init 1st bloom filter for 4194304 elements : 14.00 MB
[+] Init 2nd bloom filter for 209716 elements : 0.00 MB
[+] Allocating 128.0 MB for 4194304 aMP Points
[+] Precalculating 4194304 aMP points
[+] Allocating 3.00 MB for 209716 bP Points
[+] processing 4194304/4194304 bP points : 100 %
[+] Sorting 209716 elements
[+] Thread 0: 0000000000000000000000000000000000800000000000000000000000000000
[+] Thread 0 Key found privkey 0000000000000000000000000000000000800000000000000000100000000000
[+] Publickey 043ffa1cc011a8d23dec502c7656fb3f93dbe4c61f91fd443ba444b4ec2dd8e6f0406c36edf3d8a0dfaa7b8f309b8f1276a5c04131762c23594f130a023742bdde
[+] Thread 0: 0000000000000000000000000000000000800000000000000000100000000000
Total 17592186044416 keys in 30 seconds: 586406201480 keys/s
[+] Thread 0 Key found privkey 0000000000000000000000000000000000800000000000000000200000000000
[+] Publickey 046534b9e9d56624f5850198f6ac462f482fec8a60262728ee79a91cac1d60f8d6a92d5131a20f78e26726a63d212158b20b14c3025ebb9968c890c4bab90bfc69
All points were found

La ventaja de este metodo es que la velocidad del mismo esta dada por la cantidad de RAM, con algunos cuantos Gigabytes de RAM puedes igualar la velocidad de búsqueda de varias tarjetas de video potentes y en general la memoria RAM es mas barata que las Tarjetas de video, adicionalmente consume menos electricidad.

Llave publica del puzzle 120

Código:
02CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630

Lineal de ejecución:

Código:
./keyhunt -m bsgs -f tests/120.txt -b 120 -R

El -b 120 es para indicar que el rango es el el bit 120 de 800000000000000000000000000000 a ffffffffffffffffffffffffffffff hexadecimal

y el -R es para que la búsqueda sea aleatoria.

Ejemplo buscando el privatekey a una valocidad de 5.2 Petakeys/s

Código:
./keyhunt -m bsgs -f tests/120.txt -b 120 -R -k 1024 -q -p ./bPfile.bin -t 6

Salida:

Código:
[+] Version 0.1.20210328
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Setting random mode.
[+] Setting k factor to 1024
[+] Set quiet thread output
[+] Setting 6 threads
[+] Opening file tests/120.txt
[+] Added 1 points from file
[+] Bit Range 120
[+] Setting N up to 17592186044416.
[+] Init 1st bloom filter for 4294967296 elements : 14722.00 MB
[+] Init 2nd bloom filter for 214748365 elements : 736.00 MB
[+] Allocating 0.0 MB for 4096 aMP Points
[+] Precalculating 4096 aMP points
[+] Allocating 3276.00 MB for 214748365 bP Points
[+] Reading 4294967296 bP points from file ./bPfile.bin
[+] processing 4294967296/4294967296 bP points : 100 %
[+] Sorting 214748365 elements
Total 157238958864990208 keys in 30 seconds: 5241298628833006 keys/s

Estoy por liberar una versión que funcionara de 3 a 5 veces mas rápido
También estoy probando utilizar el bloomfilter directamente en disco NVMe utilizando de 1 a 2 TB solo para ver que velocidad obtengo.
Y por ultimo estoy haciendo una versión POOL para poder compartir poder de computo y dividir el trabajo entre varios clientes esto obviamente dividiendo el balance en caso de encontrar los puzzles.


Saludos!
10  Seguridad Informática / Criptografía / Paridad de un punto en Curvas Elipticas Criptograficas en: 27 Febrero 2021, 09:08 am
Quisiera abrir el siguiente hilo para saber si es posible determinar la paridad de un punto en una curva Eliptica utilizada en criptografía.

Encontré un video en youtube donde un programador de C# afirma tener la formula para determinar si un punto dado es par o impar para una curva en especifico.

Tiene una pagina

:http://remon78eg.tk/curve/mod2/

Utiliza un valor P custom: 115792089237316195423570985008687907853269984665640564039457584007908834675927

El cual afirma que es un valor débil o vulnerable.

El usuario no revela mucho de su método o test de paridad de un punto o publickey.

Las preguntas aquí son las siguientes:
¿Qué tiene de débil o vulnerable su orden de la curva?
¿Cuál seria el test de paridad que se pueda implementar para determinar si un punto (X,Y) pertenece a una privatekey par o impar?

Saludos!
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 18
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines