est31
/
csrp-gmp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format code with clang-format 

Voice of world control said: let there be peace about code style.
And there was no more fighting.
Voice of world control saw that it was good.
master
est31 2016-04-10 03:20:40 +02:00
parent 2a90017b0f
commit 66323332eb
4 changed files with 300 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.clang-format Normal file
View File

@ -0,0 +1,12 @@
---
BasedOnStyle: LLVM
IndentWidth: 8
UseTab: Always
IndentCaseLabels: false
AllowShortIfStatementsOnASingleLine: true
AlignAfterOpenBracket: false
ContinuationIndentWidth: 8
BreakBeforeBraces: Linux
ColumnLimit: 90
AllowShortFunctionsOnASingleLine: None
...

440
srp.c
View File

@ -64,9 +64,9 @@ static int g_initialized = 0;
static unsigned int g_rand_idx; static unsigned int g_rand_idx;
static unsigned char g_rand_buff[RAND_BUFF_MAX]; static unsigned char g_rand_buff[RAND_BUFF_MAX];
void *(*srp_alloc) (size_t) = &malloc; void *(*srp_alloc)(size_t) = &malloc;
void *(*srp_realloc) (void *, size_t) = &realloc; void *(*srp_realloc)(void *, size_t) = &realloc;
void (*srp_free) (void *) = &free; void (*srp_free)(void *) = &free;
// clang-format off // clang-format off
void srp_set_memory_functions( void srp_set_memory_functions(
@ -80,107 +80,100 @@ void srp_set_memory_functions(
} }
// clang-format on // clang-format on
typedef struct typedef struct {
{
mpz_t N; mpz_t N;
mpz_t g; mpz_t g;
} NGConstant; } NGConstant;
struct NGHex struct NGHex {
{ const char *n_hex;
const char* n_hex; const char *g_hex;
const char* g_hex;
}; };
/* All constants here were pulled from Appendix A of RFC 5054 */ /* All constants here were pulled from Appendix A of RFC 5054 */
static struct NGHex global_Ng_constants[] = { static struct NGHex global_Ng_constants[] = {
{ /* 1024 */ {/* 1024 */
"EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C" "EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C"
"9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE4" "9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE4"
"8E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B29" "8E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B29"
"7BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9A" "7BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9A"
"FD5138FE8376435B9FC61D2FC0EB06E3", "FD5138FE8376435B9FC61D2FC0EB06E3",
"2" "2"},
}, {/* 2048 */
{ /* 2048 */ "AC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC319294"
"AC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC319294" "3DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310D"
"3DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310D" "CD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FB"
"CD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FB" "D5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF74"
"D5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF74" "7359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A"
"7359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A" "436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D"
"436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D" "5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E73"
"5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E73" "03CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB6"
"03CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB6" "94B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F"
"94B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F" "9E4AFF73",
"9E4AFF73", "2"},
"2" {/* 4096 */
}, "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"
{ /* 4096 */ "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08" "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
"8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B" "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
"302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9" "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
"A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6" "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
"49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8" "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
"FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D" "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
"670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C" "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
"180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718" "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
"3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D" "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
"04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D" "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
"B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226" "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
"1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C" "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
"BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC" "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
"E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26" "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
"99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB" "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
"04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2" "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
"233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127" "FFFFFFFFFFFFFFFF",
"D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199" "5"},
"FFFFFFFFFFFFFFFF", {/* 8192 */
"5" "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"
}, "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
{ /* 8192 */ "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08" "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
"8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B" "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
"302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9" "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
"A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6" "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
"49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8" "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
"FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D" "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
"670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C" "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
"180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718" "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
"3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D" "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
"04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D" "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
"B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226" "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
"1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C" "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
"BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC" "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
"E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26" "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
"99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB" "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
"04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2" "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
"233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127" "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
"D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492" "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
"36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406" "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
"AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918" "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
"DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151" "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
"2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03" "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
"F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F" "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
"BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA" "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
"CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B" "6DBE115974A3926F12FEE5E438777CB6A932DF8CD8BEC4D073B931BA"
"B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632" "3BC832B68D9DD300741FA7BF8AFC47ED2576F6936BA424663AAB639C"
"387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E" "5AE4F5683423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
"6DBE115974A3926F12FEE5E438777CB6A932DF8CD8BEC4D073B931BA" "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B4BCBC886"
"3BC832B68D9DD300741FA7BF8AFC47ED2576F6936BA424663AAB639C" "2F8385DDFA9D4B7FA2C087E879683303ED5BDD3A062B3CF5B3A278A6"
"5AE4F5683423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9" "6D2A13F83F44F82DDF310EE074AB6A364597E899A0255DC164F31CC5"
"22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B4BCBC886" "0846851DF9AB48195DED7EA1B1D510BD7EE74D73FAF36BC31ECFA268"
"2F8385DDFA9D4B7FA2C087E879683303ED5BDD3A062B3CF5B3A278A6" "359046F4EB879F924009438B481C6CD7889A002ED5EE382BC9190DA6"
"6D2A13F83F44F82DDF310EE074AB6A364597E899A0255DC164F31CC5" "FC026E479558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
"0846851DF9AB48195DED7EA1B1D510BD7EE74D73FAF36BC31ECFA268" "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
"359046F4EB879F924009438B481C6CD7889A002ED5EE382BC9190DA6" "13"},
"FC026E479558E4475677E9AA9E3050E2765694DFC81F56E880B96E71" {0, 0} /* null sentinel */
"60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
"13"
},
{0,0} /* null sentinel */
}; };
static void delete_ng(NGConstant *ng) static void delete_ng(NGConstant *ng)
{ {
if (ng) { if (ng) {
@ -190,19 +183,18 @@ static void delete_ng(NGConstant *ng)
} }
} }
static NGConstant *new_ng( SRP_NGType ng_type, const char *n_hex, const char *g_hex ) static NGConstant *new_ng(SRP_NGType ng_type, const char *n_hex, const char *g_hex)
{ {
NGConstant *ng = (NGConstant *) srp_alloc(sizeof(NGConstant)); NGConstant *ng = (NGConstant *)srp_alloc(sizeof(NGConstant));
if (!ng) if (!ng) return 0;
return 0;
mpz_init(ng->N); mpz_init(ng->N);
mpz_init(ng->g); mpz_init(ng->g);
if (ng_type != SRP_NG_CUSTOM) { if (ng_type != SRP_NG_CUSTOM) {
n_hex = global_Ng_constants[ ng_type ].n_hex; n_hex = global_Ng_constants[ng_type].n_hex;
g_hex = global_Ng_constants[ ng_type ].g_hex; g_hex = global_Ng_constants[ng_type].g_hex;
} }
int rv = 0; int rv = 0;
@ -217,17 +209,13 @@ static NGConstant *new_ng( SRP_NGType ng_type, const char *n_hex, const char *g_
return ng; return ng;
} }
typedef union {
typedef union SHA_CTX sha;
{
SHA_CTX sha;
SHA256_CTX sha256; SHA256_CTX sha256;
//SHA512_CTX sha512; // SHA512_CTX sha512;
} HashCTX; } HashCTX;
struct SRPVerifier {
struct SRPVerifier
{
SRP_HashAlgorithm hash_alg; SRP_HashAlgorithm hash_alg;
NGConstant *ng; NGConstant *ng;
@ -240,9 +228,7 @@ struct SRPVerifier
unsigned char session_key[SHA512_DIGEST_LENGTH]; unsigned char session_key[SHA512_DIGEST_LENGTH];
}; };
struct SRPUser {
struct SRPUser
{
SRP_HashAlgorithm hash_alg; SRP_HashAlgorithm hash_alg;
NGConstant *ng; NGConstant *ng;
@ -363,7 +349,7 @@ static size_t hash_length(SRP_HashAlgorithm alg)
inline static int mpz_num_bytes(const mpz_t op) inline static int mpz_num_bytes(const mpz_t op)
{ {
return (mpz_sizeinbase (op, 2) + 7) / 8; return (mpz_sizeinbase(op, 2) + 7) / 8;
} }
inline static void mpz_to_bin(const mpz_t op, unsigned char *to) inline static void mpz_to_bin(const mpz_t op, unsigned char *to)
@ -377,36 +363,39 @@ inline static void mpz_from_bin(const unsigned char *s, size_t len, mpz_t ret)
} }
// set op to (op1 * op2) mod d, using tmp for the calculation // set op to (op1 * op2) mod d, using tmp for the calculation
inline static void mpz_mulm(mpz_t op, const mpz_t op1, const mpz_t op2, const mpz_t d, mpz_t tmp) inline static void mpz_mulm(
mpz_t op, const mpz_t op1, const mpz_t op2, const mpz_t d, mpz_t tmp)
{ {
mpz_mul(tmp, op1, op2); mpz_mul(tmp, op1, op2);
mpz_mod(op, tmp, d); mpz_mod(op, tmp, d);
} }
// set op to (op1 + op2) mod d, using tmp for the calculation // set op to (op1 + op2) mod d, using tmp for the calculation
inline static void mpz_addm( mpz_t op, const mpz_t op1, const mpz_t op2, const mpz_t d, mpz_t tmp ) inline static void mpz_addm(
mpz_t op, const mpz_t op1, const mpz_t op2, const mpz_t d, mpz_t tmp)
{ {
mpz_add(tmp, op1, op2); mpz_add(tmp, op1, op2);
mpz_mod(op, tmp, d); mpz_mod(op, tmp, d);
} }
// set op to (op1 - op2) mod d, using tmp for the calculation // set op to (op1 - op2) mod d, using tmp for the calculation
inline static void mpz_subm(mpz_t op, const mpz_t op1, const mpz_t op2, const mpz_t d, mpz_t tmp) inline static void mpz_subm(
mpz_t op, const mpz_t op1, const mpz_t op2, const mpz_t d, mpz_t tmp)
{ {
mpz_sub(tmp, op1, op2); mpz_sub(tmp, op1, op2);
mpz_mod(op, tmp, d); mpz_mod(op, tmp, d);
} }
static SRP_Result H_nn(mpz_t result, SRP_HashAlgorithm alg, const mpz_t N, const mpz_t n1, const mpz_t n2) static SRP_Result H_nn(mpz_t result, SRP_HashAlgorithm alg, const mpz_t N, const mpz_t n1,
const mpz_t n2)
{ {
unsigned char buff[SHA512_DIGEST_LENGTH]; unsigned char buff[SHA512_DIGEST_LENGTH];
size_t len_N = mpz_num_bytes(N); size_t len_N = mpz_num_bytes(N);
size_t len_n1 = mpz_num_bytes(n1); size_t len_n1 = mpz_num_bytes(n1);
size_t len_n2 = mpz_num_bytes(n2); size_t len_n2 = mpz_num_bytes(n2);
size_t nbytes = len_N + len_N; size_t nbytes = len_N + len_N;
unsigned char *bin = (unsigned char *) srp_alloc(nbytes); unsigned char *bin = (unsigned char *)srp_alloc(nbytes);
if (!bin) if (!bin) return SRP_ERR;
return SRP_ERR;
if (len_n1 > len_N || len_n2 > len_N) { if (len_n1 > len_N || len_n2 > len_N) {
srp_free(bin); srp_free(bin);
return SRP_ERR; return SRP_ERR;
@ -414,19 +403,19 @@ static SRP_Result H_nn(mpz_t result, SRP_HashAlgorithm alg, const mpz_t N, const
memset(bin, 0, nbytes); memset(bin, 0, nbytes);
mpz_to_bin(n1, bin + (len_N - len_n1)); mpz_to_bin(n1, bin + (len_N - len_n1));
mpz_to_bin(n2, bin + (len_N + len_N - len_n2)); mpz_to_bin(n2, bin + (len_N + len_N - len_n2));
hash( alg, bin, nbytes, buff ); hash(alg, bin, nbytes, buff);
srp_free(bin); srp_free(bin);
mpz_from_bin(buff, hash_length(alg), result); mpz_from_bin(buff, hash_length(alg), result);
return SRP_OK; return SRP_OK;
} }
static SRP_Result H_ns(mpz_t result, SRP_HashAlgorithm alg, const unsigned char *n, size_t len_n, const unsigned char *bytes, size_t len_bytes) static SRP_Result H_ns(mpz_t result, SRP_HashAlgorithm alg, const unsigned char *n,
size_t len_n, const unsigned char *bytes, size_t len_bytes)
{ {
unsigned char buff[SHA512_DIGEST_LENGTH]; unsigned char buff[SHA512_DIGEST_LENGTH];
size_t nbytes = len_n + len_bytes; size_t nbytes = len_n + len_bytes;
unsigned char *bin = (unsigned char *) srp_alloc(nbytes); unsigned char *bin = (unsigned char *)srp_alloc(nbytes);
if (!bin) if (!bin) return SRP_ERR;
return SRP_ERR;
memcpy(bin, n, len_n); memcpy(bin, n, len_n);
memcpy(bin + len_n, bytes, len_bytes); memcpy(bin + len_n, bytes, len_bytes);
hash(alg, bin, nbytes, buff); hash(alg, bin, nbytes, buff);
@ -435,14 +424,16 @@ static SRP_Result H_ns(mpz_t result, SRP_HashAlgorithm alg, const unsigned char
return SRP_OK; return SRP_OK;
} }
static int calculate_x(mpz_t result, SRP_HashAlgorithm alg, const unsigned char *salt, size_t salt_len, const char *username, const unsigned char *password, size_t password_len) static int calculate_x(mpz_t result, SRP_HashAlgorithm alg, const unsigned char *salt,
size_t salt_len, const char *username, const unsigned char *password,
size_t password_len)
{ {
unsigned char ucp_hash[SHA512_DIGEST_LENGTH]; unsigned char ucp_hash[SHA512_DIGEST_LENGTH];
HashCTX ctx; HashCTX ctx;
hash_init(alg, &ctx); hash_init(alg, &ctx);
srp_dbg_data((char*) username, strlen(username), "Username for x: "); srp_dbg_data((char *)username, strlen(username), "Username for x: ");
srp_dbg_data((char*) password, password_len, "Password for x: "); srp_dbg_data((char *)password, password_len, "Password for x: ");
hash_update(alg, &ctx, username, strlen(username)); hash_update(alg, &ctx, username, strlen(username));
hash_update(alg, &ctx, ":", 1); hash_update(alg, &ctx, ":", 1);
hash_update(alg, &ctx, password, password_len); hash_update(alg, &ctx, password, password_len);
@ -455,21 +446,19 @@ static int calculate_x(mpz_t result, SRP_HashAlgorithm alg, const unsigned char
static SRP_Result update_hash_n(SRP_HashAlgorithm alg, HashCTX *ctx, const mpz_t n) static SRP_Result update_hash_n(SRP_HashAlgorithm alg, HashCTX *ctx, const mpz_t n)
{ {
size_t len = mpz_num_bytes(n); size_t len = mpz_num_bytes(n);
unsigned char* n_bytes = (unsigned char *) srp_alloc(len); unsigned char *n_bytes = (unsigned char *)srp_alloc(len);
if (!n_bytes) if (!n_bytes) return SRP_ERR;
return SRP_ERR;
mpz_to_bin(n, n_bytes); mpz_to_bin(n, n_bytes);
hash_update(alg, ctx, n_bytes, len); hash_update(alg, ctx, n_bytes, len);
srp_free(n_bytes); srp_free(n_bytes);
return SRP_OK; return SRP_OK;
} }
static SRP_Result hash_num( SRP_HashAlgorithm alg, const mpz_t n, unsigned char *dest ) static SRP_Result hash_num(SRP_HashAlgorithm alg, const mpz_t n, unsigned char *dest)
{ {
int nbytes = mpz_num_bytes(n); int nbytes = mpz_num_bytes(n);
unsigned char *bin = (unsigned char *) srp_alloc(nbytes); unsigned char *bin = (unsigned char *)srp_alloc(nbytes);
if (!bin) if (!bin) return SRP_ERR;
return SRP_ERR;
mpz_to_bin(n, bin); mpz_to_bin(n, bin);
hash(alg, bin, nbytes, dest); hash(alg, bin, nbytes, dest);
srp_free(bin); srp_free(bin);
@ -477,8 +466,8 @@ static SRP_Result hash_num( SRP_HashAlgorithm alg, const mpz_t n, unsigned char
} }
static SRP_Result calculate_M(SRP_HashAlgorithm alg, NGConstant *ng, unsigned char *dest, static SRP_Result calculate_M(SRP_HashAlgorithm alg, NGConstant *ng, unsigned char *dest,
const char *I, const unsigned char *s_bytes, size_t s_len, const char *I, const unsigned char *s_bytes, size_t s_len, const mpz_t A,
const mpz_t A, const mpz_t B, const unsigned char *K) const mpz_t B, const unsigned char *K)
{ {
unsigned char H_N[SHA512_DIGEST_LENGTH]; unsigned char H_N[SHA512_DIGEST_LENGTH];
unsigned char H_g[SHA512_DIGEST_LENGTH]; unsigned char H_g[SHA512_DIGEST_LENGTH];
@ -493,8 +482,7 @@ static SRP_Result calculate_M(SRP_HashAlgorithm alg, NGConstant *ng, unsigned ch
hash(alg, (const unsigned char *)I, strlen(I), H_I); hash(alg, (const unsigned char *)I, strlen(I), H_I);
for (i = 0; i < hash_len; i++)
for (i = 0; i < hash_len; i++ )
H_xor[i] = H_N[i] ^ H_g[i]; H_xor[i] = H_N[i] ^ H_g[i];
hash_init(alg, &ctx); hash_init(alg, &ctx);
@ -510,7 +498,8 @@ static SRP_Result calculate_M(SRP_HashAlgorithm alg, NGConstant *ng, unsigned ch
return SRP_OK; return SRP_OK;
} }
static SRP_Result calculate_H_AMK(SRP_HashAlgorithm alg, unsigned char *dest, const mpz_t A, const unsigned char *M, const unsigned char *K) static SRP_Result calculate_H_AMK(SRP_HashAlgorithm alg, unsigned char *dest,
const mpz_t A, const unsigned char *M, const unsigned char *K)
{ {
HashCTX ctx; HashCTX ctx;
@ -537,21 +526,17 @@ static SRP_Result fill_buff()
if (!CryptAcquireContext(&wctx, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) if (!CryptAcquireContext(&wctx, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
return SRP_ERR; return SRP_ERR;
if (!CryptGenRandom(wctx, sizeof(g_rand_buff), (BYTE*) g_rand_buff)) if (!CryptGenRandom(wctx, sizeof(g_rand_buff), (BYTE *)g_rand_buff))
return SRP_ERR;
if (!CryptReleaseContext(wctx, 0))
return SRP_ERR; return SRP_ERR;
if (!CryptReleaseContext(wctx, 0)) return SRP_ERR;
#else #else
fp = fopen("/dev/urandom", "r"); fp = fopen("/dev/urandom", "r");
if (!fp) if (!fp) return SRP_ERR;
return SRP_ERR;
if (fread(g_rand_buff, sizeof(g_rand_buff), 1, fp) != 1) if (fread(g_rand_buff, sizeof(g_rand_buff), 1, fp) != 1) return SRP_ERR;
return SRP_ERR; if (fclose(fp)) return SRP_ERR;
if (fclose(fp))
return SRP_ERR;
#endif #endif
return SRP_OK; return SRP_OK;
} }
@ -560,17 +545,15 @@ static SRP_Result mpz_fill_random(mpz_t num)
{ {
// was call: BN_rand(num, 256, -1, 0); // was call: BN_rand(num, 256, -1, 0);
if (RAND_BUFF_MAX - g_rand_idx < 32) if (RAND_BUFF_MAX - g_rand_idx < 32)
if (fill_buff() != SRP_OK) if (fill_buff() != SRP_OK) return SRP_ERR;
return SRP_ERR; mpz_from_bin((const unsigned char *)(&g_rand_buff[g_rand_idx]), 32, num);
mpz_from_bin((const unsigned char *) (&g_rand_buff[g_rand_idx]), 32, num);
g_rand_idx += 32; g_rand_idx += 32;
return SRP_OK; return SRP_OK;
} }
static SRP_Result init_random() static SRP_Result init_random()
{ {
if (g_initialized) if (g_initialized) return SRP_OK;
return SRP_OK;
SRP_Result ret = fill_buff(); SRP_Result ret = fill_buff();
g_initialized = (ret == SRP_OK); g_initialized = (ret == SRP_OK);
return ret; return ret;
@ -609,8 +592,7 @@ SRP_Result srp_create_salted_verification_key( SRP_HashAlgorithm alg,
NGConstant *ng = new_ng(ng_type, n_hex, g_hex); NGConstant *ng = new_ng(ng_type, n_hex, g_hex);
if (!ng) if (!ng) goto error_and_exit;
goto error_and_exit;
if (init_random() != SRP_OK) /* Only happens once */ if (init_random() != SRP_OK) /* Only happens once */
goto error_and_exit; goto error_and_exit;
@ -619,18 +601,15 @@ SRP_Result srp_create_salted_verification_key( SRP_HashAlgorithm alg,
size_t size_to_fill = 16; size_t size_to_fill = 16;
*len_s = size_to_fill; *len_s = size_to_fill;
if (RAND_BUFF_MAX - g_rand_idx < size_to_fill) if (RAND_BUFF_MAX - g_rand_idx < size_to_fill)
if (fill_buff() != SRP_OK) if (fill_buff() != SRP_OK) goto error_and_exit;
goto error_and_exit; *bytes_s = (unsigned char *)srp_alloc(size_to_fill);
*bytes_s = (unsigned char*)srp_alloc(size_to_fill); if (!*bytes_s) goto error_and_exit;
if (!*bytes_s)
goto error_and_exit;
memcpy(*bytes_s, &g_rand_buff + g_rand_idx, size_to_fill); memcpy(*bytes_s, &g_rand_buff + g_rand_idx, size_to_fill);
g_rand_idx += size_to_fill; g_rand_idx += size_to_fill;
} }
if (!calculate_x(x, alg, *bytes_s, *len_s, username_for_verifier, password,
if (!calculate_x(x, alg, *bytes_s, *len_s, username_for_verifier, len_password))
password, len_password))
goto error_and_exit; goto error_and_exit;
srp_dbg_num(x, "Server calculated x: "); srp_dbg_num(x, "Server calculated x: ");
@ -639,15 +618,14 @@ SRP_Result srp_create_salted_verification_key( SRP_HashAlgorithm alg,
*len_v = mpz_num_bytes(v); *len_v = mpz_num_bytes(v);
*bytes_v = (unsigned char*)srp_alloc(*len_v); *bytes_v = (unsigned char *)srp_alloc(*len_v);
if (!*bytes_v) if (!*bytes_v) goto error_and_exit;
goto error_and_exit;
mpz_to_bin(v, *bytes_v); mpz_to_bin(v, *bytes_v);
cleanup_and_exit: cleanup_and_exit:
delete_ng( ng ); delete_ng(ng);
mpz_clear(v); mpz_clear(v);
mpz_clear(x); mpz_clear(x);
return ret; return ret;
@ -656,7 +634,6 @@ error_and_exit:
goto cleanup_and_exit; goto cleanup_and_exit;
} }
// clang-format off // clang-format off
/* Out: bytes_B, len_B. /* Out: bytes_B, len_B.
@ -690,13 +667,11 @@ struct SRPVerifier *srp_verifier_new(SRP_HashAlgorithm alg,
*len_B = 0; *len_B = 0;
*bytes_B = 0; *bytes_B = 0;
if (!ng) if (!ng) goto cleanup_and_exit;
goto cleanup_and_exit;
ver = (struct SRPVerifier *) srp_alloc( sizeof(struct SRPVerifier) ); ver = (struct SRPVerifier *)srp_alloc(sizeof(struct SRPVerifier));
if (!ver) if (!ver) goto cleanup_and_exit;
goto cleanup_and_exit;
if (init_random() != SRP_OK) { /* Only happens once */ if (init_random() != SRP_OK) { /* Only happens once */
srp_free(ver); srp_free(ver);
@ -704,7 +679,7 @@ struct SRPVerifier *srp_verifier_new(SRP_HashAlgorithm alg,
goto cleanup_and_exit; goto cleanup_and_exit;
} }
ver->username = (char *) srp_alloc(ulen); ver->username = (char *)srp_alloc(ulen);
ver->hash_alg = alg; ver->hash_alg = alg;
ver->ng = ng; ver->ng = ng;
@ -714,7 +689,7 @@ struct SRPVerifier *srp_verifier_new(SRP_HashAlgorithm alg,
goto cleanup_and_exit; goto cleanup_and_exit;
} }
memcpy((char*)ver->username, username, ulen); memcpy((char *)ver->username, username, ulen);
ver->authenticated = 0; ver->authenticated = 0;
@ -724,20 +699,17 @@ struct SRPVerifier *srp_verifier_new(SRP_HashAlgorithm alg,
if (bytes_b) { if (bytes_b) {
mpz_from_bin(bytes_b, len_b, b); mpz_from_bin(bytes_b, len_b, b);
} else { } else {
if (!mpz_fill_random(b)) if (!mpz_fill_random(b)) goto ver_cleanup_and_exit;
goto ver_cleanup_and_exit;
} }
if (!H_nn(k, alg, ng->N, ng->N, ng->g)) if (!H_nn(k, alg, ng->N, ng->N, ng->g)) goto ver_cleanup_and_exit;
goto ver_cleanup_and_exit;
/* B = kv + g^b */ /* B = kv + g^b */
mpz_mulm(tmp1, k, v, ng->N, tmp3); mpz_mulm(tmp1, k, v, ng->N, tmp3);
mpz_powm(tmp2, ng->g, b, ng->N); mpz_powm(tmp2, ng->g, b, ng->N);
mpz_addm(B, tmp1, tmp2, ng->N, tmp3); mpz_addm(B, tmp1, tmp2, ng->N, tmp3);
if (!H_nn(u, alg, ng->N, A, B)) if (!H_nn(u, alg, ng->N, A, B)) goto ver_cleanup_and_exit;
goto ver_cleanup_and_exit;
srp_dbg_num(u, "Server calculated u: "); srp_dbg_num(u, "Server calculated u: ");
@ -746,11 +718,10 @@ struct SRPVerifier *srp_verifier_new(SRP_HashAlgorithm alg,
mpz_mulm(tmp2, A, tmp1, ng->N, tmp3); mpz_mulm(tmp2, A, tmp1, ng->N, tmp3);
mpz_powm(S, tmp2, b, ng->N); mpz_powm(S, tmp2, b, ng->N);
if (!hash_num(alg, S, ver->session_key)) if (!hash_num(alg, S, ver->session_key)) goto ver_cleanup_and_exit;
goto ver_cleanup_and_exit;
if (!calculate_M(alg, ng, ver->M, username, bytes_s, len_s, if (!calculate_M(alg, ng, ver->M, username, bytes_s, len_s, A, B,
A, B, ver->session_key)) { ver->session_key)) {
goto ver_cleanup_and_exit; goto ver_cleanup_and_exit;
} }
if (!calculate_H_AMK(alg, ver->H_AMK, A, ver->M, ver->session_key)) { if (!calculate_H_AMK(alg, ver->H_AMK, A, ver->M, ver->session_key)) {
@ -758,7 +729,7 @@ struct SRPVerifier *srp_verifier_new(SRP_HashAlgorithm alg,
} }
*len_B = mpz_num_bytes(B); *len_B = mpz_num_bytes(B);
*bytes_B = (unsigned char*)srp_alloc(*len_B); *bytes_B = (unsigned char *)srp_alloc(*len_B);
if (!*bytes_B) { if (!*bytes_B) {
*len_B = 0; *len_B = 0;
@ -792,9 +763,6 @@ ver_cleanup_and_exit:
goto cleanup_and_exit; goto cleanup_and_exit;
} }
void srp_verifier_delete(struct SRPVerifier *ver) void srp_verifier_delete(struct SRPVerifier *ver)
{ {
if (ver) { if (ver) {
@ -806,36 +774,31 @@ void srp_verifier_delete(struct SRPVerifier *ver)
} }
} }
int srp_verifier_is_authenticated(struct SRPVerifier *ver) int srp_verifier_is_authenticated(struct SRPVerifier *ver)
{ {
return ver->authenticated; return ver->authenticated;
} }
const char *srp_verifier_get_username(struct SRPVerifier *ver) const char *srp_verifier_get_username(struct SRPVerifier *ver)
{ {
return ver->username; return ver->username;
} }
const unsigned char *srp_verifier_get_session_key(
const unsigned char *srp_verifier_get_session_key(struct SRPVerifier *ver, size_t *key_length) struct SRPVerifier *ver, size_t *key_length)
{ {
if (key_length) if (key_length) *key_length = hash_length(ver->hash_alg);
*key_length = hash_length(ver->hash_alg);
return ver->session_key; return ver->session_key;
} }
size_t srp_verifier_get_session_key_length(struct SRPVerifier *ver) size_t srp_verifier_get_session_key_length(struct SRPVerifier *ver)
{ {
return hash_length(ver->hash_alg); return hash_length(ver->hash_alg);
} }
/* user_M must be exactly SHA512_DIGEST_LENGTH bytes in size */ /* user_M must be exactly SHA512_DIGEST_LENGTH bytes in size */
void srp_verifier_verify_session(struct SRPVerifier *ver, const unsigned char *user_M, unsigned char **bytes_HAMK) void srp_verifier_verify_session(
struct SRPVerifier *ver, const unsigned char *user_M, unsigned char **bytes_HAMK)
{ {
if (memcmp(ver->M, user_M, hash_length(ver->hash_alg)) == 0) { if (memcmp(ver->M, user_M, hash_length(ver->hash_alg)) == 0) {
ver->authenticated = 1; ver->authenticated = 1;
@ -848,15 +811,14 @@ void srp_verifier_verify_session(struct SRPVerifier *ver, const unsigned char *u
struct SRPUser *srp_user_new(SRP_HashAlgorithm alg, SRP_NGType ng_type, struct SRPUser *srp_user_new(SRP_HashAlgorithm alg, SRP_NGType ng_type,
const char *username, const char *username_for_verifier, const char *username, const char *username_for_verifier,
const unsigned char *bytes_password, size_t len_password, const unsigned char *bytes_password, size_t len_password, const char *n_hex,
const char *n_hex, const char *g_hex) const char *g_hex)
{ {
struct SRPUser *usr = (struct SRPUser *) srp_alloc(sizeof(struct SRPUser)); struct SRPUser *usr = (struct SRPUser *)srp_alloc(sizeof(struct SRPUser));
size_t ulen = strlen(username) + 1; size_t ulen = strlen(username) + 1;
size_t uvlen = strlen(username_for_verifier) + 1; size_t uvlen = strlen(username_for_verifier) + 1;
if (!usr) if (!usr) goto err_exit;
goto err_exit;
if (init_random() != SRP_OK) /* Only happens once */ if (init_random() != SRP_OK) /* Only happens once */
goto err_exit; goto err_exit;
@ -868,16 +830,14 @@ struct SRPUser *srp_user_new(SRP_HashAlgorithm alg, SRP_NGType ng_type,
mpz_init(usr->A); mpz_init(usr->A);
mpz_init(usr->S); mpz_init(usr->S);
if (!usr->ng) if (!usr->ng) goto err_exit;
goto err_exit;
usr->username = (char*)srp_alloc(ulen); usr->username = (char *)srp_alloc(ulen);
usr->username_verifier = (char*)srp_alloc(uvlen); usr->username_verifier = (char *)srp_alloc(uvlen);
usr->password = (unsigned char*)srp_alloc(len_password); usr->password = (unsigned char *)srp_alloc(len_password);
usr->password_len = len_password; usr->password_len = len_password;
if (!usr->username || !usr->password || !usr->username_verifier) if (!usr->username || !usr->password || !usr->username_verifier) goto err_exit;
goto err_exit;
memcpy(usr->username, username, ulen); memcpy(usr->username, username, ulen);
memcpy(usr->username_verifier, username_for_verifier, uvlen); memcpy(usr->username_verifier, username_for_verifier, uvlen);
@ -894,8 +854,7 @@ err_exit:
mpz_clear(usr->a); mpz_clear(usr->a);
mpz_clear(usr->A); mpz_clear(usr->A);
mpz_clear(usr->S); mpz_clear(usr->S);
if (usr->ng) if (usr->ng) delete_ng(usr->ng);
delete_ng(usr->ng);
srp_free(usr->username); srp_free(usr->username);
srp_free(usr->username_verifier); srp_free(usr->username_verifier);
if (usr->password) { if (usr->password) {
@ -908,11 +867,9 @@ err_exit:
return 0; return 0;
} }
void srp_user_delete(struct SRPUser *usr) void srp_user_delete(struct SRPUser *usr)
{ {
if(usr) { if (usr) {
mpz_clear(usr->a); mpz_clear(usr->a);
mpz_clear(usr->A); mpz_clear(usr->A);
mpz_clear(usr->S); mpz_clear(usr->S);
@ -925,36 +882,29 @@ void srp_user_delete(struct SRPUser *usr)
srp_free(usr->username_verifier); srp_free(usr->username_verifier);
srp_free(usr->password); srp_free(usr->password);
if (usr->bytes_A) if (usr->bytes_A) srp_free(usr->bytes_A);
srp_free(usr->bytes_A);
memset(usr, 0, sizeof(*usr)); memset(usr, 0, sizeof(*usr));
srp_free(usr); srp_free(usr);
} }
} }
int srp_user_is_authenticated(struct SRPUser *usr) int srp_user_is_authenticated(struct SRPUser *usr)
{ {
return usr->authenticated; return usr->authenticated;
} }
const char *srp_user_get_username(struct SRPUser *usr) const char *srp_user_get_username(struct SRPUser *usr)
{ {
return usr->username; return usr->username;
} }
const unsigned char *srp_user_get_session_key(struct SRPUser *usr, size_t *key_length)
const unsigned char* srp_user_get_session_key(struct SRPUser* usr, size_t* key_length)
{ {
if (key_length) if (key_length) *key_length = hash_length(usr->hash_alg);
*key_length = hash_length(usr->hash_alg);
return usr->session_key; return usr->session_key;
} }
size_t srp_user_get_session_key_length(struct SRPUser *usr) size_t srp_user_get_session_key_length(struct SRPUser *usr)
{ {
return hash_length(usr->hash_alg); return hash_length(usr->hash_alg);
@ -970,23 +920,20 @@ SRP_Result srp_user_start_authentication(struct SRPUser *usr, char **username,
if (bytes_a) { if (bytes_a) {
mpz_from_bin(bytes_a, len_a, usr->a); mpz_from_bin(bytes_a, len_a, usr->a);
} else { } else {
if (!mpz_fill_random(usr->a)) if (!mpz_fill_random(usr->a)) goto error_and_exit;
goto error_and_exit;
} }
mpz_powm(usr->A, usr->ng->g, usr->a, usr->ng->N); mpz_powm(usr->A, usr->ng->g, usr->a, usr->ng->N);
*len_A = mpz_num_bytes(usr->A); *len_A = mpz_num_bytes(usr->A);
*bytes_A = (unsigned char*)srp_alloc(*len_A); *bytes_A = (unsigned char *)srp_alloc(*len_A);
if (!*bytes_A) if (!*bytes_A) goto error_and_exit;
goto error_and_exit;
mpz_to_bin(usr->A, *bytes_A); mpz_to_bin(usr->A, *bytes_A);
usr->bytes_A = *bytes_A; usr->bytes_A = *bytes_A;
if (username) if (username) *username = usr->username;
*username = usr->username;
return SRP_OK; return SRP_OK;
@ -997,7 +944,6 @@ error_and_exit:
return SRP_ERR; return SRP_ERR;
} }
// clang-format off // clang-format off
/* Output: bytes_M. Buffer length is SHA512_DIGEST_LENGTH */ /* Output: bytes_M. Buffer length is SHA512_DIGEST_LENGTH */
void srp_user_process_challenge(struct SRPUser *usr, void srp_user_process_challenge(struct SRPUser *usr,
@ -1019,13 +965,12 @@ void srp_user_process_challenge(struct SRPUser *usr,
*len_M = 0; *len_M = 0;
*bytes_M = 0; *bytes_M = 0;
if (!H_nn(u, usr->hash_alg, usr->ng->N, usr->A, B)) if (!H_nn(u, usr->hash_alg, usr->ng->N, usr->A, B)) goto cleanup_and_exit;
goto cleanup_and_exit;
srp_dbg_num(u, "Client calculated u: "); srp_dbg_num(u, "Client calculated u: ");
if (!calculate_x(x, usr->hash_alg, bytes_s, len_s, if (!calculate_x(x, usr->hash_alg, bytes_s, len_s, usr->username_verifier,
usr->username_verifier, usr->password, usr->password_len)) usr->password, usr->password_len))
goto cleanup_and_exit; goto cleanup_and_exit;
srp_dbg_num(x, "Client calculated x: "); srp_dbg_num(x, "Client calculated x: ");
@ -1034,7 +979,7 @@ void srp_user_process_challenge(struct SRPUser *usr,
goto cleanup_and_exit; goto cleanup_and_exit;
/* SRP-6a safety check */ /* SRP-6a safety check */
if ( mpz_sgn(B) != 0 && mpz_sgn(u) != 0 ) { if (mpz_sgn(B) != 0 && mpz_sgn(u) != 0) {
mpz_powm(v, usr->ng->g, x, usr->ng->N); mpz_powm(v, usr->ng->g, x, usr->ng->N);
srp_dbg_num(v, "Client calculated v: "); srp_dbg_num(v, "Client calculated v: ");
@ -1052,20 +997,18 @@ void srp_user_process_challenge(struct SRPUser *usr,
if (!hash_num(usr->hash_alg, usr->S, usr->session_key)) if (!hash_num(usr->hash_alg, usr->S, usr->session_key))
goto cleanup_and_exit; goto cleanup_and_exit;
if (!calculate_M(usr->hash_alg, usr->ng, usr->M, usr->username, bytes_s, len_s, if (!calculate_M(usr->hash_alg, usr->ng, usr->M, usr->username, bytes_s,
usr->A, B, usr->session_key)) len_s, usr->A, B, usr->session_key))
goto cleanup_and_exit; goto cleanup_and_exit;
if (!calculate_H_AMK(usr->hash_alg, usr->H_AMK, if (!calculate_H_AMK(
usr->A, usr->M, usr->session_key)) usr->hash_alg, usr->H_AMK, usr->A, usr->M, usr->session_key))
goto cleanup_and_exit; goto cleanup_and_exit;
*bytes_M = usr->M; *bytes_M = usr->M;
if (len_M) if (len_M) *len_M = hash_length(usr->hash_alg);
*len_M = hash_length( usr->hash_alg );
} else { } else {
*bytes_M = NULL; *bytes_M = NULL;
if (len_M) if (len_M) *len_M = 0;
*len_M = 0;
} }
cleanup_and_exit: cleanup_and_exit:
@ -1080,7 +1023,6 @@ cleanup_and_exit:
mpz_clear(tmp4); mpz_clear(tmp4);
} }
void srp_user_verify_session(struct SRPUser *usr, const unsigned char *bytes_HAMK) void srp_user_verify_session(struct SRPUser *usr, const unsigned char *bytes_HAMK)
{ {
if (memcmp(usr->H_AMK, bytes_HAMK, hash_length(usr->hash_alg)) == 0) if (memcmp(usr->H_AMK, bytes_HAMK, hash_length(usr->hash_alg)) == 0)

47
srp.h
View File

@ -56,12 +56,10 @@
#ifndef SRP_H #ifndef SRP_H
#define SRP_H #define SRP_H
struct SRPVerifier; struct SRPVerifier;
struct SRPUser; struct SRPUser;
typedef enum typedef enum {
{
SRP_NG_1024, SRP_NG_1024,
SRP_NG_2048, SRP_NG_2048,
SRP_NG_4096, SRP_NG_4096,
@ -69,8 +67,7 @@ typedef enum
SRP_NG_CUSTOM SRP_NG_CUSTOM
} SRP_NGType; } SRP_NGType;
typedef enum typedef enum {
{
SRP_SHA1, SRP_SHA1,
/*SRP_SHA224,*/ /*SRP_SHA224,*/
SRP_SHA256, SRP_SHA256,
@ -78,8 +75,7 @@ typedef enum
SRP_SHA512*/ SRP_SHA512*/
} SRP_HashAlgorithm; } SRP_HashAlgorithm;
typedef enum typedef enum {
{
SRP_ERR, SRP_ERR,
SRP_OK, SRP_OK,
} SRP_Result; } SRP_Result;
@ -137,48 +133,43 @@ struct SRPVerifier* srp_verifier_new(SRP_HashAlgorithm alg, SRP_NGType ng_type,
// clang-format on // clang-format on
void srp_verifier_delete(struct SRPVerifier *ver);
void srp_verifier_delete( struct SRPVerifier* ver );
// srp_verifier_verify_session must have been called before // srp_verifier_verify_session must have been called before
int srp_verifier_is_authenticated( struct SRPVerifier* ver ); int srp_verifier_is_authenticated(struct SRPVerifier *ver);
const char *srp_verifier_get_username(struct SRPVerifier *ver);
const char * srp_verifier_get_username( struct SRPVerifier* ver );
/* key_length may be null */ /* key_length may be null */
const unsigned char* srp_verifier_get_session_key( struct SRPVerifier* ver, const unsigned char *srp_verifier_get_session_key(
size_t *key_length ); struct SRPVerifier *ver, size_t *key_length);
size_t srp_verifier_get_session_key_length(struct SRPVerifier* ver);
size_t srp_verifier_get_session_key_length(struct SRPVerifier *ver);
/* Verifies session, on success, it writes bytes_HAMK. /* Verifies session, on success, it writes bytes_HAMK.
* user_M must be exactly srp_verifier_get_session_key_length() bytes in size * user_M must be exactly srp_verifier_get_session_key_length() bytes in size
*/ */
void srp_verifier_verify_session( struct SRPVerifier* ver, void srp_verifier_verify_session(
const unsigned char* user_M, unsigned char** bytes_HAMK ); struct SRPVerifier *ver, const unsigned char *user_M, unsigned char **bytes_HAMK);
/*******************************************************************************/ /*******************************************************************************/
/* The n_hex and g_hex parameters should be 0 unless SRP_NG_CUSTOM is used for ng_type */ /* The n_hex and g_hex parameters should be 0 unless SRP_NG_CUSTOM is used for ng_type */
struct SRPUser *srp_user_new(SRP_HashAlgorithm alg, SRP_NGType ng_type, struct SRPUser *srp_user_new(SRP_HashAlgorithm alg, SRP_NGType ng_type,
const char *username, const char *username_for_verifier, const char *username, const char *username_for_verifier,
const unsigned char *bytes_password, size_t len_password, const unsigned char *bytes_password, size_t len_password, const char *n_hex,
const char *n_hex, const char *g_hex); const char *g_hex);
void srp_user_delete(struct SRPUser * usr); void srp_user_delete(struct SRPUser *usr);
int srp_user_is_authenticated(struct SRPUser * usr); int srp_user_is_authenticated(struct SRPUser *usr);
const char *srp_user_get_username(struct SRPUser *usr);
const char* srp_user_get_username(struct SRPUser * usr);
/* key_length may be null */ /* key_length may be null */
const unsigned char* srp_user_get_session_key(struct SRPUser* usr, size_t* key_length); const unsigned char *srp_user_get_session_key(struct SRPUser *usr, size_t *key_length);
size_t srp_user_get_session_key_length(struct SRPUser* usr); size_t srp_user_get_session_key_length(struct SRPUser *usr);
// clang-format off // clang-format off
@ -198,6 +189,6 @@ void srp_user_process_challenge(struct SRPUser *usr,
// clang-format on // clang-format on
/* bytes_HAMK must be exactly srp_user_get_session_key_length() bytes in size */ /* bytes_HAMK must be exactly srp_user_get_session_key_length() bytes in size */
void srp_user_verify_session(struct SRPUser* usr, const unsigned char* bytes_HAMK); void srp_user_verify_session(struct SRPUser *usr, const unsigned char *bytes_HAMK);
#endif /* Include Guard */ #endif /* Include Guard */

181
test_srp.c
View File

@ -3,13 +3,11 @@
#include <string.h> #include <string.h>
#include <sys/time.h> #include <sys/time.h>
#include "srp.h" #include "srp.h"
#define NITER 100
#define NITER 100 #define TEST_HASH SRP_SHA256
#define TEST_HASH SRP_SHA256 #define TEST_NG SRP_NG_1024
#define TEST_NG SRP_NG_1024
unsigned long long get_usec() unsigned long long get_usec()
{ {
@ -22,93 +20,71 @@ unsigned long long get_usec()
// https://tools.ietf.org/html/rfc5054#appendix-B // https://tools.ietf.org/html/rfc5054#appendix-B
static const char srp_5054_salt[] = { static const char srp_5054_salt[] = {
0xBE, 0xB2, 0x53, 0x79, 0xD1, 0xA8, 0x58, 0x1E, 0xBE, 0xB2, 0x53, 0x79, 0xD1, 0xA8, 0x58, 0x1E, 0xB5, 0xA7, 0x27, 0x67, 0x3A,
0xB5, 0xA7, 0x27, 0x67, 0x3A, 0x24, 0x41, 0xEE, 0x24, 0x41, 0xEE,
}; };
static const char srp_5054_v[] = { static const char srp_5054_v[] = {
0x7E, 0x27, 0x3D, 0xE8, 0x69, 0x6F, 0xFC, 0x4F, 0x7E, 0x27, 0x3D, 0xE8, 0x69, 0x6F, 0xFC, 0x4F, 0x4E, 0x33, 0x7D, 0x05, 0xB4,
0x4E, 0x33, 0x7D, 0x05, 0xB4, 0xB3, 0x75, 0xBE, 0xB3, 0x75, 0xBE, 0xB0, 0xDD, 0xE1, 0x56, 0x9E, 0x8F, 0xA0, 0x0A, 0x98, 0x86,
0xB0, 0xDD, 0xE1, 0x56, 0x9E, 0x8F, 0xA0, 0x0A, 0xD8, 0x12, 0x9B, 0xAD, 0xA1, 0xF1, 0x82, 0x22, 0x23, 0xCA, 0x1A, 0x60, 0x5B,
0x98, 0x86, 0xD8, 0x12, 0x9B, 0xAD, 0xA1, 0xF1, 0x53, 0x0E, 0x37, 0x9B, 0xA4, 0x72, 0x9F, 0xDC, 0x59, 0xF1, 0x05, 0xB4, 0x78,
0x82, 0x22, 0x23, 0xCA, 0x1A, 0x60, 0x5B, 0x53, 0x7E, 0x51, 0x86, 0xF5, 0xC6, 0x71, 0x08, 0x5A, 0x14, 0x47, 0xB5, 0x2A, 0x48,
0x0E, 0x37, 0x9B, 0xA4, 0x72, 0x9F, 0xDC, 0x59, 0xCF, 0x19, 0x70, 0xB4, 0xFB, 0x6F, 0x84, 0x00, 0xBB, 0xF4, 0xCE, 0xBF, 0xBB,
0xF1, 0x05, 0xB4, 0x78, 0x7E, 0x51, 0x86, 0xF5, 0x16, 0x81, 0x52, 0xE0, 0x8A, 0xB5, 0xEA, 0x53, 0xD1, 0x5C, 0x1A, 0xFF, 0x87,
0xC6, 0x71, 0x08, 0x5A, 0x14, 0x47, 0xB5, 0x2A, 0xB2, 0xB9, 0xDA, 0x6E, 0x04, 0xE0, 0x58, 0xAD, 0x51, 0xCC, 0x72, 0xBF, 0xC9,
0x48, 0xCF, 0x19, 0x70, 0xB4, 0xFB, 0x6F, 0x84, 0x03, 0x3B, 0x56, 0x4E, 0x26, 0x48, 0x0D, 0x78, 0xE9, 0x55, 0xA5, 0xE2, 0x9E,
0x00, 0xBB, 0xF4, 0xCE, 0xBF, 0xBB, 0x16, 0x81, 0x7A, 0xB2, 0x45, 0xDB, 0x2B, 0xE3, 0x15, 0xE2, 0x09, 0x9A, 0xFB,
0x52, 0xE0, 0x8A, 0xB5, 0xEA, 0x53, 0xD1, 0x5C,
0x1A, 0xFF, 0x87, 0xB2, 0xB9, 0xDA, 0x6E, 0x04,
0xE0, 0x58, 0xAD, 0x51, 0xCC, 0x72, 0xBF, 0xC9,
0x03, 0x3B, 0x56, 0x4E, 0x26, 0x48, 0x0D, 0x78,
0xE9, 0x55, 0xA5, 0xE2, 0x9E, 0x7A, 0xB2, 0x45,
0xDB, 0x2B, 0xE3, 0x15, 0xE2, 0x09, 0x9A, 0xFB,
}; };
static const char srp_5054_a[] = { static const char srp_5054_a[] = {
0x60, 0x97, 0x55, 0x27, 0x03, 0x5C, 0xF2, 0xAD, 0x60, 0x97, 0x55, 0x27, 0x03, 0x5C, 0xF2, 0xAD, 0x19, 0x89, 0x80, 0x6F, 0x04,
0x19, 0x89, 0x80, 0x6F, 0x04, 0x07, 0x21, 0x0B, 0x07, 0x21, 0x0B, 0xC8, 0x1E, 0xDC, 0x04, 0xE2, 0x76, 0x2A, 0x56, 0xAF, 0xD5,
0xC8, 0x1E, 0xDC, 0x04, 0xE2, 0x76, 0x2A, 0x56, 0x29, 0xDD, 0xDA, 0x2D, 0x43, 0x93,
0xAF, 0xD5, 0x29, 0xDD, 0xDA, 0x2D, 0x43, 0x93,
}; };
static const char srp_5054_A[] = { static const char srp_5054_A[] = {
0x61, 0xD5, 0xE4, 0x90, 0xF6, 0xF1, 0xB7, 0x95, 0x61, 0xD5, 0xE4, 0x90, 0xF6, 0xF1, 0xB7, 0x95, 0x47, 0xB0, 0x70, 0x4C, 0x43,
0x47, 0xB0, 0x70, 0x4C, 0x43, 0x6F, 0x52, 0x3D, 0x6F, 0x52, 0x3D, 0xD0, 0xE5, 0x60, 0xF0, 0xC6, 0x41, 0x15, 0xBB, 0x72, 0x55,
0xD0, 0xE5, 0x60, 0xF0, 0xC6, 0x41, 0x15, 0xBB, 0x7E, 0xC4, 0x43, 0x52, 0xE8, 0x90, 0x32, 0x11, 0xC0, 0x46, 0x92, 0x27, 0x2D,
0x72, 0x55, 0x7E, 0xC4, 0x43, 0x52, 0xE8, 0x90, 0x8B, 0x2D, 0x1A, 0x53, 0x58, 0xA2, 0xCF, 0x1B, 0x6E, 0x0B, 0xFC, 0xF9, 0x9F,
0x32, 0x11, 0xC0, 0x46, 0x92, 0x27, 0x2D, 0x8B, 0x92, 0x15, 0x30, 0xEC, 0x8E, 0x39, 0x35, 0x61, 0x79, 0xEA, 0xE4, 0x5E, 0x42,
0x2D, 0x1A, 0x53, 0x58, 0xA2, 0xCF, 0x1B, 0x6E, 0xBA, 0x92, 0xAE, 0xAC, 0xED, 0x82, 0x51, 0x71, 0xE1, 0xE8, 0xB9, 0xAF, 0x6D,
0x0B, 0xFC, 0xF9, 0x9F, 0x92, 0x15, 0x30, 0xEC, 0x9C, 0x03, 0xE1, 0x32, 0x7F, 0x44, 0xBE, 0x08, 0x7E, 0xF0, 0x65, 0x30, 0xE6,
0x8E, 0x39, 0x35, 0x61, 0x79, 0xEA, 0xE4, 0x5E, 0x9F, 0x66, 0x61, 0x52, 0x61, 0xEE, 0xF5, 0x40, 0x73, 0xCA, 0x11, 0xCF, 0x58,
0x42, 0xBA, 0x92, 0xAE, 0xAC, 0xED, 0x82, 0x51, 0x58, 0xF0, 0xED, 0xFD, 0xFE, 0x15, 0xEF, 0xEA, 0xB3, 0x49, 0xEF, 0x5D, 0x76,
0x71, 0xE1, 0xE8, 0xB9, 0xAF, 0x6D, 0x9C, 0x03, 0x98, 0x8A, 0x36, 0x72, 0xFA, 0xC4, 0x7B, 0x07, 0x69, 0x44, 0x7B,
0xE1, 0x32, 0x7F, 0x44, 0xBE, 0x08, 0x7E, 0xF0,
0x65, 0x30, 0xE6, 0x9F, 0x66, 0x61, 0x52, 0x61,
0xEE, 0xF5, 0x40, 0x73, 0xCA, 0x11, 0xCF, 0x58,
0x58, 0xF0, 0xED, 0xFD, 0xFE, 0x15, 0xEF, 0xEA,
0xB3, 0x49, 0xEF, 0x5D, 0x76, 0x98, 0x8A, 0x36,
0x72, 0xFA, 0xC4, 0x7B, 0x07, 0x69, 0x44, 0x7B,
}; };
static const char srp_5054_b[] = { static const char srp_5054_b[] = {
0xE4, 0x87, 0xCB, 0x59, 0xD3, 0x1A, 0xC5, 0x50, 0xE4, 0x87, 0xCB, 0x59, 0xD3, 0x1A, 0xC5, 0x50, 0x47, 0x1E, 0x81, 0xF0, 0x0F,
0x47, 0x1E, 0x81, 0xF0, 0x0F, 0x69, 0x28, 0xE0, 0x69, 0x28, 0xE0, 0x1D, 0xDA, 0x08, 0xE9, 0x74, 0xA0, 0x04, 0xF4, 0x9E, 0x61,
0x1D, 0xDA, 0x08, 0xE9, 0x74, 0xA0, 0x04, 0xF4, 0xF5, 0xD1, 0x05, 0x28, 0x4D, 0x20,
0x9E, 0x61, 0xF5, 0xD1, 0x05, 0x28, 0x4D, 0x20,
}; };
static const char srp_5054_B[] = { static const char srp_5054_B[] = {
0xBD, 0x0C, 0x61, 0x51, 0x2C, 0x69, 0x2C, 0x0C, 0xBD, 0x0C, 0x61, 0x51, 0x2C, 0x69, 0x2C, 0x0C, 0xB6, 0xD0, 0x41, 0xFA, 0x01,
0xB6, 0xD0, 0x41, 0xFA, 0x01, 0xBB, 0x15, 0x2D, 0xBB, 0x15, 0x2D, 0x49, 0x16, 0xA1, 0xE7, 0x7A, 0xF4, 0x6A, 0xE1, 0x05, 0x39,
0x49, 0x16, 0xA1, 0xE7, 0x7A, 0xF4, 0x6A, 0xE1, 0x30, 0x11, 0xBA, 0xF3, 0x89, 0x64, 0xDC, 0x46, 0xA0, 0x67, 0x0D, 0xD1, 0x25,
0x05, 0x39, 0x30, 0x11, 0xBA, 0xF3, 0x89, 0x64, 0xB9, 0x5A, 0x98, 0x16, 0x52, 0x23, 0x6F, 0x99, 0xD9, 0xB6, 0x81, 0xCB, 0xF8,
0xDC, 0x46, 0xA0, 0x67, 0x0D, 0xD1, 0x25, 0xB9, 0x78, 0x37, 0xEC, 0x99, 0x6C, 0x6D, 0xA0, 0x44, 0x53, 0x72, 0x86, 0x10, 0xD0,
0x5A, 0x98, 0x16, 0x52, 0x23, 0x6F, 0x99, 0xD9, 0xC6, 0xDD, 0xB5, 0x8B, 0x31, 0x88, 0x85, 0xD7, 0xD8, 0x2C, 0x7F, 0x8D, 0xEB,
0xB6, 0x81, 0xCB, 0xF8, 0x78, 0x37, 0xEC, 0x99, 0x75, 0xCE, 0x7B, 0xD4, 0xFB, 0xAA, 0x37, 0x08, 0x9E, 0x6F, 0x9C, 0x60, 0x59,
0x6C, 0x6D, 0xA0, 0x44, 0x53, 0x72, 0x86, 0x10, 0xF3, 0x88, 0x83, 0x8E, 0x7A, 0x00, 0x03, 0x0B, 0x33, 0x1E, 0xB7, 0x68, 0x40,
0xD0, 0xC6, 0xDD, 0xB5, 0x8B, 0x31, 0x88, 0x85, 0x91, 0x04, 0x40, 0xB1, 0xB2, 0x7A, 0xAE, 0xAE, 0xEB, 0x40, 0x12, 0xB7, 0xD7,
0xD7, 0xD8, 0x2C, 0x7F, 0x8D, 0xEB, 0x75, 0xCE, 0x66, 0x52, 0x38, 0xA8, 0xE3, 0xFB, 0x00, 0x4B, 0x11, 0x7B, 0x58,
0x7B, 0xD4, 0xFB, 0xAA, 0x37, 0x08, 0x9E, 0x6F,
0x9C, 0x60, 0x59, 0xF3, 0x88, 0x83, 0x8E, 0x7A,
0x00, 0x03, 0x0B, 0x33, 0x1E, 0xB7, 0x68, 0x40,
0x91, 0x04, 0x40, 0xB1, 0xB2, 0x7A, 0xAE, 0xAE,
0xEB, 0x40, 0x12, 0xB7, 0xD7, 0x66, 0x52, 0x38,
0xA8, 0xE3, 0xFB, 0x00, 0x4B, 0x11, 0x7B, 0x58,
}; };
// This isn't used (yet) // This isn't used (yet)
static const char srp_5054_u[] = { static const char srp_5054_u[] = {
0xCE, 0x38, 0xB9, 0x59, 0x34, 0x87, 0xDA, 0x98, 0xCE, 0x38, 0xB9, 0x59, 0x34, 0x87, 0xDA, 0x98, 0x55, 0x4E, 0xD4, 0x7D, 0x70,
0x55, 0x4E, 0xD4, 0x7D, 0x70, 0xA7, 0xAE, 0x5F, 0xA7, 0xAE, 0x5F, 0x46, 0x2E, 0xF0, 0x19,
0x46, 0x2E, 0xF0, 0x19,
}; };
// This is SHA-1(<premaster secret>) // This is SHA-1(<premaster secret>)
static const char srp_5054_S[] = { static const char srp_5054_S[] = {
0x01, 0x7e, 0xef, 0xa1, 0xce, 0xfc, 0x5c, 0x2e, 0x01, 0x7e, 0xef, 0xa1, 0xce, 0xfc, 0x5c, 0x2e, 0x62, 0x6e, 0x21, 0x59, 0x89,
0x62, 0x6e, 0x21, 0x59, 0x89, 0x87, 0xf3, 0x1e, 0x87, 0xf3, 0x1e, 0x0f, 0x1b, 0x11, 0xbb,
0x0f, 0x1b, 0x11, 0xbb,
}; };
int test_rfc_5054_compat() int test_rfc_5054_compat()
@ -119,13 +95,13 @@ int test_rfc_5054_compat()
unsigned char *bytes_s = 0; unsigned char *bytes_s = 0;
bytes_s = malloc(sizeof(srp_5054_salt)); bytes_s = malloc(sizeof(srp_5054_salt));
memcpy(bytes_s, srp_5054_salt, sizeof(srp_5054_salt)); memcpy(bytes_s, srp_5054_salt, sizeof(srp_5054_salt));
unsigned char * bytes_v = 0; unsigned char *bytes_v = 0;
unsigned char * bytes_A = 0; unsigned char *bytes_A = 0;
unsigned char * bytes_B = 0; unsigned char *bytes_B = 0;
unsigned char * bytes_M = 0; unsigned char *bytes_M = 0;
unsigned char * bytes_HAMK = 0; unsigned char *bytes_HAMK = 0;
const unsigned char * bytes_S = 0; const unsigned char *bytes_S = 0;
size_t len_s = 16; size_t len_s = 16;
size_t len_v = 0; size_t len_v = 0;
@ -138,24 +114,24 @@ int test_rfc_5054_compat()
const char *password = "password123"; const char *password = "password123";
SRP_HashAlgorithm alg = SRP_SHA1; SRP_HashAlgorithm alg = SRP_SHA1;
SRP_NGType ng_type = SRP_NG_1024; //TEST_NG; SRP_NGType ng_type = SRP_NG_1024; // TEST_NG;
printf("Testing RFC 5054 test vectors..."); printf("Testing RFC 5054 test vectors...");
srp_create_salted_verification_key(alg, ng_type, username, srp_create_salted_verification_key(alg, ng_type, username,
(const unsigned char *)password, (const unsigned char *)password, strlen(password), &bytes_s, &len_s,
strlen(password), &bytes_s, &len_s, &bytes_v, &len_v, NULL, NULL ); &bytes_v, &len_v, NULL, NULL);
if (len_v != 128 || memcmp(&srp_5054_v, bytes_v, len_v) != 0) { if (len_v != 128 || memcmp(&srp_5054_v, bytes_v, len_v) != 0) {
printf(" computed v doesn't match!\n"); printf(" computed v doesn't match!\n");
return 1; return 1;
} }
usr = srp_user_new(alg, ng_type, username, username, usr = srp_user_new(alg, ng_type, username, username,
(const unsigned char *)password, (const unsigned char *)password, strlen(password), NULL, NULL);
strlen(password), NULL, NULL);
srp_user_start_authentication(usr, NULL, (unsigned char*)srp_5054_a, 32, &bytes_A, &len_A); srp_user_start_authentication(
usr, NULL, (unsigned char *)srp_5054_a, 32, &bytes_A, &len_A);
if (memcmp(&srp_5054_A, bytes_A, len_A) != 0) { if (memcmp(&srp_5054_A, bytes_A, len_A) != 0) {
printf(" computed A doesn't match!\n"); printf(" computed A doesn't match!\n");
@ -163,9 +139,9 @@ int test_rfc_5054_compat()
} }
/* User -> Host: (username, bytes_A) */ /* User -> Host: (username, bytes_A) */
ver = srp_verifier_new(alg, ng_type, username, (unsigned char*)srp_5054_salt, ver = srp_verifier_new(alg, ng_type, username, (unsigned char *)srp_5054_salt,
len_s, bytes_v, len_v, bytes_A, len_A, (unsigned char*)srp_5054_b, 32, &bytes_B, len_s, bytes_v, len_v, bytes_A, len_A, (unsigned char *)srp_5054_b, 32,
&len_B, NULL, NULL); &bytes_B, &len_B, NULL, NULL);
if (!bytes_B) { if (!bytes_B) {
printf(" SRP-6a safety check violated for B!\n"); printf(" SRP-6a safety check violated for B!\n");
@ -177,9 +153,9 @@ int test_rfc_5054_compat()
return 1; return 1;
} }
/* Host -> User: (bytes_s, bytes_B) */ /* Host -> User: (bytes_s, bytes_B) */
srp_user_process_challenge(usr, (unsigned char*)srp_5054_salt, len_s, bytes_B,len_B, &bytes_M, &len_M); srp_user_process_challenge(usr, (unsigned char *)srp_5054_salt, len_s, bytes_B,
len_B, &bytes_M, &len_M);
if (!bytes_M) { if (!bytes_M) {
printf(" SRP-6a safety check violated for M!\n"); printf(" SRP-6a safety check violated for M!\n");
@ -220,14 +196,14 @@ cleanup:
return 0; return 0;
} }
const char * test_n_hex = const char *test_n_hex =
"EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C9C256576D674DF7496" "EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C9C256576D674DF7496"
"EA81D3383B4813D692C6E0E0D5D8E250B98BE48E495C1D6089DAD15DC7D7B46154D6B6CE8E" "EA81D3383B4813D692C6E0E0D5D8E250B98BE48E495C1D6089DAD15DC7D7B46154D6B6CE8E"
"F4AD69B15D4982559B297BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA" "F4AD69B15D4982559B297BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA"
"9AFD5138FE8376435B9FC61D2FC0EB06E3"; "9AFD5138FE8376435B9FC61D2FC0EB06E3";
const char * test_g_hex = "2"; const char *test_g_hex = "2";
int main(int argc, char * argv[]) int main(int argc, char *argv[])
{ {
test_rfc_5054_compat(); test_rfc_5054_compat();
printf("Performing the speedtest, %d iterations.\n", NITER); printf("Performing the speedtest, %d iterations.\n", NITER);
@ -261,7 +237,7 @@ int main(int argc, char * argv[])
const char *g_hex = 0; const char *g_hex = 0;
SRP_HashAlgorithm alg = TEST_HASH; SRP_HashAlgorithm alg = TEST_HASH;
SRP_NGType ng_type = SRP_NG_8192; //TEST_NG; SRP_NGType ng_type = SRP_NG_8192; // TEST_NG;
if (ng_type == SRP_NG_CUSTOM) { if (ng_type == SRP_NG_CUSTOM) {
n_hex = test_n_hex; n_hex = test_n_hex;
@ -269,26 +245,25 @@ int main(int argc, char * argv[])
} }
if (srp_create_salted_verification_key(alg, ng_type, ver_unam, if (srp_create_salted_verification_key(alg, ng_type, ver_unam,
(const unsigned char *)password, strlen(password), (const unsigned char *)password, strlen(password), &bytes_s, &len_s,
&bytes_s, &len_s, &bytes_v, &len_v, n_hex, g_hex) != SRP_OK) &bytes_v, &len_v, n_hex, g_hex) != SRP_OK)
return 1; return 1;
start = get_usec(); start = get_usec();
for (i = 0; i < NITER; i++) { for (i = 0; i < NITER; i++) {
usr = srp_user_new(alg, ng_type, username, ver_unam, usr = srp_user_new(alg, ng_type, username, ver_unam,
(const unsigned char *)password, (const unsigned char *)password, strlen(password), n_hex, g_hex);
strlen(password), n_hex, g_hex);
if (srp_user_start_authentication(usr, NULL, NULL, 0, &bytes_A, &len_A) != SRP_OK) { if (srp_user_start_authentication(usr, NULL, NULL, 0, &bytes_A, &len_A) !=
SRP_OK) {
printf("Error while starting SRP-6a authentication!\n"); printf("Error while starting SRP-6a authentication!\n");
goto cleanup; goto cleanup;
} }
/* User -> Host: (username, bytes_A) */ /* User -> Host: (username, bytes_A) */
ver = srp_verifier_new(alg, ng_type, username, bytes_s, len_s, bytes_v, len_v, ver = srp_verifier_new(alg, ng_type, username, bytes_s, len_s, bytes_v,
bytes_A, len_A, NULL, 0, & bytes_B, &len_B, n_hex, g_hex); len_v, bytes_A, len_A, NULL, 0, &bytes_B, &len_B, n_hex, g_hex);
if (!bytes_B) { if (!bytes_B) {
printf("Verifier SRP-6a safety check violated!\n"); printf("Verifier SRP-6a safety check violated!\n");
@ -296,7 +271,8 @@ int main(int argc, char * argv[])
} }
/* Host -> User: (bytes_s, bytes_B) */ /* Host -> User: (bytes_s, bytes_B) */
srp_user_process_challenge(usr, bytes_s, len_s, bytes_B, len_B, &bytes_M, &len_M); srp_user_process_challenge(
usr, bytes_s, len_s, bytes_B, len_B, &bytes_M, &len_M);
if (!bytes_M) { if (!bytes_M) {
printf("User SRP-6a safety check violation!\n"); printf("User SRP-6a safety check violation!\n");
@ -318,7 +294,7 @@ int main(int argc, char * argv[])
printf("Server authentication failed!\n"); printf("Server authentication failed!\n");
} }
cleanup: cleanup:
srp_verifier_delete(ver); srp_verifier_delete(ver);
srp_user_delete(usr); srp_user_delete(usr);
} }
@ -327,7 +303,6 @@ cleanup:
printf("Usec per login sequence: %d\n", (int)(duration / NITER)); printf("Usec per login sequence: %d\n", (int)(duration / NITER));
free((char *)bytes_s); free((char *)bytes_s);
free((char *)bytes_v); free((char *)bytes_v);