En criptografía , una firma en anillo es un tipo de firma digital que puede realizar cualquier miembro de un conjunto de usuarios, cada uno de los cuales tiene claves . Por lo tanto, un mensaje firmado con una firma en anillo está respaldado por alguien de un grupo particular de personas. Una de las propiedades de seguridad de una firma en anillo es que debería ser computacionalmente inviable determinar cuál de las claves de los miembros del conjunto se utilizó para producir la firma. Las firmas en anillo son similares a las firmas de grupo , pero difieren en dos aspectos clave: primero, no hay forma de revocar el anonimato de una firma individual; y segundo, cualquier conjunto de usuarios se puede utilizar como conjunto de firma sin configuración adicional.
Las firmas de anillo fueron inventadas por Ron Rivest , Adi Shamir y Yael Tauman Kalai , y se introdujeron en ASIACRYPT en 2001. [1] El nombre, firma de anillo , proviene de la estructura similar a un anillo del algoritmo de firma .
Supongamos que un conjunto de entidades tiene pares de claves pública/privada, ( P 1 , S 1 ), ( P 2 , S 2 ), ..., ( P n , S n ). La parte i puede calcular una firma de anillo σ en un mensaje m , en la entrada ( m , Si , P 1 , ..., P n ). Cualquiera puede verificar la validez de una firma de anillo dadas σ, m y las claves públicas involucradas, P 1 , ..., P n . Si una firma de anillo se calcula correctamente, debería pasar la verificación. Por otro lado, debería ser difícil para cualquiera crear una firma de anillo válida en cualquier mensaje para cualquier conjunto sin conocer ninguna de las claves privadas de ese conjunto. [2]
En el artículo original, Rivest, Shamir y Tauman describieron las firmas de anillos como una forma de filtrar un secreto. Por ejemplo, se podría utilizar un anillo de firma para proporcionar una firma anónima de "un funcionario de alto rango de la Casa Blanca ", sin revelar qué funcionario firmó el mensaje. Las firmas en anillo son adecuadas para esta aplicación porque el anonimato de una firma en anillo no se puede revocar y porque el grupo de una firma en anillo se puede improvisar.
Otra aplicación, también descrita en el documento original, es la de firmas negables. Aquí el remitente y el destinatario de un mensaje forman un grupo para la firma en anillo, luego la firma es válida para el destinatario, pero cualquier otra persona no estará segura de si el destinatario o el remitente fue el firmante real. Por tanto, dicha firma es convincente, pero no puede transferirse más allá de su destinatario previsto.
Fueron diversos trabajos, introduciendo novedades y partiendo de diferentes supuestos:
La mayoría de los algoritmos propuestos tienen un tamaño de salida asintótico ; es decir, el tamaño de la firma resultante aumenta linealmente con el tamaño de la entrada (número de claves públicas). Eso significa que tales esquemas son impracticables para casos de uso reales con un tamaño suficientemente grande (por ejemplo, una votación electrónica con millones de participantes). Pero para algunas aplicaciones con un tamaño de entrada mediano relativamente pequeño , dicha estimación puede ser aceptable. CryptoNote implementa un esquema de firma en anillo de Fujisaki y Suzuki [5] en pagos p2p para lograr la imposibilidad de rastrear al remitente.
Recientemente han aparecido algoritmos más eficientes. Existen esquemas con tamaño sublineal de la firma, [6] así como con tamaño constante. [7]
El artículo original describe un esquema de firma de anillo basado en RSA , así como uno basado en firmas Rabin . Definen una "función de combinación" con clave que toma una clave , un valor de inicialización y una lista de valores arbitrarios . se define como , donde es una función de trampilla (es decir, una clave pública RSA en el caso de firmas de anillo basadas en RSA).
La función se llama ecuación de anillo y se define a continuación. La ecuación se basa en una función de cifrado simétrica :
Genera un valor único que se fuerza a ser igual a . La ecuación se puede resolver siempre que al menos uno , y por extensión , pueda elegirse libremente. Según los supuestos de RSA, esto implica el conocimiento de al menos una de las funciones inversas de las funciones de la trampilla (es decir, una clave privada), ya que .
Generar una firma de anillo implica seis pasos. El texto plano se indica con , las claves públicas del anillo con .
La verificación de firma implica tres pasos.
Aquí hay una implementación de Python del artículo original usando RSA . Requiere el módulo PyCryptodome de terceros.
importar sistema operativo importar hashlib importar aleatoriamente importar Crypto.PublicKey.RSAimportar funciones Anillo de clase : """Implementación RSA.""" def __init__ ( self , k , L : int = 1024 ) -> Ninguno : self . k = k yo . l = L yo . n = len ( k ) uno mismo . q = 1 << ( L - 1 ) def sign_message ( self , m : str , z : int ): self . _permut ( m ) s = [ Ninguno ] * self . norte tu = aleatorio . randint ( 0 , self . q ) c = v = self . _UE ) primer_rango = lista ( rango ( z + 1 , self . n )) segundo_rango = lista ( rango ( z )) rango_completo = primer_rango + segundo_rango para i en todo el rango : s [ i ] = aleatorio . randint ( 0 , self . q ) e = self . _g ( s [ i ], self . k [ i ] . e , self . k [ i ] . n ) v = self . _E ( v ^ e ) si ( i + 1 ) % propio . norte == 0 : c = v s [ z ] = yo . _g ( v ^ u , self . k [ z ] . d , self . k [ z ] . n ) return [ c ] + s def verificar_mensaje ( self , m : str , X ) -> bool : self . _permutar ( m ) def _f ( i ): devuelve uno mismo . _g ( X [ i + 1 ], yo . k [ i ] . e , yo . k [ i ] . n ) y = mapa ( _f , rango ( len ( X ) - 1 )) y = lista ( y ) def _g ( x , i ): devuelve self . _E ( x ^ y [ i ]) r = herramientas funcionales . reducir ( _g , rango ( self . n ), X [ 0 ]) devolver r == X [ 0 ] def _permut ( self , m ): mensaje = m . codificar ( "utf-8" ) auto . p = int ( hashlib . sha1 ( msg ) . hexdigest (), 16 ) def _E ( self , x ) : msg = f " { x } { self.p } " . codificar ( "utf-8" ) devolver int ( hashlib . sha1 ( msg ) . hexdigest (), 16 ) def _g ( self , x , e , n ): q , r = divmod ( x , n ) if (( q + 1 ) * n ) <= (( 1 << self . l ) - 1 ): resultado = q * n + pow ( r , e , n ) más : resultado = x devolver resultado
Para firmar y verificar 2 mensajes en un anillo de 4 usuarios:
tamaño = 4 msg1 , msg2 = "hola" , "¡mundo!"def _rn ( _ ): devuelve Cripto . Llave pública . RSA . generar ( 1024 , os . urandom )clave = mapa ( _rn , rango ( tamaño )) clave = lista ( clave )r = Anillo ( llave )para i en rango ( tamaño ): firma_1 = r . sign_message ( msg1 , i ) firma_2 = r . sign_message ( msg2 , i ) afirmar r . verificar_mensaje ( msg1 , firma_1 ) y r . verificar_message ( msg2 , firma_2 ) y no r . verificar_mensaje ( msg1 , firma_2 )
Monero y varias otras criptomonedas utilizan esta tecnología. [ cita necesaria ]
Este artículo incorpora texto disponible bajo la licencia CC BY-SA 4.0.
{{cite book}}
: |journal=
ignorado ( ayuda )