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

47
srp.h
View File

@ -56,12 +56,10 @@
#ifndef SRP_H
#define SRP_H
struct SRPVerifier;
struct SRPUser;
typedef enum
{
typedef enum {
SRP_NG_1024,
SRP_NG_2048,
SRP_NG_4096,
@ -69,8 +67,7 @@ typedef enum
SRP_NG_CUSTOM
} SRP_NGType;
typedef enum
{
typedef enum {
SRP_SHA1,
/*SRP_SHA224,*/
SRP_SHA256,
@ -78,8 +75,7 @@ typedef enum
SRP_SHA512*/
} SRP_HashAlgorithm;
typedef enum
{
typedef enum {
SRP_ERR,
SRP_OK,
} SRP_Result;
@ -137,48 +133,43 @@ struct SRPVerifier* srp_verifier_new(SRP_HashAlgorithm alg, SRP_NGType ng_type,
// 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
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 */
const unsigned char* srp_verifier_get_session_key( struct SRPVerifier* ver,
size_t *key_length );
size_t srp_verifier_get_session_key_length(struct SRPVerifier* ver);
const unsigned char *srp_verifier_get_session_key(
struct SRPVerifier *ver, size_t *key_length);
size_t srp_verifier_get_session_key_length(struct SRPVerifier *ver);
/* Verifies session, on success, it writes bytes_HAMK.
* user_M must be exactly srp_verifier_get_session_key_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);
/*******************************************************************************/
/* 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,
const char *username, const char *username_for_verifier,
const unsigned char *bytes_password, size_t len_password,
const char *n_hex, const char *g_hex);
const unsigned char *bytes_password, size_t len_password, const char *n_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 */
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
@ -198,6 +189,6 @@ void srp_user_process_challenge(struct SRPUser *usr,
// clang-format on
/* 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 */

181
test_srp.c
View File

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