kris
/
sike_ifma
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
1 Revīzija
1 Atzars
116 KiB
 
 
 
Koks: 8335e684f6
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '8335e684f6'
${ noResults }
sike_ifma/sidh_ref/api.h

110 rindas
6.2 KiB
Neapstrādāts Vainot Vēsture 

  1. /********************************************************************************************

  2. * Supersingular Isogeny Key Encapsulation Library

  3. *

  4. * Abstract: API header file for P751

  5. *********************************************************************************************/  

  6. 

  7. #ifndef __P751_API_H__

  8. #define __P751_API_H__

  9. 

  10. #include "config.h"

  11.     

  12. 

  13. /*********************** Key encapsulation mechanism API ***********************/

  14. 

  15. #define CRYPTO_SECRETKEYBYTES     644    // MSG_BYTES + SECRETKEY_B_BYTES + CRYPTO_PUBLICKEYBYTES bytes

  16. #define CRYPTO_PUBLICKEYBYTES     564

  17. #define CRYPTO_BYTES               24

  18. #define CRYPTO_CIPHERTEXTBYTES    596    // CRYPTO_PUBLICKEYBYTES + MSG_BYTES bytes

  19. 

  20. // Algorithm name

  21. #define CRYPTO_ALGNAME "SIKEp751"  

  22. 

  23. // SIKE's key generation

  24. // It produces a private key sk and computes the public key pk.

  25. // Outputs: secret key sk (CRYPTO_SECRETKEYBYTES = 644 bytes)

  26. //          public key pk (CRYPTO_PUBLICKEYBYTES = 564 bytes) 

  27. int crypto_kem_keypair(unsigned char *pk, unsigned char *sk);

  28. 

  29. // SIKE's encapsulation

  30. // Input:   public key pk         (CRYPTO_PUBLICKEYBYTES = 564 bytes)

  31. // Outputs: shared secret ss      (CRYPTO_BYTES = 24 bytes)

  32. //          ciphertext message ct (CRYPTO_CIPHERTEXTBYTES = 596 bytes) 

  33. int crypto_kem_enc(unsigned char *ct, unsigned char *ss, const unsigned char *pk);

  34. 

  35. // SIKE's decapsulation

  36. // Input:   secret key sk         (CRYPTO_SECRETKEYBYTES = 644 bytes)

  37. //          ciphertext message ct (CRYPTO_CIPHERTEXTBYTES = 596 bytes) 

  38. // Outputs: shared secret ss      (CRYPTO_BYTES = 24 bytes)

  39. int crypto_kem_dec(unsigned char *ss, const unsigned char *ct, const unsigned char *sk);

  40. 

  41. 

  42. // Encoding of keys for KEM-based isogeny system "SIKEp751" (wire format):

  43. // ----------------------------------------------------------------------

  44. // Elements over GF(p751) are encoded in 94 octets in little endian format (i.e., the least significant octet is located in the lowest memory address). 

  45. // Elements (a+b*i) over GF(p751^2), where a and b are defined over GF(p751), are encoded as {a, b}, with a in the lowest memory portion.

  46. //

  47. // Private keys sk consist of the concatenation of a 32-byte random value, a value in the range [0, 2^378-1] and the public key pk. In the SIKE API, 

  48. // private keys are encoded in 644 octets in little endian format. 

  49. // Public keys pk consist of 3 elements in GF(p751^2). In the SIKE API, pk is encoded in 564 octets. 

  50. // Ciphertexts ct consist of the concatenation of a public key value and a 32-byte value. In the SIKE API, ct is encoded in 564 + 32 = 596 octets.  

  51. // Shared keys ss consist of a value of 24 octets.

  52. 

  53. 

  54. /*********************** Ephemeral key exchange API ***********************/

  55. 

  56. #define SIDH_SECRETKEYBYTES      48

  57. #define SIDH_PUBLICKEYBYTES     564

  58. #define SIDH_BYTES              188 

  59. 

  60. // SECURITY NOTE: SIDH supports ephemeral Diffie-Hellman key exchange. It is NOT secure to use it with static keys.

  61. // See "On the Security of Supersingular Isogeny Cryptosystems", S.D. Galbraith, C. Petit, B. Shani and Y.B. Ti, in ASIACRYPT 2016, 2016.

  62. // Extended version available at: http://eprint.iacr.org/2016/859     

  63. 

  64. // Generation of Alice's secret key 

  65. // Outputs random value in [0, 2^372 - 1] to be used as Alice's private key

  66. void random_mod_order_A(unsigned char* random_digits);

  67. 

  68. // Generation of Bob's secret key 

  69. // Outputs random value in [0, 2^Floor(Log(2,3^239)) - 1] to be used as Bob's private key

  70. void random_mod_order_B(unsigned char* random_digits);

  71. 

  72. // Alice's ephemeral public key generation

  73. // Input:  a private key PrivateKeyA in the range [0, 2^372 - 1], stored in 47 bytes. 

  74. // Output: the public key PublicKeyA consisting of 3 GF(p751^2) elements encoded in 564 bytes.

  75. int EphemeralKeyGeneration_A(const unsigned char* PrivateKeyA, unsigned char* PublicKeyA);

  76. 

  77. // Bob's ephemeral key-pair generation

  78. // It produces a private key PrivateKeyB and computes the public key PublicKeyB.

  79. // The private key is an integer in the range [0, 2^Floor(Log(2,3^239)) - 1], stored in 48 bytes.  

  80. // The public key consists of 3 GF(p751^2) elements encoded in 564 bytes.

  81. int EphemeralKeyGeneration_B(const unsigned char* PrivateKeyB, unsigned char* PublicKeyB);

  82. 

  83. // Alice's ephemeral shared secret computation

  84. // It produces a shared secret key SharedSecretA using her secret key PrivateKeyA and Bob's public key PublicKeyB

  85. // Inputs: Alice's PrivateKeyA is an integer in the range [0, 2^372 - 1], stored in 47 bytes. 

  86. //         Bob's PublicKeyB consists of 3 GF(p751^2) elements encoded in 564 bytes.

  87. // Output: a shared secret SharedSecretA that consists of one element in GF(p751^2) encoded in 188 bytes.

  88. int EphemeralSecretAgreement_A(const unsigned char* PrivateKeyA, const unsigned char* PublicKeyB, unsigned char* SharedSecretA);

  89. 

  90. // Bob's ephemeral shared secret computation

  91. // It produces a shared secret key SharedSecretB using his secret key PrivateKeyB and Alice's public key PublicKeyA

  92. // Inputs: Bob's PrivateKeyB is an integer in the range [0, 2^Floor(Log(2,3^239)) - 1], stored in 48 bytes.  

  93. //         Alice's PublicKeyA consists of 3 GF(p751^2) elements encoded in 564 bytes.

  94. // Output: a shared secret SharedSecretB that consists of one element in GF(p751^2) encoded in 188 bytes. 

  95. int EphemeralSecretAgreement_B(const unsigned char* PrivateKeyB, const unsigned char* PublicKeyA, unsigned char* SharedSecretB);

  96. 

  97. 

  98. // Encoding of keys for KEX-based isogeny system "SIDHp751" (wire format):

  99. // ----------------------------------------------------------------------

  100. // Elements over GF(p751) are encoded in 94 octets in little endian format (i.e., the least significant octet is located in the lowest memory address). 

  101. // Elements (a+b*i) over GF(p751^2), where a and b are defined over GF(p751), are encoded as {a, b}, with a in the lowest memory portion.

  102. //

  103. // Private keys PrivateKeyA and PrivateKeyB can have values in the range [0, 2^372-1] and [0, 2^378-1], resp. In the SIDH API, private keys are encoded 

  104. // in 48 octets in little endian format. 

  105. // Public keys PublicKeyA and PublicKeyB consist of 3 elements in GF(p751^2). In the SIDH API, they are encoded in 564 octets. 

  106. // Shared keys SharedSecretA and SharedSecretB consist of one element in GF(p751^2). In the SIDH API, they are encoded in 188 octets.

  107. 

  108. 

  109. #endif