void share(char*fn)
{
int i;
mpz_t x,k,t,e;
byte rnd[16];
char buf[1024];
FILE *f;
f=fopen(fn,"w+");
if(f==NULL){
fprintf(stderr,"Unable to open file %s.\n",fn);
return;
}
/*generate random x*/
mpz_init(x);
for(i=0;i<16;i++)rnd[i]=randbyte();
setbin(x,rnd,16);
/*calculate k*/
mpz_init(k);
mpz_init(t);
mpz_init(e);
for(i=0;i<n;i++){
/*k=k + kvec[i]*x^i*/
mpz_powm(t,x,e,p);
mpz_mul(t,t,kvec[i]);
mpz_add(k,k,t);
mpz_mod(k,k,p);
/*incr e so that it matches the next i*/
mpz_add_ui(e,e,1);
}
fprintf(f,"%s\n",mpz_get_str(buf,16,p));
fprintf(f,"%s\n",mpz_get_str(buf,16,x));
fprintf(f,"%s\n",mpz_get_str(buf,16,k));
mpz_set_ui(e,0);
mpz_set_ui(k,0);
for(i=0;i<n;i++){
/*k=k + hvec[i]*x^i*/
mpz_powm(t,x,e,p);
mpz_mul(t,t,hvec[i]);
mpz_add(k,k,t);
mpz_mod(k,k,p);
/*incr e so that it matches the next i*/
mpz_add_ui(e,e,1);
}
fprintf(f,"%s\n",mpz_get_str(buf,16,k));
fclose(f);
mpz_clear(x);
mpz_clear(k);
mpz_clear(t);
mpz_clear(e);
}
void sharevector(int n_)
{
int i,j;
byte hdl[17];
n=n_;
/*intialize vector and p*/
kvec=malloc(n*sizeof(mpz_t));
hvec=malloc(n*sizeof(mpz_t));
for(i=0;i<n;i++){
mpz_init(kvec[i]);
mpz_init(hvec[i]);
if(i==0){
setbin(kvec[0],key,16);
setbin(hvec[0],hashv,16);
printf("Setting key: %s\n",key_prints(0,key));
printf("Setting hash: %s\n",key_prints(0,hashv));
}else{
for(j=0;j<16;j++)
hdl[j]=randbyte();
setbin(kvec[i],hdl,16);
for(j=0;j<16;j++)
hdl[j]=randbyte();
setbin(hvec[i],hdl,16);
}
}
mpz_init(p);
/*generate random prime*/
hdl[0]=1;
for(i=0;i<500;i++){
for(j=1;j<17;j++)
hdl[j]=randbyte();
hdl[16]|=1;
setbin(p,hdl,17);
j=mpz_probab_prime_p(p,100);
if(j)break;
}
if(!j){
fprintf(stderr,"Unable to generate a good prime. Giving up.\n");
exit(1);
}
}
void gamejump(planetnum i) /* Move to system i */
{ currentplanet=i;
localmarket = genmarket(randbyte(),galaxy[i]);
}
void genkey()
{
int i;
for(i=0;i<16;i++)key[i]=randbyte();
}
APR_DECLARE(apr_status_t) apr_generate_random_bytes(unsigned char *buf,
apr_size_t length)
{
#ifdef DEV_RANDOM
int fd = -1;
/* On BSD/OS 4.1, /dev/random gives out 8 bytes at a time, then
* gives EOF, so reading 'length' bytes may require opening the
* device several times. */
do {
apr_ssize_t rc;
if (fd == -1)
if ((fd = open(DEV_RANDOM, O_RDONLY)) == -1)
return errno;
do {
rc = read(fd, buf, length);
} while (rc == -1 && errno == EINTR);
if (rc < 0) {
int errnum = errno;
close(fd);
return errnum;
}
else if (rc == 0) {
close(fd);
fd = -1; /* force open() again */
}
else {
buf += rc;
length -= rc;
}
} while (length > 0);
close(fd);
#elif defined(OS2)
static UCHAR randbyte();
unsigned int idx;
for (idx=0; idx<length; idx++)
buf[idx] = randbyte();
#elif defined(HAVE_EGD)
/* use EGD-compatible socket daemon (such as EGD or PRNGd).
* message format:
* 0x00 (get entropy level)
* 0xMM (msb) 0xmm 0xll 0xLL (lsb)
* 0x01 (read entropy nonblocking) 0xNN (bytes requested)
* 0xMM (bytes granted) MM bytes
* 0x02 (read entropy blocking) 0xNN (bytes desired)
* [block] NN bytes
* 0x03 (write entropy) 0xMM 0xLL (bits of entropy) 0xNN (bytes of data)
* NN bytes
* (no response - write only)
* 0x04 (report PID)
* 0xMM (length of PID string, not null-terminated) MM chars
*/
static const char *egd_sockets[] = { EGD_DEFAULT_SOCKET, NULL };
const char **egdsockname = NULL;
int egd_socket, egd_path_len, rv, bad_errno;
struct sockaddr_un addr;
apr_socklen_t egd_addr_len;
apr_size_t resp_expected;
unsigned char req[2], resp[255];
unsigned char *curbuf = buf;
for (egdsockname = egd_sockets; *egdsockname && length > 0; egdsockname++) {
egd_path_len = strlen(*egdsockname);
if (egd_path_len > sizeof(addr.sun_path)) {
return APR_EINVAL;
}
memset(&addr, 0, sizeof(struct sockaddr_un));
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, *egdsockname, egd_path_len);
egd_addr_len = APR_OFFSETOF(struct sockaddr_un, sun_path) +
egd_path_len;
egd_socket = socket(PF_UNIX, SOCK_STREAM, 0);
if (egd_socket == -1) {
return errno;
}
rv = connect(egd_socket, (struct sockaddr*)&addr, egd_addr_len);
if (rv == -1) {
bad_errno = errno;
continue;
}
/* EGD can only return 255 bytes of data at a time. Silly. */
while (length > 0) {
apr_ssize_t srv;
req[0] = 2; /* We'll block for now. */
req[1] = length > 255 ? 255: length;
srv = write(egd_socket, req, 2);
if (srv == -1) {
bad_errno = errno;
shutdown(egd_socket, SHUT_RDWR);
close(egd_socket);
break;
}
if (srv != 2) {
shutdown(egd_socket, SHUT_RDWR);
close(egd_socket);
return APR_EGENERAL;
}
resp_expected = req[1];
srv = read(egd_socket, resp, resp_expected);
if (srv == -1) {
bad_errno = errno;
shutdown(egd_socket, SHUT_RDWR);
close(egd_socket);
return bad_errno;
}
memcpy(curbuf, resp, srv);
curbuf += srv;
length -= srv;
}
shutdown(egd_socket, SHUT_RDWR);
close(egd_socket);
}
if (length > 0) {
/* We must have iterated through the list of sockets,
* and no go. Return the errno.
*/
return bad_errno;
}
#elif defined(HAVE_TRUERAND) /* use truerand */
extern int randbyte(void); /* from the truerand library */
unsigned int idx;
/* this will increase the startup time of the server, unfortunately...
* (generating 20 bytes takes about 8 seconds)
*/
for (idx=0; idx<length; idx++)
buf[idx] = (unsigned char) randbyte();
#endif /* DEV_RANDOM */
return APR_SUCCESS;
}
