void meteor_user_generate_M_string( struct SRPUser *usr,
const char * S_str,
unsigned char *buff,
const char * B_str,
char ** M_str )
{
BIGNUM *M = BN_new();
char *ABS = malloc( strlen(usr->Astr) + strlen(B_str) + strlen(S_str) + 1 );
strcpy(ABS, usr->Astr);
strcat(ABS, B_str);
strcat(ABS, S_str);
hash( usr->hash_alg, (const unsigned char *)ABS, strlen(ABS), buff );
M = BN_bin2bn( buff, hash_length(usr->hash_alg), NULL );
if ( !M )
goto cleanup_and_exit;
*M_str = convert_to_lower( BN_bn2hex(M) );
cleanup_and_exit:
BN_free(M);
}
/* Output: username, bytes_A, len_A, Astr */
void srp_user_start_authentication( struct SRPUser * usr, const char ** username,
const unsigned char ** bytes_A, int * len_A, const char ** Astr )
{
BN_CTX *ctx = BN_CTX_new();
BN_rand(usr->a, 256, -1, 0);
BN_mod_exp(usr->A, usr->ng->g, usr->a, usr->ng->N, ctx);
BN_CTX_free(ctx);
*len_A = BN_num_bytes(usr->A);
*bytes_A = malloc( *len_A );
if (!*bytes_A)
{
*len_A = 0;
*bytes_A = 0;
*username = 0;
return;
}
BN_bn2bin( usr->A, (unsigned char *) *bytes_A );
usr->bytes_A = *bytes_A;
usr->Astr = convert_to_lower( BN_bn2hex(usr->A) );
*Astr = usr->Astr;
*username = usr->username;
}
void meteor_user_generate_S_string( struct SRPUser *usr,
BN_CTX * ctx,
BIGNUM * kgx,
BIGNUM * aux,
const char * B_str,
char ** S_str)
{
BIGNUM *B = BN_new();
BIGNUM *bkgx = BN_new();
BIGNUM *S = BN_new();
BN_hex2bn( &B, B_str );
if ( !B )
goto cleanup_and_exit;
BN_sub( bkgx, B, kgx );
if ( !bkgx )
goto cleanup_and_exit;
BN_mod_exp(S, bkgx, aux, usr->ng->N, ctx);
if ( !S )
goto cleanup_and_exit;
*S_str = convert_to_lower( BN_bn2hex(S) );
cleanup_and_exit:
BN_free(B);
BN_free(bkgx);
BN_free(S);
}
void meteor_user_generate_x(SRPUser *usr,
char const *identity,
char const *salt,
char const *password,
unsigned char *buff,
BIGNUM **x) {
const static char *static_delim = ":";
BIGNUM *x_inner;
char *catString_i_p = malloc(strlen(identity)+1 + strlen(static_delim)+ 1 + strlen(password)+1 + 1);
strcpy(catString_i_p, identity);
strcat(catString_i_p, static_delim);
strcat(catString_i_p, password);
catString_i_p[strlen(catString_i_p)] = '\0';
unsigned char lbuff[SHA256_DIGEST_LENGTH] = "";
hash(usr->hash_alg, (const unsigned char *)catString_i_p, strlen(catString_i_p), lbuff);
x_inner = BN_bin2bn(lbuff, hash_length(usr->hash_alg), NULL);
char *x_inner_str_lower = convert_to_lower(BN_bn2hex(x_inner));
char *catString_s_i_p = malloc(strlen(salt)+1 + strlen(x_inner_str_lower)+1 + 1);
strcpy(catString_s_i_p, salt);
strcat(catString_s_i_p, x_inner_str_lower);
catString_s_i_p[strlen(catString_s_i_p)] = '\0';
unsigned char xbuff[SHA256_DIGEST_LENGTH] = "";
hash(usr->hash_alg, (const unsigned char *)catString_s_i_p, strlen((char *)catString_s_i_p), xbuff);
*x = BN_bin2bn(xbuff, hash_length(usr->hash_alg), NULL);
BN_free(x_inner);
free(catString_i_p);
free(catString_s_i_p);
}
void meteor_user_generate_HAMK( struct SRPUser *usr,
unsigned char *buff,
const char * M_str,
const char * S_str )
{
char * AMS = malloc( strlen(usr->Astr) + strlen(M_str) + strlen(S_str) + 1 );
strcpy( AMS, usr->Astr );
strcat( AMS, M_str );
strcat( AMS, S_str );
hash( usr->hash_alg, (const unsigned char *)AMS, strlen(AMS), buff );
usr->HAMK = convert_to_lower( BN_bn2hex(BN_bin2bn(buff, hash_length(usr->hash_alg), NULL)) );
}
void meteor_user_generate_S_string(SRPUser *usr,
BN_CTX *ctx,
BIGNUM *kgx,
BIGNUM *aux,
const char *B_str,
char **S_str) {
BN_CTX *lctx = BN_CTX_new();
BIGNUM *B = BN_new();
BIGNUM *bkgx = BN_new();
BIGNUM *S = BN_new();
BN_hex2bn(&B, B_str);
BN_sub(bkgx, B, kgx);
BN_mod_exp(S, bkgx, aux, usr->ng->N, lctx);
*S_str = convert_to_lower(BN_bn2hex(S));
usr->Sstr = convert_to_lower(BN_bn2hex(S));
BN_free(B);
BN_free(bkgx);
BN_free(S);
BN_CTX_free(lctx);
}
inline unsigned short
month_str_to_ushort(std::string const& s) {
if((s.at(0) >= '0') && (s.at(0) <= '9')) {
return boost::lexical_cast<unsigned short>(s);
}
else {
std::string str = convert_to_lower(s);
typename month_type::month_map_ptr_type ptr = month_type::get_month_map_ptr();
typename month_type::month_map_type::iterator iter = ptr->find(str);
if(iter != ptr->end()) { // required for STLport
return iter->second;
}
}
return 13; // intentionally out of range - name not found
}
void meteor_user_generate_k( struct SRPUser *usr,
unsigned char *buff,
BIGNUM **k )
{
char * N_str = BN_bn2hex( usr->ng->N );
// generator (g) is always 0x02 but bn2hex represents string as 02 and meteor (javascript) lib represents as 2
// so hard coding this value to 2 to be able to generate what meteor expects us to
const char * g_str = "2";
char * cat_string_n_g = malloc( strlen(N_str) + strlen(g_str) + 1 );
strcpy( cat_string_n_g, N_str );
strcat( cat_string_n_g, g_str );
const char * ng = convert_to_lower( cat_string_n_g );
hash( usr->hash_alg, (const unsigned char *)ng, strlen(ng), buff );
*k = BN_bin2bn( buff, hash_length(usr->hash_alg), NULL );
}
int main(int argc, char **argv) {
Node *head = create_node("", 0, 0);
char **filenames = init_filenames();
char ch, line[MAXLINE], *token;
char *indexfile = "index";
char *namefile = "filenames";
FILE *fp;
while((ch = getopt(argc, argv, "i:n:")) != -1) {
switch (ch) {
case 'i':
indexfile = optarg;
break;
case 'n':
namefile = optarg;
break;
default:
fprintf(stderr, "Usage: indexfile [-i FILE] [-n FILE ] FILE...\n");
exit(1);
}
}
while (optind < argc) {
if ( (fp = fopen(argv[optind], "r")) == NULL) {
fprintf(stderr, "Cannot open file %s.\n", argv[optind]);
}
else {
while ( fgets(line, MAXLINE, fp) != NULL ) {
token = strtok(line, DELIM);
for(; token != NULL ;) {
add_word(head, filenames, convert_to_lower(token), argv[optind]);
token = strtok(NULL, DELIM);
}
}
fclose(fp);
}
optind++;
}
write_list(namefile, indexfile, head, filenames);
return 0;
}
/* Output: username, bytes_A, len_A, Astr */
const char * srp_user_start_authentication(SRPUser *usr) {
BN_CTX *ctx = BN_CTX_new();
BN_mod_exp(usr->A, usr->ng->g, usr->a, usr->ng->N, ctx);
BIGNUM *modCheck = BN_new();
BN_mod(modCheck, usr->A, usr->ng->N, ctx);
BN_free(modCheck);
BN_CTX_free(ctx);
int len_A = BN_num_bytes(usr->A);
unsigned char *bytes_A = malloc(len_A);
BN_bn2bin(usr->A, bytes_A);
usr->bytes_A = bytes_A;
usr->Astr = convert_to_lower(BN_bn2hex(usr->A));
free(bytes_A);
return usr->Astr;
}
const char * meteor_user_generate_M_string(SRPUser *usr,
const char *S_str,
unsigned char *buff,
const char *B_str) {
BIGNUM *M = BN_new();
char *ABS = malloc(strlen(usr->Astr)+1 + strlen(B_str)+1 + strlen(S_str)+1 + 1);
strcpy(ABS, usr->Astr);
strcat(ABS, B_str);
strcat(ABS, usr->Sstr);
ABS[strlen(ABS)] = '\0';
unsigned char lbuff[SHA256_DIGEST_LENGTH] = "";
hash(usr->hash_alg, (const unsigned char *)ABS, strlen(ABS), lbuff);
M = BN_bin2bn(lbuff, hash_length(usr->hash_alg), NULL);
free(ABS);
return convert_to_lower(BN_bn2hex(M));
}
/* Return a case-INsensitive hash of buf. */
unsigned int tm_ihash(str_char *buf, unsigned int table_size)
{
unsigned int result = 0;
unsigned int word;
int done;
str_char *rest_of_buf;
ASSERT(buf);
ASSERT(table_size > 0);
rest_of_buf = buf;
do
{
next_word(&rest_of_buf, &word, &done);
convert_to_lower(&word);
result += word;
}
while(!done);
return(result % table_size);
}
void meteor_user_generate_k( SRPUser *usr,
unsigned char *buff,
BIGNUM **k ) {
char *N_str = BN_bn2hex(usr->ng->N);
// generator (g) is always 0x02 but bn2hex represents
// string as 02 and meteor (javascript) lib represents as 2
// so hard coding this value to 2 to be able to generate
// what meteor expects
static const char *g_str = "2";
char *cat_string_n_g = malloc(strlen(N_str)+1 + strlen(g_str)+1 + 1);
strcpy(cat_string_n_g, N_str);
strcat(cat_string_n_g, g_str);
cat_string_n_g[strlen(cat_string_n_g)] = '\0';
char *ng = convert_to_lower(cat_string_n_g);
unsigned char lbuff[SHA256_DIGEST_LENGTH] = "";
hash(usr->hash_alg, (const unsigned char *)ng, strlen(ng), lbuff);
*k = BN_bin2bn(lbuff, hash_length(usr->hash_alg), NULL);
free(cat_string_n_g);
}
void meteor_user_generate_x( struct SRPUser *usr,
char const *identity,
char const *salt,
char const *password,
unsigned char *buff,
BIGNUM **x )
{
const char * static_delim = ":";
BIGNUM * x_inner = 0;
const unsigned char * catString_i_p = malloc(strlen(identity) + strlen(password) + 1);
strcpy((char *)catString_i_p, identity);
strcat((char *)catString_i_p, static_delim);
strcat((char *)catString_i_p, password);
hash( usr->hash_alg, catString_i_p, strlen((char *)catString_i_p), buff );
x_inner = BN_bin2bn(buff, hash_length(usr->hash_alg), NULL);
if ( !x_inner )
goto cleanup_and_exit;
// x_innerStr should now equal salt value
const char * x_inner_str = BN_bn2hex(x_inner);
char * x_inner_str_lower = convert_to_lower(x_inner_str);
const unsigned char * catString_s_i_p = malloc(strlen(salt) + strlen(x_inner_str_lower) + 1);
strcpy((char *)catString_s_i_p, salt);
strcat((char *)catString_s_i_p, x_inner_str_lower);
hash( usr->hash_alg, catString_s_i_p, strlen((char *)catString_s_i_p), buff );
*x = BN_bin2bn(buff, hash_length(usr->hash_alg), NULL);
cleanup_and_exit:
BN_free( x_inner );
}
int main(int argc, char** argv)
{
int ret = 0, option = 0, long_index = 0;
int i;
if (argc == 1) {
printf("Main Help.\n");
wolfCLU_help();
}
/* flexibility: allow users to input any CAPS or lower case,
* we will do all processing on lower case only. */
for (i = 0; i < argc; i++) {
convert_to_lower(argv[i], (int) XSTRLEN(argv[i]));
}
while ((option = getopt_long_only(argc, argv,"",
long_options, &long_index )) != -1) {
switch (option) {
/* Encrypt */
case ENCRYPT: ret = wolfCLU_setup(argc, argv, 'e');
break;
/* Decrypt */
case DECRYPT: ret = wolfCLU_setup(argc, argv, 'd');;
break;
/* Benchmark */
case BENCHMARK:ret = wolfCLU_benchSetup(argc, argv);
break;
/* Hash */
case HASH: ret = wolfCLU_hashSetup(argc, argv);
break;
/* x509 Certificate processing */
case X509: ret = wolfCLU_certSetup(argc, argv);
break;
/* x509 Certificate request */
case REQUEST: ret = wolfCLU_requestSetup(argc, argv);
break;
/* Ignore the following arguments for now. Will be handled by their respective
* setups IE Crypto setup, Benchmark setup, or Hash Setup */
/* File passed in by user */
case INFILE: break;
/* Output file */
case OUTFILE: break;
/* Password */
case PASSWORD: break;
/* Key if used must be in hex */
case KEY: break;
/* IV if used must be in hex */
case IV: break;
/* Opt to benchmark all available algorithms */
case ALL: break;
/* size for hash to output */
case SIZE: break;
/* Time to benchmark for 1-10 seconds optional default: 3s */
case TIME: break;
/* Verify results, used with -iv and -key */
case VERIFY: break;
/* Certificate Stuff*/
case INFORM: break;
case OUTFORM: break;
case NOOUT: break;
case TEXT_OUT: break;
case SILENT: break;
case HELP1:
if (argc == 2) {
printf("Main help menu:\n");
wolfCLU_help();
return 0;
}
break;
case HELP2:
if (argc == 2) {
printf("Main help menu:\n");
wolfCLU_help();
return 0;
}
break;
/* which version of clu am I using */
case VERBOSE:
wolfCLU_verboseHelp();
return 0;
/*End of ignored arguments */
case 'v': wolfCLU_version();
return 0;
default:
printf("Main help default.\n");
wolfCLU_help();
return 0;
}
}
if (ret != 0)
printf("Error returned: %d.\n", ret);
return ret;
}
