En este Post entederemos como crear, gestionar y como funciona una unidad 100% encruptada y tambien veremos la importancia de rellenar dichas unidades con Datos aleatorios previos a su uso.

Primero vamos a ver un ejemplo de como se visualizan los datos encryptados y como se ven en Texto Plano

Vamos a crear un arhivo de 32 Megabytes para realizar una prueba, esto si lo quieren replicar pueden utilizar el tamaño que ustedes quieran.

Para realizar esto vamos a utilizar el comando dd y para que se vea claramente cuales datos estan encryptados y cuales no se utilizara como relleno del archivo /dev/zero


Listamos que nuestro archivo este creado y que tenga el peso adecuado


verificamos que nuestro archivo este llenos de Zeros para este ejemlo



Realize un programa que indica el nivel de entropia de Shannon para cada cantidad bytes en el archivo


Por ejemplo si llenamos el primer Megabyte del archivo con Datos aleatorios



La salida se vera asi:


Como ven solo el primer chunk cambia a una entropia de casi 8 que para este caso es la mas alta.



Ahora proceremos a formatear nuestro archivo como un archivo LUKS


Nos pedira ingresar YES en mayusculas y nuestra contraseña 2 veces para verificar que este correcta

Si ahora utilizamos file y hexedit vermos lo siguiente:


Como vemos ahora ya tiene un header
Vamos a ver como quedo la entropia de este ejemplo


para este caso vemos que el primer chunk tiene entropia de 7.93 y los siguientes 15 casi de 7.99 Esto se debe que luksFormat rellena los primer 16 MB con data aleatoria
Estos primer 16 MB estan reservados para los slots de llaves que pueden desencryptar el disco.
Y solo el primer chunk tiene algunos bytes en Zero por eso tiene una menor entropia que los 15 anteriores.

Con el comando que tengo podemos pedir que los chunks sean de 32 Kilobytes esto es 32768 bytes



Si vemos solo el primer chunk de 32 KB tiene una entropia de casi Cero y los demas chunks tienen entropia de 7.99 (Esto es random data)

Volviendo a los Chunks de 1 MB notaremos que los chunks del 17 al 32 vemos que estos siguen con entropia de Zero ya que estos actualmente tienen el relleno original de /dev/zero

Podremos ver esto con hexedit al offset 0x01000000



Como vemos apartir del offset 0x01000000 comienza todo Zeros tal como lo esperamos...

Ahora procederemos a generar el device descifrado y comenzar a ver como se ven los datos cuando estos comienzan a ser encryptados




Validamos que nuestro nuevo device este en /dev/mapper con

Primero listamos la entropia actual del nuevo device


Vamos a proceder a editar Un mensaje, digamos "hola mundo" y visualizaremos como se ve los dato cifrados:


Y ahora vemos el archivo encrypted_data.dat en el offset 0x01000000


Como vemos apartir de offset 0x01000000 de nuestro archivo vemos que ya se van editando los datos conforme nosotros editamos el archivo

Aqui he simplificado burdamente y edite directamente sobre el device /dev/mapper/encrypted_data, lo ideal es darle un formato para almacenar achivos y montar la unidad para utilizarlo como si se tratara de otra unidad de discos.

Ahora hay que notar que Si alguien tiene acceso al archivo encrypted_data.dat podran facilmente determinar cuanto hemos escrito viendo la cantidad de entropia apartir de offset 01000000

Como evitamos esto, Facil necesitamos sobre escribir todo el /dev/mapper/encrypted_data previo a la formateada, podremos sobre escribir todo con /dev/zero o con /dev/urandom

Mi recomendacion en este caso es hacerlo con /dev/urandom con esto lograremos que tanto encrypted_data.dat y /dev/mapper/encrypted_data Esten ambos con entropia al maximo en un estado inicial.

Corremos el comando



Con esto lo que hemos hecho es que toda la informacion random que entro /dev/mapper/encrypted_data se escribe en tiempo real de forma encryptada en encrypted_data.dat

Y si listamos la entropia en ambos archivo encrypted_data.dat y /dev/mapper/encrypted_data



Vemos que ya muestra entropia de casi 8 para todo

