Código de Python - Elíptica_Criptografía

Filtrado por el tag: Array
<<>>
Imágen de perfil

Elíptica_Criptografíagráfica de visualizaciones


Python

Publicado el 27 de Noviembre del 2024 por Hilario (144 códigos)
582 visualizaciones desde el 27 de Noviembre del 2024
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Figure_1

---------------------------------------------------------------------------------------------------------------------------

Captura-de-pantalla-de-2024-11-27-12-07-57

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


Aula_28_Nov_Eliptica_Criptografia.py
+++++++++++++++++++++++++++++




Dentro de todas las partes, digamos, técnologicas, que hemos ido estudiando y procesando. Comenzamos un tema nuevo,
para el que seguiremos utilizando el lengua Python, y un sistema operativo basado en linux.
Nos adentramos en el mundo de la criptografía y de las claves, en principio, en los sistemas más utilizados
por el secure shel SSH, en principio con un ejemplo sencillo, que intentaré explicar lo mejor posible.
Como siempre, en nuestras sucesivas clases de técnología iremos aclarando las dudas que surjan, lo que supondrá, como siempre
ocurre en nuestras clases, profundizar mucho más sobre el tema. Os pido, que dentro de lo posible, intenteis razonar el código.
Luego ya aclararemos todo lo que surja, pero es más fácil su comprensión si llevamos, digamos, trillado, un poco de lo que se trata.

EMPECEMOS:
++++++++++++++

-¿Qué es una curva elíptica?
Una curva elíptica es una curva matemática que tiene la forma general:
y2=x3+ax+b (Ya sabeis, y elevado a 2, igual a x elevado a 3, más a por x, más b)
Esta curva tiene propiedades interesantes que se aprovechan en criptografía para generar claves. En criptografía de curvas elípticas (ECC, por sus siglas en inglés), usamos puntos sobre esta curva para construir un sistema de claves.


¿Cómo se construyen las claves con una curva elíptica?
1. Selección de la curva elíptica:
◦ Primero, se elige una curva elíptica específica. La ecuación y2=x3+ax+b tiene parámetros como a, b, y un número primo p que define el campo finito (es decir, trabajamos con números que están "limitados" por un número p).
◦ Un ejemplo común de curva elíptica es la curva secp256k1, que se usa en Bitcoin.

2. Punto generador (G):
◦ Sobre la curva elíptica, hay un punto generador G que es un punto específico de la curva, que se conoce de antemano. Este punto sirve para generar las claves.

3. Clave privada:
◦ La clave privada es un número aleatorio que se elige de manera segura. Es como una "semilla" que vamos a usar para generar la clave pública.
◦ Este número privado es secreto, y nunca se debe compartir.

4. Clave pública:
◦ La clave pública se genera multiplicando el punto generador G por el número privado (clave privada). Esto se hace mediante una operación llamada multiplicación escalar.
◦ Matemáticamente, si tienes una clave privada k, la clave pública P es: P=k⋅G
◦ Aquí, P es un nuevo punto sobre la curva que depende de k y G. Es casi imposible calcular k solo a partir de P, lo que hace la curva elíptica segura para su uso en criptografía.

5. Uso en criptografía:
◦ En criptografía de clave pública, puedes usar la clave pública para verificar la autenticidad de un mensaje o para cifrar datos.
◦ Solo la persona que tiene la clave privada puede descifrar los datos o firmar mensajes, porque se necesita la clave privada para generar la firma o descifrar.

Ejemplo práctico en criptografía
Imagina que quieres enviar un mensaje seguro a alguien:
1. La otra persona te envía su clave pública.
2. Tú usas esa clave pública para cifrar el mensaje.
3. La otra persona usa su clave privada para descifrarlo.
Y cuando firmes un mensaje:
1. Usas tu clave privada para firmar el mensaje (de forma que solo tú puedas hacerlo).
2. Cualquier persona que tenga tu clave pública puede verificar que la firma es auténtica y que no ha sido modificada.

¿Por qué es segura?
La seguridad de este sistema se basa en que, aunque la multiplicación escalar de un número por un punto en la curva es fácil de hacer, el proceso inverso (saber la clave privada a partir de la clave pública) es extremadamente difícil. Este problema se llama el problema del logaritmo discreto, y es la base de la seguridad de las curvas elípticas.

En fin, alumnos, resumiendo:
1. Clave privada: Número secreto que eliges.
2. Clave pública: Punto en la curva generado a partir de la clave privada.
3. Suma de puntos: Usada para multiplicar el punto generador G para obtener la clave pública.
4. Seguridad: Es muy difícil calcular la clave privada a partir de la clave pública.


Este enfoque se usa en criptografía moderna para asegurar comunicaciones y transacciones, como en Bitcoin o en protocolos TLS/SSL para la navegación segura por Internet.
----------------------------------------------------------------------------------------------------------------------------------

Bien, después de esta pequeña introducción, que ampliaremos en clase, la próxima semana y sucesivas, vamos con algo más práctico:

