/* Taken from gsti */
-#define DH_G 2
-
-#warning "FIXME: NEED MORE PRIMES"
+#define DH_G_1024 2
+#define DH_G_4096 5
+#define DH_G_2048 5
static const uint8 diffie_hellman_group1_prime[130] = { 0x04, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
+/* prime - 4096 bits */
+const uint8 diffie_hellman_prime_4096[512] = {
+ 0x98, 0xb7, 0x3d, 0x66, 0xf1, 0x18, 0x61,
+ 0xa9, 0x36, 0xd9, 0xf1, 0xbf, 0x65, 0xbb,
+ 0x7c, 0x06, 0x10, 0x15, 0xe5, 0x24, 0x47,
+ 0xb5, 0x45, 0x7e, 0xbb, 0xdf, 0x59, 0xf4,
+ 0xf2, 0x59, 0x7d, 0xea, 0xe0, 0x0f, 0x06,
+ 0x42, 0xd8, 0xb1, 0x9b, 0x62, 0xf9, 0x81,
+ 0x05, 0xd7, 0xd5, 0x74, 0x7c, 0x39, 0x3b,
+ 0x6d, 0x57, 0xb7, 0xe9, 0x51, 0x0d, 0xb6,
+ 0xe5, 0x03, 0xf7, 0xf3, 0xac, 0x1b, 0x66,
+ 0x96, 0xb3, 0xf8, 0xa1, 0xe1, 0xc7, 0x9c,
+ 0xc7, 0x52, 0x19, 0x2a, 0x90, 0xe6, 0x1d,
+ 0xba, 0xf5, 0x15, 0xcb, 0x8b, 0x52, 0x88,
+ 0xcd, 0xf5, 0x50, 0x33, 0x04, 0xb8, 0x2f,
+ 0x2c, 0x01, 0x57, 0x82, 0x7c, 0x8a, 0xf0,
+ 0xa3, 0x73, 0x7e, 0x0c, 0x2d, 0x69, 0xd4,
+ 0x17, 0xf6, 0xd0, 0x6a, 0x32, 0x95, 0x6a,
+ 0x69, 0x40, 0xb0, 0x55, 0x4f, 0xf0, 0x1d,
+ 0xae, 0x3d, 0x5f, 0x01, 0x92, 0x14, 0x3a,
+ 0x73, 0x69, 0x5a, 0x8e, 0xea, 0x22, 0x52,
+ 0x44, 0xc2, 0xb8, 0x66, 0x1e, 0x26, 0x1a,
+ 0x5d, 0x8f, 0x46, 0x6b, 0x8d, 0x3c, 0x71,
+ 0xcf, 0x1d, 0x72, 0x8d, 0x2f, 0x03, 0x54,
+ 0xdb, 0xe9, 0x82, 0x60, 0xe5, 0xf6, 0x40,
+ 0x4b, 0x6b, 0xae, 0x0a, 0xb2, 0x30, 0xba,
+ 0x1c, 0x45, 0x7e, 0x3f, 0xfd, 0xf7, 0xdc,
+ 0xa6, 0xbb, 0x98, 0xc4, 0xca, 0xfc, 0x66,
+ 0xf3, 0x48, 0x47, 0xbf, 0xdb, 0xd7, 0xdc,
+ 0xff, 0x1d, 0xeb, 0xa0, 0x4e, 0xb6, 0xff,
+ 0x75, 0xdc, 0x0c, 0x1d, 0x93, 0x9e, 0xd5,
+ 0xb3, 0x68, 0xe7, 0x07, 0x29, 0x91, 0xf1,
+ 0xae, 0xfc, 0x7e, 0x3a, 0xea, 0xec, 0x40,
+ 0xfc, 0x70, 0x7f, 0xf3, 0x36, 0x81, 0xec,
+ 0x97, 0xa7, 0x0d, 0x71, 0x2c, 0x5c, 0x4f,
+ 0xd9, 0x00, 0xcf, 0x62, 0x56, 0xfb, 0x09,
+ 0x2d, 0x1b, 0x04, 0x3c, 0x00, 0xc8, 0x17,
+ 0xd7, 0x7d, 0x16, 0x20, 0x1e, 0x62, 0x9b,
+ 0xf4, 0x4f, 0xee, 0xa4, 0xbf, 0x0b, 0xde,
+ 0x51, 0x7c, 0x01, 0x76, 0x79, 0x73, 0x7d,
+ 0x7b, 0xec, 0xee, 0x14, 0xec, 0x83, 0xc3,
+ 0xb4, 0x42, 0x66, 0x19, 0x52, 0x19, 0x04,
+ 0x02, 0x71, 0x61, 0x5c, 0x78, 0xee, 0x5f,
+ 0x58, 0x1e, 0x5b, 0x2d, 0xf3, 0x0c, 0x6e,
+ 0x00, 0x0f, 0xd8, 0xf0, 0x86, 0xa1, 0x11,
+ 0xfd, 0x04, 0x07, 0xa6, 0xf7, 0x31, 0xb9,
+ 0xf6, 0x76, 0xfc, 0xea, 0xf0, 0x16, 0x98,
+ 0x37, 0x48, 0x1b, 0x0c, 0x32, 0x3f, 0x7e,
+ 0xfa, 0x02, 0x04, 0x2a, 0x48, 0x70, 0xb4,
+ 0xe3, 0xe0, 0xc1, 0x7f, 0x65, 0x70, 0xd0,
+ 0x71, 0x74, 0x86, 0xb7, 0x5d, 0xd4, 0x84,
+ 0xd5, 0x9d, 0x77, 0xf6, 0x72, 0x82, 0x4b,
+ 0x98, 0x8b, 0x49, 0x3a, 0x0b, 0x1e, 0x94,
+ 0x42, 0xf7, 0x0b, 0x3f, 0xec, 0xc2, 0x2b,
+ 0x7f, 0x55, 0xe2, 0x94, 0x48, 0xac, 0x04,
+ 0xb9, 0xb2, 0xb6, 0xca, 0xb4, 0x09, 0xe3,
+ 0xba, 0x6a, 0x55, 0x28, 0xf7, 0x8a, 0x73,
+ 0x4d, 0x21, 0xe1, 0xf4, 0xcd, 0x22, 0x15,
+ 0x9c, 0xe6, 0xcc, 0x1d, 0x9f, 0x81, 0x88,
+ 0x4c, 0x5a, 0x17, 0x9f, 0xe5, 0x8c, 0x85,
+ 0xf1, 0xa3, 0xcf, 0x6c, 0xa1, 0xbf, 0x5e,
+ 0x02, 0x61, 0xa8, 0x67, 0x6f, 0xb8, 0x20,
+ 0x1a, 0x4e, 0xf2, 0x05, 0xd7, 0xb4, 0x4b,
+ 0x3e, 0xca, 0x87, 0x49, 0x10, 0x16, 0xcc,
+ 0xc9, 0xe0, 0x1c, 0xc1, 0x83, 0xc7, 0xa0,
+ 0x54, 0x3d, 0x36, 0x17, 0x84, 0xc3, 0x84,
+ 0x2e, 0x5a, 0xe0, 0x75, 0x45, 0x01, 0xe6,
+ 0xf0, 0x3d, 0xf9, 0x33, 0x0a, 0xd9, 0x1e,
+ 0x66, 0x99, 0xb4, 0x21, 0xed, 0x6e, 0xda,
+ 0x6f, 0x37, 0x33, 0xdd, 0x8f, 0x25, 0x35,
+ 0x5e, 0x6c, 0x1e, 0x33, 0xc2, 0x41, 0x3f,
+ 0x58, 0x40, 0xbb, 0xe7, 0x2b, 0x54, 0xdb,
+ 0xd8, 0xcf, 0x3a, 0xba, 0x0c, 0xf1, 0x19,
+ 0xec, 0x9d, 0x50, 0xf6, 0x63, 0x22, 0x55,
+ 0x5e, 0x79, 0xd1, 0x3f, 0x46, 0x0f, 0xf3,
+ 0x7f
+};
+
+
+/* prime - 2048 bits */
+const uint8 diffie_hellman_prime_2048[256] = {
+ 0xf0, 0x49, 0x65, 0x6d, 0x24, 0x61, 0xe6,
+ 0x86, 0x8e, 0x57, 0x2b, 0x9b, 0x1c, 0x53,
+ 0x2e, 0xef, 0xd2, 0x6e, 0xe5, 0x6c, 0xc4,
+ 0x0c, 0x77, 0x1d, 0xce, 0xc7, 0xe0, 0x92,
+ 0x78, 0x8b, 0x2b, 0x80, 0x9f, 0xc4, 0x59,
+ 0xb5, 0x2e, 0xeb, 0x81, 0x8b, 0xfa, 0x08,
+ 0x9f, 0x02, 0x5e, 0x94, 0x85, 0xab, 0xab,
+ 0x08, 0x8a, 0x71, 0xb5, 0x0c, 0x26, 0x63,
+ 0x2f, 0x34, 0x10, 0xdf, 0x32, 0x9a, 0xa1,
+ 0xd5, 0xb5, 0xd7, 0xa1, 0x46, 0x24, 0x9a,
+ 0xe3, 0x2a, 0xf1, 0x3a, 0x52, 0xc4, 0xa4,
+ 0xe6, 0xa2, 0x29, 0x5e, 0x49, 0x0e, 0x2a,
+ 0x4d, 0xad, 0xcd, 0x92, 0xb6, 0xa5, 0x25,
+ 0xe5, 0x09, 0xae, 0x76, 0xe4, 0x19, 0xec,
+ 0x29, 0x9b, 0x9b, 0xdb, 0x0c, 0xc8, 0x28,
+ 0x1c, 0x49, 0x11, 0x45, 0x30, 0x51, 0x73,
+ 0x31, 0x18, 0x9e, 0xa5, 0x89, 0x7d, 0x17,
+ 0x22, 0xd5, 0x49, 0xaf, 0xf6, 0xe5, 0x00,
+ 0x55, 0x7f, 0x2b, 0x33, 0x2d, 0x2f, 0x89,
+ 0x73, 0x0b, 0x4d, 0x44, 0x72, 0xb1, 0x2e,
+ 0xa3, 0x68, 0xbe, 0x52, 0x4e, 0x5a, 0x66,
+ 0x36, 0xf9, 0x2c, 0xe7, 0xce, 0x92, 0x4d,
+ 0x0c, 0xa3, 0xc7, 0x85, 0x7e, 0xe6, 0x97,
+ 0x02, 0x8b, 0x0c, 0xcb, 0xf3, 0x6f, 0x2e,
+ 0x04, 0xed, 0x6e, 0x75, 0xcf, 0xd1, 0xd4,
+ 0x9f, 0xd3, 0x44, 0x3e, 0x5f, 0x81, 0xaa,
+ 0xc1, 0xb8, 0xe2, 0xab, 0xed, 0x3b, 0xfc,
+ 0xeb, 0x47, 0x48, 0xee, 0xe5, 0xfd, 0xc2,
+ 0x79, 0x7a, 0x01, 0xe9, 0xab, 0xc6, 0x34,
+ 0x65, 0x6a, 0x0a, 0x6c, 0xe8, 0x89, 0xa6,
+ 0x96, 0xd2, 0x1e, 0xe5, 0xbe, 0x58, 0xf2,
+ 0xcf, 0x17, 0xb8, 0x75, 0x43, 0xec, 0x0b,
+ 0xb2, 0x91, 0x50, 0x93, 0x4c, 0xd2, 0xa3,
+ 0xa4, 0x8a, 0x67, 0x23, 0x7f, 0x86, 0xac,
+ 0xe3, 0x56, 0x9b, 0x18, 0x03, 0x03, 0x70,
+ 0x50, 0x7b, 0x1a, 0x02, 0x22, 0x0b, 0x93,
+ 0xc8, 0x9b, 0xa8, 0x8f
+};
+
+
/*
--Example--
you: X = g ^ x mod p;
his_key = X ^ y mod p;
// generate our secret and the public value for it
- X = gnutls_calc_dh_secret(&x);
+ X = gnutls_calc_dh_secret(&x, g, p);
// now we can calculate the shared secret
- key = gnutls_calc_dh_key(Y, x);
+ key = gnutls_calc_dh_key(Y, x, g, p);
gnutls_mpi_release(x);
gnutls_mpi_release(g);
*/
-/* #define E_SIZE 1024 */
#define X_SIZE 512
-/****************
- * Choose a random value x and calculate e = g^x mod p.
- * Return: e and if ret_x is not NULL x.
- * It also returns g and p.
- */
-MPI gnutls_calc_dh_secret(MPI * ret_x)
-{
- MPI e, g, x, prime;
- size_t n = sizeof diffie_hellman_group1_prime;
-
- if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
- diffie_hellman_group1_prime, &n)) {
- gnutls_assert();
- abort();
- }
- /*_gnutls_dump_mpi(stderr, "prime=", prime ); */
-
- g = gcry_mpi_set_ui(NULL, DH_G);
- x = gcry_mpi_new(X_SIZE); /* FIXME: allocate in secure memory */
- gcry_mpi_randomize(x, X_SIZE, GCRY_STRONG_RANDOM);
- /* fixme: set high bit of x and select a larger one */
-
-/* e = gcry_mpi_new(E_SIZE); */
- e = gcry_mpi_alloc_like(prime);
- /* e = g^x mod prime */
-
- gcry_mpi_powm(e, g, x, prime);
-
- if (ret_x)
- *ret_x = x;
- else
- gcry_mpi_release(x);
- gcry_mpi_release(g);
- gcry_mpi_release(prime);
- return e;
-}
-
-MPI _gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
+MPI gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
{
MPI e, x;
/* fixme: set high bit of x and select a larger one */
e = gcry_mpi_alloc_like(prime);
-/* e = gcry_mpi_new(E_SIZE); */
gcry_mpi_powm(e, g, x, prime);
if (ret_x)
}
/* returns g and p */
-MPI gnutls_get_dh_params(MPI * ret_p)
+MPI gnutls_get_dh_params(MPI * ret_p, int bits)
{
MPI g, prime;
- size_t n = sizeof diffie_hellman_group1_prime;
+ size_t n;
+
+ if (bits >= 4096) bits = 4096;
+ else if (bits>=2048) bits=2048;
+ else if (bits>=1024) bits=1024;
+ else bits=1024;
+
+ switch (bits) {
+ case 1024:
+ n = sizeof diffie_hellman_group1_prime;
- if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
+ if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
diffie_hellman_group1_prime, &n)) {
- gnutls_assert();
- abort();
- }
+ gnutls_assert();
+ abort();
+ }
- g = gcry_mpi_set_ui(NULL, DH_G);
+ g = gcry_mpi_set_ui(NULL, DH_G_1024);
- if (ret_p)
- *ret_p = prime;
- else
- gcry_mpi_release(prime);
- return g;
-}
+ if (ret_p)
+ *ret_p = prime;
+ else
+ gcry_mpi_release(prime);
+ return g;
+ case 2048:
+ n = sizeof diffie_hellman_prime_2048;
+ if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
+ diffie_hellman_prime_2048, &n)) {
+ gnutls_assert();
+ abort();
+ }
-MPI gnutls_calc_dh_key(MPI f, MPI x)
-{
- MPI k, prime;
- size_t n = sizeof diffie_hellman_group1_prime;
+ g = gcry_mpi_set_ui(NULL, DH_G_2048);
- if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
- diffie_hellman_group1_prime, &n)) {
+ if (ret_p)
+ *ret_p = prime;
+ else
+ gcry_mpi_release(prime);
+ return g;
+ case 4096:
+ n = sizeof diffie_hellman_prime_4096;
+
+ if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
+ diffie_hellman_prime_4096, &n)) {
+ gnutls_assert();
+ abort();
+ }
+
+ g = gcry_mpi_set_ui(NULL, DH_G_4096);
+
+ if (ret_p)
+ *ret_p = prime;
+ else
+ gcry_mpi_release(prime);
+ return g;
+ default:
gnutls_assert();
abort();
}
- /*_gnutls_dump_mpi(stderr, "prime=", prime ); */
-
- k = gcry_mpi_alloc_like(prime);
-/* k = gcry_mpi_new(E_SIZE); FIXME: allocate in secure memory */
- gcry_mpi_powm(k, f, x, prime);
- gcry_mpi_release(prime);
- return k;
}
-MPI _gnutls_calc_dh_key(MPI f, MPI x, MPI prime)
+
+MPI gnutls_calc_dh_key(MPI f, MPI x, MPI prime)
{
MPI k;
-/* k = gcry_mpi_new(E_SIZE); FIXME: allocate in secure memory */
k = gcry_mpi_alloc_like(prime);
gcry_mpi_powm(k, f, x, prime);
return k;
#define gcry_mpi_addm mpi_addm
#define gcry_mpi_mul mpi_mul
#define gcry_mpi_mulm mpi_mulm
-MPI generate_public_prime( unsigned nbits );
+MPI generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
+ MPI g, MPI **ret_factors );
/* Here functions for SRP (like g^x mod n) are defined
*/
*/
const uint8 diffie_hellman_group1_prime[130] = { 0x04, 0x00,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
- 0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
- 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
- 0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
- 0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
- 0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
- 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
- 0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
- 0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
- 0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE6, 0x53, 0x81,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA,
+ 0xA2, 0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC,
+ 0x1C, 0xD1, 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02,
+ 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79,
+ 0x8E, 0x34, 0x04, 0xDD, 0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43,
+ 0x1B, 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1,
+ 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45, 0xE4, 0x85, 0xB5, 0x76, 0x62,
+ 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B,
+ 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED, 0xEE, 0x38, 0x6B,
+ 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B,
+ 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE6, 0x53, 0x81, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
-int _gnutls_srp_gn( opaque** ret_g, opaque** ret_n, int bits) {
+int _gnutls_srp_gn(opaque ** ret_g, opaque ** ret_n, int bits)
+{
MPI g, prime;
size_t n;
- int siz;
- char* tmp;
+ int siz, qbits;
+ char *tmp;
n = sizeof diffie_hellman_group1_prime;
- if (bits==n*8) {
+ if (bits == n * 8) {
if (gcry_mpi_scan(&prime, GCRYMPI_FMT_USG,
diffie_hellman_group1_prime, &n)) {
gnutls_assert();
return GNUTLS_E_MPI_SCAN_FAILED;
}
+ g = gcry_mpi_set_ui(NULL, SRP_G);
+
} else {
+ g = mpi_new(16); /* this should be ok */
+
/* generate a random prime */
- prime = generate_public_prime(bits);
- }
+ /* this is an emulation of Michael Wiener's table
+ * bad emulation.
+ */
+ qbits = 120 + (((bits / 256) - 1) * 20);
+ if (qbits & 1) /* better have a even one */
+ qbits++;
- g = gcry_mpi_set_ui(NULL, SRP_G);
+ prime = generate_elg_prime(0, bits, qbits, g, NULL);
+
+ }
siz = 0;
gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &siz, g);
- if (ret_g!=NULL) {
+ if (ret_g != NULL) {
tmp = gnutls_malloc(siz);
gcry_mpi_print(GCRYMPI_FMT_USG, tmp, &siz, g);
- if (_gnutls_sbase64_encode( tmp, siz, ret_g) < 0) {
+ if (_gnutls_sbase64_encode(tmp, siz, ret_g) < 0) {
gnutls_free(tmp);
return GNUTLS_E_UNKNOWN_ERROR;
}
siz = 0;
gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &siz, prime);
- if (ret_n!=NULL) {
+ if (ret_n != NULL) {
tmp = gnutls_malloc(siz);
gcry_mpi_print(GCRYMPI_FMT_USG, tmp, &siz, prime);
- if (_gnutls_sbase64_encode( tmp, siz, ret_n) < 0) {
+ if (_gnutls_sbase64_encode(tmp, siz, ret_n) < 0) {
gnutls_free(tmp);
return GNUTLS_E_UNKNOWN_ERROR;
}
gnutls_free(tmp);
}
-
+
gcry_mpi_release(g);
gcry_mpi_release(prime);
}
-int _gnutls_srp_gx(opaque *text, int textsize, opaque** result, MPI g, MPI prime) {
+int _gnutls_srp_gx(opaque * text, int textsize, opaque ** result, MPI g,
+ MPI prime)
+{
MPI x, e;
int result_size;
- if (gcry_mpi_scan(&x, GCRYMPI_FMT_USG,
- text, &textsize)) {
+ if (gcry_mpi_scan(&x, GCRYMPI_FMT_USG, text, &textsize)) {
gnutls_assert();
return GNUTLS_E_MPI_SCAN_FAILED;
}
gcry_mpi_powm(e, g, x, prime);
gcry_mpi_release(x);
-
gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &result_size, e);
- if (result!=NULL) {
+ if (result != NULL) {
*result = gnutls_malloc(result_size);
- gcry_mpi_print(GCRYMPI_FMT_USG, *result, &result_size, e);
+ gcry_mpi_print(GCRYMPI_FMT_USG, *result, &result_size, e);
}
gcry_mpi_release(e);
MPI tmpB;
MPI b, B;
int bits;
-
+
/* calculate: B = (v + g^b) % N */
bits = gcry_mpi_get_nbits(n);
b = gcry_mpi_new(bits); /* FIXME: allocate in secure memory */
return B;
}
-MPI _gnutls_calc_srp_u( MPI B) {
-int b_size;
-opaque* b_holder, *hd;
-GNUTLS_MAC_HANDLE td;
-uint32 u;
-MPI ret;
+MPI _gnutls_calc_srp_u(MPI B)
+{
+ int b_size;
+ opaque *b_holder, *hd;
+ GNUTLS_MAC_HANDLE td;
+ uint32 u;
+ MPI ret;
gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &b_size, B);
b_holder = gnutls_malloc(b_size);
-
+
gcry_mpi_print(GCRYMPI_FMT_USG, b_holder, &b_size, B);
-
-
+
+
td = gnutls_hash_init(GNUTLS_MAC_SHA);
gnutls_hash(td, b_holder, b_size);
hd = gnutls_hash_deinit(td);
ret = gcry_mpi_set_ui(NULL, u);
- return ret;
+ return ret;
}
/* S = (A * v^u) ^ b % N
*/
MPI _gnutls_calc_srp_S1(MPI A, MPI b, MPI u, MPI v, MPI n)
{
-MPI tmp1, tmp2;
-MPI S;
+ MPI tmp1, tmp2;
+ MPI S;
-S = gcry_mpi_alloc_like(n);
-tmp1 = gcry_mpi_alloc_like(n);
-tmp2 = gcry_mpi_alloc_like(n);
+ S = gcry_mpi_alloc_like(n);
+ tmp1 = gcry_mpi_alloc_like(n);
+ tmp2 = gcry_mpi_alloc_like(n);
-gcry_mpi_powm(tmp1, v, u, n);
-gcry_mpi_mulm(tmp2, A, tmp1, n);
-gcry_mpi_release(tmp1);
+ gcry_mpi_powm(tmp1, v, u, n);
+ gcry_mpi_mulm(tmp2, A, tmp1, n);
+ gcry_mpi_release(tmp1);
-gcry_mpi_powm(S, tmp2, b, n);
-gcry_mpi_release(tmp2);
+ gcry_mpi_powm(S, tmp2, b, n);
+ gcry_mpi_release(tmp2);
-return S;
+ return S;
}
/* A = g^a % N
* returns A and a (which is random)
*/
-MPI _gnutls_calc_srp_A(MPI *a, MPI g, MPI n)
+MPI _gnutls_calc_srp_A(MPI * a, MPI g, MPI n)
{
-MPI tmpa;
-MPI A;
-int bits;
+ MPI tmpa;
+ MPI A;
+ int bits;
bits = gcry_mpi_get_nbits(n);
tmpa = gcry_mpi_new(bits); /* FIXME: allocate in secure memory */
A = gcry_mpi_new(bits); /* FIXME: allocate in secure memory */
gcry_mpi_powm(A, g, tmpa, n);
- if (a!=NULL)
+ if (a != NULL)
*a = tmpa;
else
gcry_mpi_release(tmpa);
-
+
return A;
}
/* generate x = SHA(s | SHA(U | ":" | p))
* The output is exactly 20 bytes
*/
-void* _gnutls_calc_srp_sha( char* username, char* password, opaque* salt, int salt_size, int* size) {
-GNUTLS_MAC_HANDLE td;
-opaque* res;
+void *_gnutls_calc_srp_sha(char *username, char *password, opaque * salt,
+ int salt_size, int *size)
+{
+ GNUTLS_MAC_HANDLE td;
+ opaque *res;
*size = 20;
-
+
td = gnutls_hash_init(GNUTLS_MAC_SHA);
gnutls_hash(td, username, strlen(username));
gnutls_hash(td, ":", 1);
td = gnutls_hash_init(GNUTLS_MAC_SHA);
gnutls_hash(td, salt, salt_size);
- gnutls_hash(td, res, 20); /* 20 bytes is the output of sha1 */
+ gnutls_hash(td, res, 20); /* 20 bytes is the output of sha1 */
gnutls_free(res);
return gnutls_hash_deinit(td);
}
-void* _gnutls_calc_srp_x( char* username, char* password, opaque* salt, int salt_size, uint8 crypt_algo, int* size) {
-
- switch(crypt_algo) {
- case SRPSHA1_CRYPT:
- return _gnutls_calc_srp_sha( username, password, salt, salt_size, size);
- case BLOWFISH_CRYPT:
- return _gnutls_calc_srp_bcrypt( password, salt, salt_size, size);
+void *_gnutls_calc_srp_x(char *username, char *password, opaque * salt,
+ int salt_size, uint8 crypt_algo, int *size)
+{
+
+ switch (crypt_algo) {
+ case SRPSHA1_CRYPT:
+ return _gnutls_calc_srp_sha(username, password, salt,
+ salt_size, size);
+ case BLOWFISH_CRYPT:
+ return _gnutls_calc_srp_bcrypt(password, salt, salt_size,
+ size);
}
- return NULL;
+ return NULL;
}
*/
MPI _gnutls_calc_srp_S2(MPI B, MPI g, MPI x, MPI a, MPI u, MPI n)
{
-MPI S, tmp1, tmp2, tmp4;
+ MPI S, tmp1, tmp2, tmp4;
S = gcry_mpi_alloc_like(n);
tmp1 = gcry_mpi_alloc_like(n);
projects / thirdparty / gnutls.git / commitdiff