Entonces ahora que ya tenemos el archivo con Alta entropia en el device /dev/mapper/encrypted_data y para el archivo encrypted_data.dat

Podemos proceder a formatear /dev/mapper/encrypted_data con algun formato que nos guste, por ejemplos ext3 o ext4, vfat o el que sea de su eleccion


Ahora ya con el device formateado procedemos a crear un punto de montaje

sudo mkdir -p /mnt/encrypted_data

Lo montamos ahi


Y ahora si podremos guardar toda la informacion completamente encryptada en dicha unidad


Recordar desmontar su unidad con


Y cerrar el device con


Con este ultimo desaparece /dev/mapper/encrypted_data y todos los cambios que hicimos ya deberian de estar guardo encryptados en nuestro archivo encrypted_data.dat

Ahora solo queda tener una buena escusa para tener archivo llenos de "random"

Para ello publicare un post al respecto.

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:

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:


Luego


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


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


Listar llaves publicas


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


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:

Exportar tu llave publica o la de alguien mas


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


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

signed_message.txt

Verificar un mensaje de texto firmado


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


Haz caso omiso del warning lo que nos interesa es:


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


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


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


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

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:

---

Mensaje de usuario Bob:

Llave de Alice verificada.

Hola tengo una pequeña duda de que alternativa utilizar a la función hash_pbkdf2 de PHP en javascript.

Ejemplo en PHP

<?php
	$salt = hex2bin("0123456789ABCDEF0123456789ABCDEF");
	$secret = hash_pbkdf2("sha512","secret",$salt,200000,0,false);
	echo "$secret\n";
?>
 

Salida:

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

function test()	{
	salt = hexToBytes("0123456789ABCDEF0123456789ABCDEF");
	password = "secret"
	secret = CryptoJS.PBKDF2(CryptoJS.enc.Utf8.parse(password), CryptoJS.enc.Utf8.parse(salt), { keySize: 512 / 32, iterations: 200000, hasher: CryptoJS.algo.SHA512});
	console.log(secret);
}

Salida

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!

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

s.trim()

PHP

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...

import base64
base64_bytes = base64.b64encode(message_bytes)
 

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!

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:


Llaves de Bob para el ejemplo:

Alicia ejecuta el programa:


Bob ejecuta el programa


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


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

---

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!

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:


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

do{
//CODIGO
}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:

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:

	for(contadores[0] = 0; contadores[0] < strlen(doubt_possibles[0]) ; contadores[0]++)	{
		current_string[doubt_locations[0]] = doubt_possibles[0][contadores[0]];
		for(contadores[1] = 0; contadores[1] < strlen(doubt_possibles[1]) ; contadores[1]++)	{
			current_string[doubt_locations[1]] = doubt_possibles[1][contadores[1]];
			for(contadores[2] = 0; contadores[2] < strlen(doubt_possibles[2]) ; contadores[2]++)	{
				current_string[doubt_locations[2]] = doubt_possibles[2][contadores[2]];
				//Otro Codigo
				do{
					//CODIGO				
				}while(increment_base58(current_string,aux));
			}
		}
	}
 

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:

do{ //Do para los "?" en lugar de tanto for....
	do{ // Do para los "*"
		//CODIGO				
	}while(increment_base58(current_string,aux));		
}while(magic_function(current_string,aux2));
 

Es decir como codificarian "magic_function"

bool magic_function(char *current_string,int aux2){
// Que hay aqui?
}
 

#if 0
//Code
#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

#if 0
      pp.y.ModSub(&Gn[i].x,&pp.x);
      pp.y.ModMulK1(&_s);
      pp.y.ModSub(&Gn[i].y);           // ry = - p2.y - s*(ret.x-p2.x);  
#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

#include<stdio.h>
 
int main(){
	int  i = 10;
	printf("%i\n",i);
#if 0
	 i = 200;
#endif
	printf("%i\n",i);
}

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

Saludos!

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:


Ejemplo de ejecucion:


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:


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:


Linea de busqueda:


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:



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:



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:


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:


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:



Ejemplo de salida:


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:


Linea de ejecucion:



Ejemplo de salida:


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


Lineal de ejecución:


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


Salida:


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!

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!