1. Representación gráfica de la curva elíptica.
---------------------------------------------------------------
El programa comienza generando una gráfica de la curva elíptica definida por y2=x3+8x+12 sobre los números reales:
• Cálculo de y2:
La ecuación se evalúa para valores de x en un rango definido [−10,10] para obtener los valores de y2.
• Raíces cuadradas positivas y negativas:
La raíz cuadrada de y2 se toma tanto positiva como negativa (y=±y2​) para trazar ambas ramas de la curva.
• Visualización:
Usa matplotlib para graficar las ramas positiva y negativa en colores distintos. También incluye líneas de referencia para los ejes x e y, junto con una cuadrícula para mejorar la legibilidad.
Propósito:
Este gráfico permite entender visualmente la forma de una curva elíptica sobre los números reales antes de trabajar con el caso modular (campo finito).

2. Implementación de una curva elíptica modular (campo finito pequeño)
-------------------------------------------------------------------------------------------------------
En esta sección, se define una clase EllipticCurve para manejar operaciones básicas en una curva elíptica sobre un campo finito

Fp​:
• Parámetros de la curva:
La curva está definida por y2=x3+ax+bmodp, donde:
◦ a=8, b=12, y p=97 (un número primo que define el campo).
• Validación de singularidades:
Verifica que la curva no sea singular usando la condición 4a3+27b2=0modp.

• Operaciones básicas:
◦ Pertenencia a la curva: Verifica si un punto (x,y) está en la curva.
◦ Suma de puntos: Implementa la adición de puntos, considerando casos como:
▪ P+O=P (punto identidad).
▪ Suma de puntos distintos.
▪ Duplicación de un punto (derivada de la tangente).
◦ Multiplicación escalar: Repite la suma k⋅P usando el algoritmo de duplicación y adición.

• Generación de claves:
◦ Se generan todos los puntos válidos en la curva para el campo F97​.
◦ Selecciona un punto generador G (el primero de la lista).
◦ La clave privada es un entero aleatorio entre 1 y p−1.
◦ La clave pública es el resultado de k⋅G, donde k es la clave privada.

Resultados:
Imprime:
• La ecuación de la curva modular.
• El punto generador G.
• Las claves privada y pública generadas.

3. Criptografía realista con secp256k1
Esta sección introduce una curva elíptica de uso práctico en criptografía, secp256k1, utilizada por Bitcoin:
• Definición:
La curva está definida por y2=x3+7modp, donde:
◦ p es un número primo grande (2256−232−977).
◦ G es un punto generador predeterminado en la curva.
◦ n es el orden del punto generador.
• Operaciones similares:
Implementa las mismas operaciones (pertenencia, suma de puntos, multiplicación escalar) adaptadas a los parámetros de secp256k1.
• Generación de claves:
◦ La clave privada es un número aleatorio de hasta 256 bits (1≤k<n).
◦ La clave pública es k⋅G, donde G y n aseguran un espacio de claves inmenso y seguridad criptográfica.
Resultados:
Muestra:
• La ecuación de secp256k1.
• El punto generador G.
• Las claves privada y pública.


Como véis, queridos alumnos, el propósito formativo del programa es:
++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++
1. Introducción visual a las curvas elípticas:
La gráfica inicial ayuda a entender cómo luce una curva elíptica y su simetría sobre los números reales.
2. Conceptos básicos de curvas elípticas en campos finitos:
◦ Explica cómo las curvas se definen y operan en un espacio modular, con un ejemplo simple (p=97).
◦ Introduce operaciones críticas como suma de puntos y multiplicación escalar.
3. Aplicación práctica en criptografía:
◦ Usa una curva criptográfica estándar (secp256k1) para mostrar cómo generar claves privadas y públicas.
◦ Destaca las diferencias entre un ejemplo educativo y un caso práctico con parámetros reales.

Bien, y como posibles mejoras, vamos a implementar lo siguiente:
---------------------------------------------------------------
• Implementar firmas digitales (ECDSA) como extensión práctica.
• Mostrar cómo la clave pública se convierte en un formato útil (como direcciones en Bitcoin).
• Incluir explicaciones más detalladas sobre seguridad y resistencia frente a ataques.


Comoos lo expuesto, tengo por sentado que os resultará un tanto farragoso, deseo que, como ya dije, comencéis su estudio-
Iremos puliendo dudas, y asentando conceptos los próximos días.



///////////////////////////////////////////////////////////////////////////
Como casi todos los ejercicios, este fue realizado, bajo una plataforma Linux,
en concreto con Ubuntu 20.04.6 LTS.
Fue editado con Sublime Text.
Se utilizó, Python3.
Y como smpre indico, se deberán de tener cargadas en el sistema, todas las librerias
que el código pide importar para su ejecucucíon.

Comando de ejecucuón bajo consola linux:

python3 Aula_28_Nov_Eliptica_Criptografia.py

Requerimientos

Como casi todos los ejercicios, este fue realizado, bajo una plataforma Linux,
en concreto con Ubuntu 20.04.6 LTS.
Fue editado con Sublime Text.
Se utilizó, Python3.
Y como smpre indico, se deberán de tener cargadas en el sistema, todas las librerias
que el código pide importar para su ejecucucíon.

