mkp224o/main.c

885 lines
20 KiB
C
Raw Normal View History

2017-10-06 03:21:00 +02:00
#ifdef __linux__
#define _POSIX_C_SOURCE 200112L
#endif
2017-09-24 21:13:16 +02:00
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <pthread.h>
2017-09-25 19:49:47 +02:00
#include <signal.h>
2017-09-27 20:38:15 +02:00
#include <sodium/randombytes.h>
2018-05-31 16:01:33 +02:00
#include <sodium/utils.h>
2017-09-24 21:13:16 +02:00
#include "types.h"
2017-09-27 20:38:15 +02:00
#include "likely.h"
2017-09-24 21:13:16 +02:00
#include "vec.h"
#include "base32.h"
2017-10-06 02:14:33 +02:00
#include "cpucount.h"
2017-09-24 21:13:16 +02:00
#include "keccak.h"
2017-10-02 16:11:23 +02:00
#include "ed25519/ed25519.h"
#include "ioutil.h"
2018-07-09 18:38:41 +02:00
#include "common.h"
#include "yaml.h"
2017-09-24 21:13:16 +02:00
2018-02-22 01:46:06 +01:00
#ifndef _WIN32
#define FSZ "%zu"
#else
#define FSZ "%Iu"
#endif
2017-10-23 06:29:37 +02:00
// additional 0 terminator is added by C
2017-09-24 21:13:16 +02:00
static const char * const pkprefix = "== ed25519v1-public: type0 ==\0\0";
static const char * const skprefix = "== ed25519v1-secret: type0 ==\0\0";
2018-07-09 18:38:41 +02:00
static const char checksumstr[] = ".onion checksum";
2018-07-09 18:38:41 +02:00
#define checksumstrlen (sizeof(checksumstr) - 1) // 15
2017-09-24 21:13:16 +02:00
// output directory
static char *workdir = 0;
static size_t workdirlen = 0;
static int quietflag = 0;
2018-01-20 20:55:45 +01:00
//static int wantdedup = 0;
#define wantdedup 0
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
// 0, direndpos, onionendpos
// printstartpos = either 0 or direndpos
// printlen = either onionendpos + 1 or ONION_LEN + 1 (additional 1 is for newline)
size_t onionendpos; // end of .onion within string
size_t direndpos; // end of dir before .onion within string
size_t printstartpos; // where to start printing from
size_t printlen; // precalculated, related to printstartpos
2017-09-24 21:13:16 +02:00
static int yamloutput = 0;
2017-10-22 07:07:45 +02:00
static int numwords = 1;
2018-07-09 18:38:41 +02:00
static size_t numneedgenerate = 0;
2017-09-25 19:49:47 +02:00
static pthread_mutex_t keysgenerated_mutex;
2017-09-24 21:13:16 +02:00
static volatile size_t keysgenerated = 0;
2017-09-25 19:49:47 +02:00
static volatile int endwork = 0;
2018-07-09 18:38:41 +02:00
pthread_mutex_t fout_mutex;
FILE *fout;
2017-09-25 19:49:47 +02:00
static void termhandler(int sig)
{
switch (sig) {
case SIGTERM:
case SIGINT:
endwork = 1;
break;
}
}
2017-09-24 21:13:16 +02:00
2018-01-20 16:33:28 +01:00
#include "filters.h"
2017-09-25 22:57:27 +02:00
2017-10-22 02:40:23 +02:00
#ifdef STATISTICS
#define ADDNUMSUCCESS ++st->numsuccess.v
#else
2017-10-22 07:07:45 +02:00
#define ADDNUMSUCCESS do ; while (0)
2017-10-22 02:40:23 +02:00
#endif
2017-09-30 05:40:12 +02:00
// statistics, if enabled
#ifdef STATISTICS
struct statstruct {
union {
2017-10-06 02:25:51 +02:00
u32 v;
size_t align;
} numcalc;
2017-09-30 05:40:12 +02:00
union {
2017-10-06 02:25:51 +02:00
u32 v;
size_t align;
} numsuccess;
union {
u32 v;
size_t align;
} numrestart;
2017-09-30 05:40:12 +02:00
} ;
VEC_STRUCT(statsvec,struct statstruct);
struct tstatstruct {
u64 numcalc;
u64 numsuccess;
u64 numrestart;
2017-09-30 05:40:12 +02:00
u32 oldnumcalc;
u32 oldnumsuccess;
u32 oldnumrestart;
2017-09-30 05:40:12 +02:00
} ;
VEC_STRUCT(tstatsvec,struct tstatstruct);
#endif
2018-05-31 16:01:33 +02:00
static void onionready(char *sname,const u8 *secret,const u8 *pubonion)
2017-09-24 21:13:16 +02:00
{
2017-09-25 19:49:47 +02:00
if (endwork)
2017-09-24 21:13:16 +02:00
return;
2017-09-25 19:49:47 +02:00
if (numneedgenerate) {
pthread_mutex_lock(&keysgenerated_mutex);
if (keysgenerated >= numneedgenerate) {
pthread_mutex_unlock(&keysgenerated_mutex);
return;
}
++keysgenerated;
2018-07-09 18:38:41 +02:00
if (keysgenerated == numneedgenerate)
2017-09-25 19:49:47 +02:00
endwork = 1;
pthread_mutex_unlock(&keysgenerated_mutex);
}
2018-07-09 18:38:41 +02:00
if (!yamloutput) {
if (createdir(sname,1) != 0) {
pthread_mutex_lock(&fout_mutex);
fprintf(stderr,"ERROR: could not create directory for key output\n");
pthread_mutex_unlock(&fout_mutex);
return;
}
2017-09-25 19:49:47 +02:00
2018-07-09 18:38:41 +02:00
strcpy(&sname[onionendpos],"/hs_ed25519_secret_key");
writetofile(sname,secret,FORMATTED_SECRET_LEN,1);
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
strcpy(&sname[onionendpos],"/hs_ed25519_public_key");
writetofile(sname,pubonion,FORMATTED_PUBLIC_LEN,0);
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
strcpy(&sname[onionendpos],"/hostname");
FILE *hfile = fopen(sname,"w");
2017-09-30 05:40:12 +02:00
sname[onionendpos] = '\n';
2018-07-09 18:38:41 +02:00
if (hfile) {
fwrite(&sname[direndpos],ONION_LEN + 1,1,hfile);
fclose(hfile);
}
if (fout) {
pthread_mutex_lock(&fout_mutex);
fwrite(&sname[printstartpos],printlen,1,fout);
fflush(fout);
pthread_mutex_unlock(&fout_mutex);
}
} else
yamlout_writekeys(&sname[direndpos],pubonion,secret);
}
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
union pubonionunion {
u8 raw[PKPREFIX_SIZE + PUBLIC_LEN + 32];
struct {
u64 prefix[4];
u64 key[4];
u64 hash[4];
} i;
} ;
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
static char *makesname()
{
char *sname = (char *) malloc(workdirlen + ONION_LEN + 63 + 1);
if (!sname)
abort();
if (workdir)
memcpy(sname,workdir,workdirlen);
return sname;
2017-09-24 21:13:16 +02:00
}
// little endian inc
2017-10-23 07:13:13 +02:00
static void addsk32(u8 *sk)
2017-09-24 21:13:16 +02:00
{
2017-10-23 07:13:13 +02:00
register unsigned int c = 8;
for (size_t i = 0;i < 32;++i) {
c = (unsigned int)sk[i] + c; sk[i] = c & 0xFF; c >>= 8;
2017-09-24 21:13:16 +02:00
// unsure if needed
if (!c) break;
}
}
2017-10-22 07:07:45 +02:00
// 0123 4567 xxxx --3--> 3456 7xxx
// 0123 4567 xxxx --1--> 1234 567x
static inline void shiftpk(u8 *dst,const u8 *src,size_t sbits)
{
size_t i,sbytes = sbits / 8;
sbits %= 8;
2017-10-22 07:13:52 +02:00
for (i = 0;i + sbytes < PUBLIC_LEN;++i) {
2018-02-23 01:03:17 +01:00
dst[i] = (u8) ((src[i+sbytes] << sbits) |
(src[i+sbytes+1] >> (8 - sbits)));
2017-10-22 07:07:45 +02:00
}
for(;i < PUBLIC_LEN;++i)
dst[i] = 0;
}
2017-09-24 21:13:16 +02:00
static void *dowork(void *task)
{
2018-07-09 18:38:41 +02:00
union pubonionunion pubonion;
u8 * const pk = &pubonion.raw[PKPREFIX_SIZE];
u8 secret[SKPREFIX_SIZE + SECRET_LEN];
u8 * const sk = &secret[SKPREFIX_SIZE];
2017-09-24 21:13:16 +02:00
u8 seed[SEED_LEN];
u8 hashsrc[checksumstrlen + PUBLIC_LEN + 1];
2017-10-22 07:07:45 +02:00
u8 wpk[PUBLIC_LEN + 1];
2017-09-24 21:13:16 +02:00
size_t i;
char *sname;
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
struct statstruct *st = (struct statstruct *)task;
#endif
2018-01-20 20:55:45 +01:00
PREFILTER
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
memcpy(secret,skprefix,SKPREFIX_SIZE);
2017-10-22 13:10:13 +02:00
wpk[PUBLIC_LEN] = 0;
2017-10-22 07:07:45 +02:00
memset(&pubonion,0,sizeof(pubonion));
2018-07-09 18:38:41 +02:00
memcpy(pubonion.raw,pkprefix,PKPREFIX_SIZE);
2017-09-29 20:18:41 +02:00
// write version later as it will be overwritten by hash
2017-09-24 23:52:17 +02:00
memcpy(hashsrc,checksumstr,checksumstrlen);
2017-09-24 21:13:16 +02:00
hashsrc[checksumstrlen + PUBLIC_LEN] = 0x03; // version
2018-07-09 18:38:41 +02:00
sname = makesname();
2017-09-24 21:13:16 +02:00
initseed:
2017-09-24 23:52:17 +02:00
randombytes(seed,sizeof(seed));
2017-10-23 07:13:13 +02:00
ed25519_seckey_expand(sk,seed);
#ifdef STATISTICS
++st->numrestart.v;
#endif
2017-09-24 21:13:16 +02:00
again:
2017-09-27 20:38:15 +02:00
if (unlikely(endwork))
2017-09-24 21:13:16 +02:00
goto end;
ed25519_pubkey(pk,sk);
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
2017-10-06 02:25:51 +02:00
++st->numcalc.v;
2017-09-30 05:40:12 +02:00
#endif
2017-10-10 03:02:43 +02:00
DOFILTER(i,pk,{
2017-10-22 07:07:45 +02:00
if (numwords > 1) {
shiftpk(wpk,pk,filter_len(i));
size_t j;
for (int w = 1;;) {
DOFILTER(j,wpk,goto secondfind);
2017-10-22 13:10:13 +02:00
goto next;
2017-10-22 07:07:45 +02:00
secondfind:
if (++w >= numwords)
break;
shiftpk(wpk,wpk,filter_len(j));
}
}
2017-10-23 07:13:13 +02:00
// sanity check
if ((sk[0] & 248) != sk[0] || ((sk[31] & 63) | 64) != sk[31])
goto initseed;
2017-10-22 07:07:45 +02:00
2017-10-22 02:40:23 +02:00
ADDNUMSUCCESS;
2017-10-10 03:02:43 +02:00
// calc checksum
memcpy(&hashsrc[checksumstrlen],pk,PUBLIC_LEN);
FIPS202_SHA3_256(hashsrc,sizeof(hashsrc),&pk[PUBLIC_LEN]);
// version byte
pk[PUBLIC_LEN + 2] = 0x03;
// base32
2018-05-31 16:01:33 +02:00
strcpy(base32_to(&sname[direndpos],pk,PUBONION_LEN),".onion");
2017-10-23 07:13:13 +02:00
onionready(sname,secret,pubonion.raw);
2017-10-22 13:10:13 +02:00
pk[PUBLIC_LEN] = 0;
2017-10-10 03:02:43 +02:00
goto initseed;
});
2017-10-22 13:10:13 +02:00
next:
2017-10-23 07:13:13 +02:00
addsk32(sk);
2017-09-24 21:13:16 +02:00
goto again;
end:
2017-09-25 19:49:47 +02:00
free(sname);
2018-01-20 20:55:45 +01:00
POSTFILTER
2018-05-31 16:01:33 +02:00
sodium_memzero(secret,sizeof(secret));
sodium_memzero(seed,sizeof(seed));
2017-09-24 21:13:16 +02:00
return 0;
}
2017-10-22 13:35:45 +02:00
static void addsztoscalar32(u8 *dst,size_t v)
2017-09-24 21:13:16 +02:00
{
int i;
u32 c = 0;
for (i = 0;i < 32;++i) {
2017-09-30 05:40:12 +02:00
c += *dst + (v & 0xFF); *dst = c & 0xFF; c >>= 8;
2017-09-24 21:13:16 +02:00
v >>= 8;
2017-09-30 05:40:12 +02:00
++dst;
2017-09-24 21:13:16 +02:00
}
}
static void *dofastwork(void *task)
{
2018-07-09 18:38:41 +02:00
union pubonionunion pubonion;
u8 * const pk = &pubonion.raw[PKPREFIX_SIZE];
u8 secret[SKPREFIX_SIZE + SECRET_LEN];
u8 * const sk = &secret[SKPREFIX_SIZE];
2017-09-24 21:13:16 +02:00
u8 seed[SEED_LEN];
u8 hashsrc[checksumstrlen + PUBLIC_LEN + 1];
2017-10-22 07:07:45 +02:00
u8 wpk[PUBLIC_LEN + 1];
2017-09-24 21:13:16 +02:00
ge_p3 ge_public;
size_t counter;
2017-09-24 21:13:16 +02:00
size_t i;
char *sname;
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
struct statstruct *st = (struct statstruct *)task;
#endif
2018-01-20 20:55:45 +01:00
PREFILTER
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
memcpy(secret,skprefix,SKPREFIX_SIZE);
2017-10-22 13:10:13 +02:00
wpk[PUBLIC_LEN] = 0;
2017-10-22 07:07:45 +02:00
memset(&pubonion,0,sizeof(pubonion));
2018-07-09 18:38:41 +02:00
memcpy(pubonion.raw,pkprefix,PKPREFIX_SIZE);
2017-09-29 20:18:41 +02:00
// write version later as it will be overwritten by hash
2017-10-23 07:13:13 +02:00
memcpy(hashsrc,checksumstr,checksumstrlen);
2017-09-24 21:13:16 +02:00
hashsrc[checksumstrlen + PUBLIC_LEN] = 0x03; // version
2018-07-09 18:38:41 +02:00
sname = makesname();
2017-09-24 21:13:16 +02:00
initseed:
#ifdef STATISTICS
++st->numrestart.v;
#endif
2017-09-24 23:52:17 +02:00
randombytes(seed,sizeof(seed));
ed25519_seckey_expand(sk,seed);
2017-09-24 21:13:16 +02:00
ge_scalarmult_base(&ge_public,sk);
2017-09-24 23:52:17 +02:00
ge_p3_tobytes(pk,&ge_public);
for (counter = 0;counter < SIZE_MAX-8;counter += 8) {
2017-09-24 21:13:16 +02:00
ge_p1p1 sum;
2017-09-27 20:38:15 +02:00
if (unlikely(endwork))
2017-09-24 21:13:16 +02:00
goto end;
2017-10-10 03:02:43 +02:00
DOFILTER(i,pk,{
2017-10-22 07:07:45 +02:00
if (numwords > 1) {
shiftpk(wpk,pk,filter_len(i));
size_t j;
for (int w = 1;;) {
DOFILTER(j,wpk,goto secondfind);
2017-10-22 13:10:13 +02:00
goto next;
2017-10-22 07:07:45 +02:00
secondfind:
if (++w >= numwords)
break;
shiftpk(wpk,wpk,filter_len(j));
}
}
2017-10-10 03:02:43 +02:00
// found!
// update secret key with counter
2017-10-22 13:35:45 +02:00
addsztoscalar32(sk,counter);
2017-10-10 03:02:43 +02:00
// sanity check
2017-10-23 07:13:13 +02:00
if ((sk[0] & 248) != sk[0] || ((sk[31] & 63) | 64) != sk[31])
2017-10-22 02:40:23 +02:00
goto initseed;
ADDNUMSUCCESS;
2017-10-10 03:02:43 +02:00
// calc checksum
memcpy(&hashsrc[checksumstrlen],pk,PUBLIC_LEN);
FIPS202_SHA3_256(hashsrc,sizeof(hashsrc),&pk[PUBLIC_LEN]);
// version byte
pk[PUBLIC_LEN + 2] = 0x03;
// full name
strcpy(base32_to(&sname[direndpos],pk,PUBONION_LEN),".onion");
onionready(sname,secret,pubonion.raw);
2017-10-22 13:10:13 +02:00
pk[PUBLIC_LEN] = 0;
2017-10-10 03:02:43 +02:00
// don't reuse same seed
goto initseed;
});
2017-10-22 13:10:13 +02:00
next:
2017-09-24 23:52:17 +02:00
ge_add(&sum, &ge_public,&ge_eightpoint);
ge_p1p1_to_p3(&ge_public,&sum);
ge_p3_tobytes(pk,&ge_public);
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
2017-10-06 02:25:51 +02:00
++st->numcalc.v;
2017-09-30 05:40:12 +02:00
#endif
2017-09-24 21:13:16 +02:00
}
goto initseed;
end:
2017-09-25 19:49:47 +02:00
free(sname);
2018-01-20 20:55:45 +01:00
POSTFILTER
2018-05-31 16:01:33 +02:00
sodium_memzero(secret,sizeof(secret));
sodium_memzero(seed,sizeof(seed));
2017-09-24 21:13:16 +02:00
return 0;
}
static void printhelp(FILE *out,const char *progname)
2017-09-24 21:13:16 +02:00
{
fprintf(out,
2017-09-24 21:13:16 +02:00
"Usage: %s filter [filter...] [options]\n"
" %s -f filterfile [options]\n"
"Options:\n"
2018-05-31 16:01:33 +02:00
"\t-h - print help to stdout and quit\n"
2017-09-24 21:13:16 +02:00
"\t-f - instead of specifying filter(s) via commandline, specify filter file which contains filters separated by newlines\n"
"\t-q - do not print diagnostic output to stderr\n"
"\t-x - do not print onion names\n"
"\t-o filename - output onion names to specified file (append)\n"
"\t-O filename - output onion names to specified file (overwrite)\n"
2017-09-24 21:13:16 +02:00
"\t-F - include directory names in onion names output\n"
"\t-d dirname - output directory\n"
"\t-t numthreads - specify number of threads (default - auto)\n"
2017-09-30 05:40:12 +02:00
"\t-j numthreads - same as -t\n"
2017-09-24 21:13:16 +02:00
"\t-n numkeys - specify number of keys (default - 0 - unlimited)\n"
2017-10-22 07:07:45 +02:00
"\t-N numwords - specify number of words per key (default - 1)\n"
2017-09-30 14:43:32 +02:00
"\t-z - use faster key generation method. this is now default\n"
"\t-Z - use slower key generation method\n"
2017-09-30 05:40:12 +02:00
"\t-s - print statistics each 10 seconds\n"
"\t-S t - print statistics every specified ammount of seconds\n"
2017-09-30 14:43:32 +02:00
"\t-T - do not reset statistics counters when printing\n"
"\t-y - output generated keys in yaml format instead of dumping them to filesystem\n"
2018-07-09 19:00:51 +02:00
"\t-Y [filename [host.onion]] - parse yaml encoded input and extract key(s) to filesystem\n"
2017-09-24 21:13:16 +02:00
,progname,progname);
fflush(out);
2017-09-24 21:13:16 +02:00
}
2018-05-31 16:01:33 +02:00
enum {
Q_ADDITIONAL = 101,
Q_UNRECOGNISED,
Q_NOSTATISTICS,
Q_FAILOPENOUTPUT,
Q_FAILTHREAD,
Q_FAILTIME,
2018-07-09 18:38:41 +02:00
Q_FAILOPENINPUT,
2018-05-31 16:01:33 +02:00
} ;
static void e_additional()
{
fprintf(stderr,"additional argument required\n");
exit(Q_ADDITIONAL);
}
#ifndef STATISTICS
static void e_nostatistics()
{
fprintf(stderr,"statistics support not compiled in\n");
exit(Q_NOSTATISTICS);
}
#endif
static void setworkdir(const char *wd)
2017-09-24 21:13:16 +02:00
{
free(workdir);
size_t l = strlen(wd);
if (!l) {
workdir = 0;
workdirlen = 0;
if (!quietflag)
2018-05-31 16:01:33 +02:00
fprintf(stderr,"unset workdir\n");
2017-09-24 21:13:16 +02:00
return;
}
2018-02-23 01:03:17 +01:00
unsigned needslash = 0;
2017-09-24 21:13:16 +02:00
if (wd[l-1] != '/')
needslash = 1;
2018-06-16 15:22:52 +02:00
char *s = (char *) malloc(l + needslash + 1);
2017-10-10 03:02:43 +02:00
if (!s)
abort();
2018-05-31 16:01:33 +02:00
memcpy(s,wd,l);
2017-09-24 21:13:16 +02:00
if (needslash)
s[l++] = '/';
s[l] = 0;
2017-09-24 21:13:16 +02:00
workdir = s;
workdirlen = l;
if (!quietflag)
2017-09-30 05:40:12 +02:00
fprintf(stderr,"set workdir: %s\n",workdir);
2017-09-24 21:13:16 +02:00
}
VEC_STRUCT(threadvec, pthread_t);
2017-09-30 05:40:12 +02:00
int main(int argc,char **argv)
2017-09-24 21:13:16 +02:00
{
2018-05-31 18:14:35 +02:00
const char *outfile = 0;
2018-07-09 18:38:41 +02:00
const char *infile = 0;
const char *hostname = 0;
2017-09-24 21:13:16 +02:00
const char *arg;
int ignoreargs = 0;
int dirnameflag = 0;
int numthreads = 0;
2017-09-30 14:43:32 +02:00
int fastkeygen = 1;
2018-07-09 18:38:41 +02:00
int yamlinput = 0;
int outfileoverwrite = 0;
2017-09-24 21:13:16 +02:00
struct threadvec threads;
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
struct statsvec stats;
struct tstatsvec tstats;
u64 reportdelay = 0;
2017-09-30 14:43:32 +02:00
int realtimestats = 1;
2017-09-30 05:46:17 +02:00
#endif
2017-09-24 21:13:16 +02:00
int tret;
2017-10-02 16:11:23 +02:00
ge_initeightpoint();
2017-09-24 21:13:16 +02:00
filters_init();
setvbuf(stderr,0,_IONBF,0);
2017-09-24 21:13:16 +02:00
fout = stdout;
const char *progname = argv[0];
2018-05-31 16:01:33 +02:00
if (argc <= 1) {
printhelp(stderr,progname);
2018-05-31 16:01:33 +02:00
exit(1);
}
argc--; argv++;
2017-09-24 21:13:16 +02:00
while (argc--) {
arg = *argv++;
if (!ignoreargs && *arg == '-') {
int numargit = 0;
nextarg:
++arg;
++numargit;
if (*arg == '-') {
if (numargit > 1) {
2018-05-31 16:01:33 +02:00
fprintf(stderr,"unrecognised argument: -\n");
exit(Q_UNRECOGNISED);
2017-09-24 21:13:16 +02:00
}
++arg;
if (!*arg)
ignoreargs = 1;
2018-05-31 16:01:33 +02:00
else if (!strcmp(arg,"help") || !strcmp(arg,"usage")) {
printhelp(stdout,progname);
2018-05-31 16:01:33 +02:00
exit(0);
}
2017-09-24 21:13:16 +02:00
else {
2018-05-31 16:01:33 +02:00
fprintf(stderr,"unrecognised argument: --%s\n",arg);
exit(Q_UNRECOGNISED);
2017-09-24 21:13:16 +02:00
}
numargit = 0;
}
else if (*arg == 0) {
if (numargit == 1)
ignoreargs = 1;
continue;
}
2018-05-31 16:01:33 +02:00
else if (*arg == 'h') {
printhelp(stdout,progname);
2018-05-31 16:01:33 +02:00
exit(0);
}
2017-09-24 21:13:16 +02:00
else if (*arg == 'f') {
if (argc--)
loadfilterfile(*argv++);
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-24 21:13:16 +02:00
}
else if (*arg == 'q')
++quietflag;
else if (*arg == 'x')
fout = 0;
else if (*arg == 'o') {
outfileoverwrite = 0;
2017-09-24 21:13:16 +02:00
if (argc--)
outfile = *argv++;
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-24 21:13:16 +02:00
}
else if (*arg == 'O') {
outfileoverwrite = 1;
2017-09-24 21:13:16 +02:00
if (argc--)
outfile = *argv++;
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-24 21:13:16 +02:00
}
else if (*arg == 'F')
dirnameflag = 1;
else if (*arg == 'd') {
2018-05-31 16:01:33 +02:00
if (argc--)
2017-09-24 21:13:16 +02:00
setworkdir(*argv++);
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-24 21:13:16 +02:00
}
2017-09-30 05:40:12 +02:00
else if (*arg == 't' || *arg == 'j') {
2017-09-24 21:13:16 +02:00
if (argc--)
numthreads = atoi(*argv++);
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-24 21:13:16 +02:00
}
2017-09-25 19:49:47 +02:00
else if (*arg == 'n') {
if (argc--)
numneedgenerate = (size_t)atoll(*argv++);
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-25 19:49:47 +02:00
}
2017-10-22 07:07:45 +02:00
else if (*arg == 'N') {
if (argc--)
numwords = atoi(*argv++);
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-10-22 07:07:45 +02:00
}
2017-09-30 14:43:32 +02:00
else if (*arg == 'Z')
fastkeygen = 0;
2017-09-24 21:13:16 +02:00
else if (*arg == 'z')
fastkeygen = 1;
2017-09-30 05:40:12 +02:00
else if (*arg == 's') {
#ifdef STATISTICS
reportdelay = 10000000;
#else
2018-05-31 16:01:33 +02:00
e_nostatistics();
2017-09-30 05:40:12 +02:00
#endif
}
else if (*arg == 'S') {
#ifdef STATISTICS
if (argc--)
reportdelay = (u64)atoll(*argv++) * 1000000;
2018-05-31 16:01:33 +02:00
else
e_additional();
2017-09-30 05:40:12 +02:00
#else
2018-05-31 16:01:33 +02:00
e_nostatistics();
2017-09-30 05:40:12 +02:00
#endif
}
2017-09-30 14:43:32 +02:00
else if (*arg == 'T') {
2017-09-30 05:46:17 +02:00
#ifdef STATISTICS
2017-09-30 14:43:32 +02:00
realtimestats = 0;
2017-09-30 05:46:17 +02:00
#else
2018-05-31 16:01:33 +02:00
e_nostatistics();
2017-09-30 05:46:17 +02:00
#endif
}
else if (*arg == 'y')
yamloutput = 1;
else if (*arg == 'Y') {
2018-07-09 18:38:41 +02:00
yamlinput = 1;
if (argc) {
--argc;
infile = *argv++;
if (!*infile)
infile = 0;
if (argc) {
--argc;
hostname = *argv++;
2018-07-09 18:38:41 +02:00
if (!*hostname)
hostname = 0;
if (hostname && strlen(hostname) != ONION_LEN) {
fprintf(stderr,"bad onion argument length\n");
exit(Q_UNRECOGNISED);
}
}
}
}
2017-09-24 21:13:16 +02:00
else {
2018-05-31 16:01:33 +02:00
fprintf(stderr,"unrecognised argument: -%c\n",*arg);
exit(Q_UNRECOGNISED);
2017-09-24 21:13:16 +02:00
}
if (numargit)
goto nextarg;
}
2018-05-31 18:14:35 +02:00
else
filters_add(arg);
}
if (outfile) {
fout = fopen(outfile,!outfileoverwrite ? "a" : "w");
2018-05-31 18:14:35 +02:00
if (!fout) {
perror("failed to open output file");
exit(Q_FAILOPENOUTPUT);
}
2017-09-24 21:13:16 +02:00
}
2017-09-25 19:49:47 +02:00
2018-07-09 18:38:41 +02:00
if (!fout && yamloutput) {
fprintf(stderr,"nil output with yaml mode does not make sense\n");
exit(Q_FAILOPENOUTPUT); // define new err code?
}
2017-09-24 21:13:16 +02:00
if (workdir)
createdir(workdir,1);
2017-09-25 19:49:47 +02:00
2017-09-24 21:13:16 +02:00
direndpos = workdirlen;
onionendpos = workdirlen + ONION_LEN;
2017-09-25 19:49:47 +02:00
2017-09-24 21:13:16 +02:00
if (!dirnameflag) {
printstartpos = direndpos;
2018-07-09 18:38:41 +02:00
printlen = ONION_LEN + 1; // + '\n'
2017-09-24 21:13:16 +02:00
} else {
printstartpos = 0;
2018-07-09 18:38:41 +02:00
printlen = onionendpos + 1; // + '\n'
2017-09-24 21:13:16 +02:00
}
2017-09-25 19:49:47 +02:00
2018-07-09 18:38:41 +02:00
if (yamlinput) {
char *sname = makesname();
FILE *fin = stdin;
if (infile) {
fin = fopen(infile,"r");
if (!fin) {
fprintf(stderr,"failed to open input file\n");
return Q_FAILOPENINPUT;
}
}
tret = yamlin_parseandcreate(fin,sname,hostname);
if (infile) {
fclose(fin);
fin = 0;
}
free(sname);
if (tret)
return tret;
goto done;
}
filters_prepare();
filters_print();
2017-09-24 21:13:16 +02:00
#ifdef STATISTICS
if (!filters_count() && !reportdelay)
#else
2017-09-25 22:57:27 +02:00
if (!filters_count())
#endif
2017-09-25 22:57:27 +02:00
return 0;
2017-12-14 16:22:45 +01:00
#ifdef EXPANDMASK
if (numwords > 1 && flattened)
fprintf(stderr,"WARNING: -N switch will produce bogus results because we can't know filter width. reconfigure with --enable-besort and recompile.\n");
#endif
2018-07-09 18:38:41 +02:00
if (yamloutput)
yamlout_init();
2017-09-25 19:49:47 +02:00
2018-07-09 18:38:41 +02:00
pthread_mutex_init(&keysgenerated_mutex,0);
pthread_mutex_init(&fout_mutex,0);
2017-09-25 19:49:47 +02:00
2017-09-24 21:13:16 +02:00
if (numthreads <= 0) {
2017-10-06 02:14:33 +02:00
numthreads = cpucount();
if (numthreads <= 0)
numthreads = 1;
2017-09-24 21:13:16 +02:00
}
if (!quietflag)
fprintf(stderr,"using %d %s\n",
numthreads,numthreads == 1 ? "thread" : "threads");
2017-09-25 19:49:47 +02:00
2017-09-30 05:40:12 +02:00
signal(SIGTERM,termhandler);
signal(SIGINT,termhandler);
2017-09-25 19:49:47 +02:00
2017-09-24 21:13:16 +02:00
VEC_INIT(threads);
VEC_ADDN(threads,numthreads);
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
VEC_INIT(stats);
VEC_ADDN(stats,numthreads);
VEC_ZERO(stats);
2017-09-30 05:40:12 +02:00
VEC_INIT(tstats);
VEC_ADDN(tstats,numthreads);
VEC_ZERO(tstats);
2017-09-30 05:40:12 +02:00
#endif
2017-09-25 19:49:47 +02:00
2018-06-01 15:48:01 +02:00
pthread_attr_t tattr,*tattrp = &tattr;
tret = pthread_attr_init(tattrp);
if (tret) {
perror("pthread_attr_init");
tattrp = 0;
}
else {
tret = pthread_attr_setstacksize(tattrp,80<<10);
2018-06-01 15:48:01 +02:00
if (tret)
perror("pthread_attr_setstacksize");
}
2017-09-30 05:40:12 +02:00
for (size_t i = 0;i < VEC_LENGTH(threads);++i) {
void *tp = 0;
#ifdef STATISTICS
tp = &VEC_BUF(stats,i);
#endif
2018-06-01 15:48:01 +02:00
tret = pthread_create(&VEC_BUF(threads,i),tattrp,fastkeygen ? dofastwork : dowork,tp);
2017-09-24 21:13:16 +02:00
if (tret) {
2018-06-01 15:48:01 +02:00
fprintf(stderr,"error while making " FSZ "th thread: %s\n",i,strerror(tret));
2018-05-31 16:01:33 +02:00
exit(Q_FAILTHREAD);
2017-09-24 21:13:16 +02:00
}
}
2017-09-25 19:49:47 +02:00
2018-06-01 15:48:01 +02:00
if (tattrp) {
tret = pthread_attr_destroy(tattrp);
if (tret)
perror("pthread_attr_destroy");
}
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
struct timespec nowtime;
u64 istarttime,inowtime,ireporttime = 0,elapsedoffset = 0;
if (clock_gettime(CLOCK_MONOTONIC,&nowtime) < 0) {
2018-05-31 16:01:33 +02:00
perror("failed to get time");
exit(Q_FAILTIME);
2017-09-30 05:40:12 +02:00
}
2018-02-23 01:03:17 +01:00
istarttime = (1000000 * (u64)nowtime.tv_sec) + ((u64)nowtime.tv_nsec / 1000);
2017-09-30 05:40:12 +02:00
#endif
2017-09-25 19:49:47 +02:00
struct timespec ts;
memset(&ts,0,sizeof(ts));
ts.tv_nsec = 100000000;
while (!endwork) {
if (numneedgenerate && keysgenerated >= numneedgenerate) {
endwork = 1;
break;
}
nanosleep(&ts,0);
2017-09-30 05:40:12 +02:00
#ifdef STATISTICS
clock_gettime(CLOCK_MONOTONIC,&nowtime);
2018-02-23 01:03:17 +01:00
inowtime = (1000000 * (u64)nowtime.tv_sec) + ((u64)nowtime.tv_nsec / 1000);
u64 sumcalc = 0,sumsuccess = 0,sumrestart = 0;
for (int i = 0;i < numthreads;++i) {
2017-09-30 05:40:12 +02:00
u32 newt,tdiff;
// numcalc
2017-10-06 02:25:51 +02:00
newt = VEC_BUF(stats,i).numcalc.v;
2017-09-30 05:40:12 +02:00
tdiff = newt - VEC_BUF(tstats,i).oldnumcalc;
VEC_BUF(tstats,i).oldnumcalc = newt;
VEC_BUF(tstats,i).numcalc += (u64)tdiff;
sumcalc += VEC_BUF(tstats,i).numcalc;
// numsuccess
2017-10-06 02:25:51 +02:00
newt = VEC_BUF(stats,i).numsuccess.v;
2017-09-30 05:40:12 +02:00
tdiff = newt - VEC_BUF(tstats,i).oldnumsuccess;
VEC_BUF(tstats,i).oldnumsuccess = newt;
VEC_BUF(tstats,i).numsuccess += (u64)tdiff;
sumsuccess += VEC_BUF(tstats,i).numsuccess;
// numrestart
newt = VEC_BUF(stats,i).numrestart.v;
tdiff = newt - VEC_BUF(tstats,i).oldnumrestart;
VEC_BUF(tstats,i).oldnumrestart = newt;
VEC_BUF(tstats,i).numrestart += (u64)tdiff;
sumrestart += VEC_BUF(tstats,i).numrestart;
2017-09-30 05:40:12 +02:00
}
if (reportdelay && (!ireporttime || inowtime - ireporttime >= reportdelay)) {
if (ireporttime)
ireporttime += reportdelay;
else
ireporttime = inowtime;
if (!ireporttime)
ireporttime = 1;
double calcpersec = (1000000.0 * sumcalc) / (inowtime - istarttime);
double succpersec = (1000000.0 * sumsuccess) / (inowtime - istarttime);
double restpersec = (1000000.0 * sumrestart) / (inowtime - istarttime);
fprintf(stderr,">calc/sec:%8lf, succ/sec:%8lf, rest/sec:%8lf, elapsed:%5.6lfsec\n",
calcpersec,succpersec,restpersec,
(inowtime - istarttime + elapsedoffset) / 1000000.0);
2017-09-30 05:40:12 +02:00
if (realtimestats) {
for (int i = 0;i < numthreads;++i) {
2017-09-30 05:40:12 +02:00
VEC_BUF(tstats,i).numcalc = 0;
VEC_BUF(tstats,i).numsuccess = 0;
VEC_BUF(tstats,i).numrestart = 0;
2017-09-30 05:40:12 +02:00
}
elapsedoffset += inowtime - istarttime;
istarttime = inowtime;
}
}
if (sumcalc > U64_MAX / 2) {
for (int i = 0;i < numthreads;++i) {
2017-09-30 05:40:12 +02:00
VEC_BUF(tstats,i).numcalc /= 2;
VEC_BUF(tstats,i).numsuccess /= 2;
VEC_BUF(tstats,i).numrestart /= 2;
2017-09-30 05:40:12 +02:00
}
u64 timediff = (inowtime - istarttime + 1) / 2;
elapsedoffset += timediff;
istarttime += timediff;
}
#endif
2017-09-25 19:49:47 +02:00
}
2017-09-30 05:40:12 +02:00
if (!quietflag)
2018-05-31 16:01:33 +02:00
fprintf(stderr,"waiting for threads to finish...");
2017-09-30 05:40:12 +02:00
for (size_t i = 0;i < VEC_LENGTH(threads);++i)
pthread_join(VEC_BUF(threads,i),0);
if (!quietflag)
2018-05-31 16:01:33 +02:00
fprintf(stderr," done.\n");
2017-09-24 21:13:16 +02:00
2018-07-09 18:38:41 +02:00
if (yamloutput)
yamlout_clean();
2017-09-25 19:49:47 +02:00
pthread_mutex_destroy(&keysgenerated_mutex);
2017-09-24 21:13:16 +02:00
pthread_mutex_destroy(&fout_mutex);
2018-07-09 18:38:41 +02:00
done:
2017-09-24 21:13:16 +02:00
filters_clean();
2017-09-25 19:49:47 +02:00
if (outfile)
fclose(fout);
2017-09-24 21:13:16 +02:00
return 0;
}