Comando de ejecucuón bajo consola linux:

python3 Aula_28_Nov_Eliptica_Criptografia.py

v-0

Actualizado el 7 de Diciembre del 2024 (Publicado el 27 de Noviembre del 2024)gráfica de visualizaciones de la versión: v-0
583 visualizaciones desde el 27 de Noviembre del 2024
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#Ejecución bajo consola linux
#python3  Aula_28_Nov_Eliptica_Criptografia.py
 
import numpy as np
import matplotlib.pyplot as plt
import random
import hashlib
 
# ----- GRÁFICA DE LA CURVA ELÍPTICA -----
# Definir los parámetros de la nueva ecuación
a = 8
b = 12
x = np.linspace(-10, 10, 1000)
 
# Calcular los valores de y^2
y_squared = x**3 + a * x + b
 
# Calcular las ramas positivas y negativas de y
y_positive = np.sqrt(np.maximum(y_squared, 0))
y_negative = -y_positive
 
# Crear la gráfica
plt.figure(figsize=(8, 6))
plt.plot(x, y_positive, label='y = +sqrt(+ 8x + 12)', color='blue')
plt.plot(x, y_negative, label='y = -sqrt(+ 8x + 12)', color='red')
plt.axhline(0, color='black', linewidth=0.8, linestyle='--')
plt.axvline(0, color='black', linewidth=0.8, linestyle='--')
plt.title(r'Gráfica de $y^2 = x^3 + 8x + 12$')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(alpha=0.5)
plt.show()
 
# ----- CLASE CURVA ELÍPTICA -----
class EllipticCurve:
    def __init__(self, a, b, p):
        self.a = a
        self.b = b
        self.p = p
 
        # Verificar que la curva sea válida
        if (4 * a**3 + 27 * b**2) % p == 0:
            raise ValueError("La curva no es válida (tiene singularidades).")
 
    def is_on_curve(self, x, y):
        """Verifica si el punto (x, y) está en la curva."""
        return (y**2 - (x**3 + self.a * x + self.b)) % self.p == 0
 
    def point_addition(self, P, Q):
        """Suma de dos puntos en la curva."""
        if P is None:
            return Q
        if Q is None:
            return P
 
        x1, y1 = P
        x2, y2 = Q
 
        if x1 == x2 and y1 != y2:
            return None
 
        if P == Q:
            m = (3 * x1**2 + self.a) * pow(2 * y1, -1, self.p)
        else:
            m = (y2 - y1) * pow(x2 - x1, -1, self.p)
 
        m %= self.p
        x3 = (m**2 - x1 - x2) % self.p
        y3 = (m * (x1 - x3) - y1) % self.p
        return (x3, y3)
 
    def scalar_multiplication(self, k, P):
        """Multiplicación escalar: k * P."""
        Q = None
        while k:
            if k & 1:
                Q = self.point_addition(Q, P)
            P = self.point_addition(P, P)
            k >>= 1
        return Q
 
# ----- PARÁMETROS DE LA CURVA secp256k1 -----
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
a = 0
b = 7
G = (
    0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,  # x
    0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8   # y
)
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141  # Orden del grupo
 
curve = EllipticCurve(a, b, p)
 
# Generar clave privada y clave pública
private_key = random.randint(1, n - 1)
public_key = curve.scalar_multiplication(private_key, G)
 
print("Curva elíptica: y^2 = x^3 + {}x + {} (mod {})".format(a, b, p))
print("Clave privada:", private_key)
print("Clave pública:", public_key)
 
# ----- FIRMA DIGITAL (ECDSA) -----
def sign_message(private_key, message):
    """Genera una firma para el mensaje usando ECDSA."""
    z = int(hashlib.sha256(message.encode()).hexdigest(), 16) % n
    r = s = 0
    while r == 0 or s == 0:
        k = random.randint(1, n - 1)
        x, _ = curve.scalar_multiplication(k, G)
        r = x % n
        k_inv = pow(k, -1, n)
        s = (k_inv * (z + r * private_key)) % n
    return r, s
 
def verify_signature(public_key, message, signature):
    """Verifica la firma de un mensaje usando ECDSA."""
    r, s = signature
    if not (1 <= r < n and 1 <= s < n):
        return False
    z = int(hashlib.sha256(message.encode()).hexdigest(), 16) % n
    s_inv = pow(s, -1, n)
    u1 = (z * s_inv) % n
    u2 = (r * s_inv) % n
    P = curve.point_addition(
        curve.scalar_multiplication(u1, G),
        curve.scalar_multiplication(u2, public_key)
    )
    if P is None:
        return False
    x, _ = P
    return r == x % n
 
# Ejemplo de firma
message = "Este es un mensaje seguro"
signature = sign_message(private_key, message)
print("Mensaje:", message)
print("Firma:", signature)
 
# Verificación de firma
is_valid = verify_signature(public_key, message, signature)
print("¿Firma válida?", is_valid)



Comentarios sobre la versión: v-0 (0)


No hay comentarios
 

Comentar la versión: v-0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s7545