int main(int argc, char *argv[])
{
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
char *bytes_file = NULL;
bool show_bps = false;
std::string username, password;
const char *cdevice = "hw:1"; /* capture device */
std::vector<std::string> hosts;
int log_level = LOG_INFO;
fprintf(stderr, "eb_server_audio v" VERSION ", (C) 2009-2015 by [email protected]\n");
while((c = getopt(argc, argv, "I:hX:P:So:d:L:l:sn")) != -1)
{
switch(c)
{
case 'I':
hosts.push_back(optarg);
break;
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'S':
show_bps = true;
break;
case 'o':
bytes_file = optarg;
break;
case 'd':
cdevice = optarg;
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
default:
help(cdevice);
return 1;
}
}
if (!hosts.empty() && (username.length() == 0 || password.length() == 0))
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty() && !bytes_file)
error_exit("no host to connect to or file to write to given");
(void)umask(0177);
no_core();
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
if (!do_not_fork && !show_bps)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
write_pid(pid_file);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
main_loop(&hosts, bytes_file, show_bps, username, password, cdevice);
unlink(pid_file);
fprintf(stderr, "program terminated\n");
return 0;
}
int main(int argc, char *argv[])
{
unsigned char bytes[4096];
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
char *bytes_file = NULL;
int verbose = 0;
char server_type[128];
bool show_bps = false;
libusb_context *ctx = NULL;
libusb_device_handle *handle = NULL;
std::string username, password;
std::vector<std::string> hosts;
int log_level = LOG_INFO;
fprintf(stderr, "eb_server_Araneus_Alea v" VERSION ", (C) 2009-2015 by [email protected]\n");
while((c = getopt(argc, argv, "I:hSX:P:o:L:l:snv")) != -1)
{
switch(c)
{
case 'I':
hosts.push_back(optarg);
break;
case 'S':
show_bps = true;
break;
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'v':
verbose++;
break;
case 'o':
bytes_file = optarg;
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
case 'h':
help();
return 0;
default:
help();
return 1;
}
}
if (!hosts.empty() && (username.length() == 0 || password.length() == 0))
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty() && !bytes_file)
error_exit("no host to connect to or file to write to given");
(void)umask(0177);
no_core();
lock_mem(bytes, sizeof bytes);
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
if(libusb_init(&ctx) < 0)
error_exit("Error initialising Araneus Alea");
libusb_set_debug(ctx, 3);
handle = libusb_open_device_with_vid_pid(ctx,USB_VENDOR_ARANEUS,USB_ARANEUS_PRODUCT_ALEA);
if (!handle)
error_exit("No Alea device found");
if(libusb_claim_interface(handle, 0) < 0){
error_exit("Cannot Claim Interface");
}
snprintf(server_type, sizeof server_type, "eb_server_Araneus_Alea v" VERSION);
if (!do_not_fork)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
write_pid(pid_file);
protocol *p = NULL;
if (!hosts.empty())
p = new protocol(&hosts, username, password, true, server_type, DEFAULT_COMM_TO);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
init_showbps();
set_showbps_start_ts();
for(;!do_exit;)
{
if (libusb_bulk_transfer(handle, (1 | LIBUSB_ENDPOINT_IN), (unsigned char *)bytes, sizeof bytes, &c, TIMEOUT) < 0)
error_exit("Failed to retrieve random bytes from device %x", c);
////////
if (show_bps)
update_showbps(sizeof bytes);
if (bytes_file)
emit_buffer_to_file(bytes_file, bytes, sizeof bytes);
if (!hosts.empty() && p -> message_transmit_entropy_data(bytes, sizeof bytes, &do_exit) == -1)
{
dolog(LOG_INFO, "connection closed");
p -> drop();
}
set_showbps_start_ts();
}
delete p;
memset(bytes, 0x00, sizeof bytes);
unlink(pid_file);
return 0;
}
int main(int argc, char *argv[])
{
unsigned char bytes[4096];
unsigned char cur_byte = 0;
int bits = 0;
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
char *bytes_file = NULL;
bool show_bps = false;
std::string username, password;
std::vector<std::string> hosts;
int log_level = LOG_INFO;
fprintf(stderr, "%s, (C) 2009-2015 by [email protected]\n", server_type);
while((c = getopt(argc, argv, "hX:P:So:I:L:l:sn")) != -1)
{
switch(c)
{
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'S':
show_bps = true;
break;
case 'o':
bytes_file = optarg;
break;
case 'I':
hosts.push_back(optarg);
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
case 'h':
help();
return 0;
default:
help();
return 1;
}
}
if (!hosts.empty() && (username.length() == 0 || password.length() == 0))
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty() && !bytes_file)
error_exit("no host to connect to or file to write to given");
(void)umask(0177);
no_core();
lock_mem(bytes, sizeof bytes);
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
if (!do_not_fork && !show_bps)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
write_pid(pid_file);
protocol *p = NULL;
if (!hosts.empty())
p = new protocol(&hosts, username, password, true, server_type, DEFAULT_COMM_TO);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
struct libusb_device **devs = NULL;
libusb_device_handle **devhs;
int index = 0, n = 0, use_n = 0;
if (libusb_init(NULL) < 0)
error_exit("cannot init libusb");
if (libusb_get_device_list(NULL, &devs) < 0)
error_exit("cannot retrieve usb devicelist");
while(devs[n] != NULL) { n++; }
dolog(LOG_INFO, "Found %d devices", n);
devhs = (libusb_device_handle **)malloc(sizeof(libusb_device_handle *) * n);
for(index=0; index<n; index++)
{
uint8_t bus_nr = libusb_get_bus_number(devs[index]);
uint8_t dev_nr = libusb_get_device_address(devs[index]);
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(devs[index], &desc);
dolog(LOG_INFO, "Opening device %d: %d/%d %04x:%04x", index, bus_nr, dev_nr, desc.idVendor, desc.idProduct);
if (desc.idVendor == 0x1d6b) // ignore
continue;
if (libusb_open(devs[index], &devhs[use_n++]) != 0)
error_exit("error getting usb handle");
}
dolog(LOG_INFO, "Using %d devices", use_n);
if (use_n == 0)
error_exit("no devices found which can be used");
init_showbps();
set_showbps_start_ts();
int dev_index = 0;
for(;!do_exit;)
{
// gather random data
double t1 = gen_entropy_data(devhs[dev_index]), t2 = gen_entropy_data(devhs[dev_index]);
if (++dev_index >= use_n)
dev_index = 0;
if (t1 == t2)
continue;
cur_byte <<= 1;
if (t1 > t2)
cur_byte |= 1;
if (++bits == 8)
{
bytes[index++] = cur_byte;
bits = 0;
if (index == sizeof bytes)
{
if (show_bps)
update_showbps(sizeof bytes);
if (bytes_file)
emit_buffer_to_file(bytes_file, bytes, index);
if (p && p -> message_transmit_entropy_data(bytes, index, &do_exit) == -1)
{
dolog(LOG_INFO, "connection closed");
p -> drop();
}
set_showbps_start_ts();
index = 0; // skip header
}
}
}
memset(bytes, 0x00, sizeof bytes);
for(index=0; index<n; index++)
libusb_close(devhs[index]);
libusb_free_device_list(devs, 1);
libusb_exit(NULL);
free(devhs);
unlink(pid_file);
return 0;
}
int main(int argc, char *argv[])
{
unsigned char bytes[4096];
int bits = 0, index = 0;
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
char *bytes_file = NULL;
bool show_bps = false;
std::string username, password;
std::vector<std::string> hosts;
int log_level = LOG_INFO;
fprintf(stderr, "%s, (C) 2009-2015 by [email protected]\n", server_type);
while((c = getopt(argc, argv, "I:hX:P:So:L:l:sn")) != -1)
{
switch(c)
{
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'S':
show_bps = true;
break;
case 'o':
bytes_file = optarg;
break;
case 'I':
hosts.push_back(optarg);
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
case 'h':
help();
return 0;
default:
help();
return 1;
}
}
if (!hosts.empty() && (username.length() == 0 || password.length() == 0))
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty() && !bytes_file)
error_exit("no host to connect to or file to write to given");
(void)umask(0177);
no_core();
lock_mem(bytes, sizeof bytes);
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
if (!do_not_fork && !show_bps)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
write_pid(pid_file);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
protocol *p = NULL;
if (!hosts.empty())
p = new protocol(&hosts, username, password, true, server_type, DEFAULT_COMM_TO);
int slp = get_clock_res();
dolog(LOG_INFO, "resolution of clock is %dns", slp);
init_showbps();
set_showbps_start_ts();
unsigned char cur_byte = 0;
int equal_cnt = 0;
for(;!do_exit;)
{
// gather random data
double t1 = gen_entropy_data(slp), t2 = gen_entropy_data(slp);
if (t1 == t2)
{
equal_cnt++;
if (equal_cnt > 5 && slp < 1000)
{
dolog(LOG_DEBUG, "increasing sleep to %dns", slp);
slp++;
}
continue;
}
equal_cnt = 0;
cur_byte <<= 1;
if (t1 >= t2)
cur_byte |= 1;
if (++bits == 8)
{
bytes[index++] = cur_byte;
bits = 0;
if (index == sizeof bytes)
{
if (show_bps)
update_showbps(sizeof bytes);
if (bytes_file)
emit_buffer_to_file(bytes_file, bytes, index);
if (p && p -> message_transmit_entropy_data(bytes, index, &do_exit) == -1)
{
dolog(LOG_INFO, "connection closed");
p -> drop();
}
set_showbps_start_ts();
index = 0; // skip header
}
}
}
memset(bytes, 0x00, sizeof bytes);
unlink(pid_file);
delete p;
return 0;
}
int main(int argc, char *argv[])
{
unsigned char bytes[BLOCK_SIZE];
int read_fd = -1;
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
char *device = NULL;
char *serial = NULL;
char *bytes_file = NULL;
bool show_bps = false;
std::string username, password;
std::vector<std::string> hosts;
int log_level = LOG_INFO;
fprintf(stderr, "%s, (C) 2009-2015 by [email protected]\n", server_type);
while((c = getopt(argc, argv, "hSX:P:o:p:I:d:L:l:sn")) != -1)
{
switch(c)
{
case 'S':
show_bps = true;
break;
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'o':
bytes_file = optarg;
break;
case 'p':
serial = optarg;
break;
case 'I':
hosts.push_back(optarg);
break;
case 'd':
device = optarg;
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
case 'h':
help();
return 0;
default:
help();
return 1;
}
}
if (!hosts.empty() && (username.length() == 0 || password.length() == 0))
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty() && !bytes_file)
error_exit("no host to connect to or file to write to given");
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
if (device)
read_fd = open(device, O_RDONLY);
if (read_fd == -1)
error_exit("error opening %s", device);
if (serial)
set_serial_parameters(read_fd, serial);
(void)umask(0177);
no_core();
lock_mem(bytes, sizeof bytes);
if (!do_not_fork)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
protocol *p = NULL;
if (!hosts.empty())
p = new protocol(&hosts, username, password, true, server_type, DEFAULT_COMM_TO);
write_pid(pid_file);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
init_showbps();
set_showbps_start_ts();
for(;!do_exit;)
{
if (READ(read_fd, bytes, BLOCK_SIZE, &do_exit) != BLOCK_SIZE)
error_exit("error reading from input");
if (show_bps)
update_showbps(BLOCK_SIZE);
if (bytes_file)
emit_buffer_to_file(bytes_file, bytes, BLOCK_SIZE);
if (p && p -> message_transmit_entropy_data(bytes, BLOCK_SIZE, &do_exit) == -1)
{
dolog(LOG_INFO, "connection closed");
p -> drop();
}
set_showbps_start_ts();
}
memset(bytes, 0x00, sizeof bytes);
unlink(pid_file);
delete p;
return 0;
}
int main(int argc, char *argv[])
{
unsigned char bytes[4096];
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
char *file = NULL;
std::string username, password;
char *bytes_file = NULL;
bool show_bps = false;
std::vector<std::string> hosts;
int log_level = LOG_INFO;
fprintf(stderr, "%s, (C) 2009-2015 by [email protected]\n", server_type);
while((c = getopt(argc, argv, "S:I:f:hX:P:o:p:d:L:l:sn")) != -1)
{
switch(c)
{
case 'S':
show_bps = true;
break;
case 'o':
bytes_file = optarg;
break;
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'f':
file = optarg;
break;
case 'I':
hosts.push_back(optarg);
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
default:
help();
return 1;
}
}
if (!hosts.empty() && (username.length() == 0 || password.length() == 0))
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty() && !bytes_file)
error_exit("no host to connect to or file to write to given");
if (!file)
error_exit("no file to read from selected");
(void)umask(0177);
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
FILE *fh = fopen(file, "rb");
if (!fh)
error_exit("Failed to open file %s", file);
(void)umask(0177);
no_core();
if (!do_not_fork)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
write_pid(pid_file);
protocol *p = NULL;
if (!hosts.empty())
p = new protocol(&hosts, username, password, true, server_type, DEFAULT_COMM_TO);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
bool data = false;
int got_bytes = -1;
init_showbps();
set_showbps_start_ts();
for(;!feof(fh) && !do_exit;)
{
// gather random data
if (!data)
{
got_bytes = fread(bytes, 1, sizeof bytes, fh);
if (got_bytes <= 0)
break;
data = true;
}
if (data)
{
if (show_bps)
update_showbps(got_bytes);
if (bytes_file)
emit_buffer_to_file(bytes_file, bytes, got_bytes);
if (p && p -> message_transmit_entropy_data(bytes, got_bytes, &do_exit) == -1)
{
dolog(LOG_INFO, "connection closed");
p -> drop();
}
set_showbps_start_ts();
data = false;
}
}
fclose(fh);
unlink(pid_file);
delete p;
return 0;
}
int main(int argc, char *argv[])
{
int dev_random_fd = open(DEV_RANDOM, O_RDWR);
const int max_bits_in_kernel_rng = kernel_rng_get_max_entropy_count();
const int write_threshold = kernel_rng_get_write_threshold();
int c;
bool do_not_fork = false, log_console = false, log_syslog = false;
char *log_logfile = NULL;
std::string username, password;
int interval = -1;
std::vector<std::string> hosts;
int log_level = LOG_INFO;
printf("eb_client_linux_kernel v" VERSION ", (C) 2009-2017 by [email protected]\n");
while((c = getopt(argc, argv, "b:hX:P:I:L:l:sn")) != -1)
{
switch(c)
{
case 'b':
interval = atof(optarg);
if (interval < 1)
error_exit("Interval must be > 0");
break;
case 'X':
get_auth_from_file(optarg, username, password);
break;
case 'P':
pid_file = optarg;
break;
case 'I':
hosts.push_back(optarg);
break;
case 's':
log_syslog = true;
break;
case 'L':
log_level = atoi(optarg);
break;
case 'l':
log_logfile = optarg;
break;
case 'n':
do_not_fork = true;
log_console = true;
break;
default:
help();
return 1;
}
}
if (username.length() == 0 || password.length() == 0)
error_exit("please select a file with authentication parameters (username + password) using the -X switch");
if (hosts.empty())
error_exit("no host to connect to selected");
set_logging_parameters(log_console, log_logfile, log_syslog, log_level);
if (!do_not_fork)
{
if (daemon(0, 0) == -1)
error_exit("fork failed");
}
protocol *p = new protocol(&hosts, username, password, false, client_type, DEFAULT_COMM_TO);
(void)umask(0177);
no_core();
write_pid(pid_file);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
signal(SIGINT , sig_handler);
signal(SIGQUIT, sig_handler);
dolog(LOG_INFO, "started with %d bits in kernel rng", kernel_rng_get_entropy_count());
if (dev_random_fd == -1)
error_exit("failed to open %s", DEV_RANDOM);
bit_count_estimator bce(BCE_SHANNON);
for(;!do_exit;)
{
struct timeval tv, *ptv = NULL;
if (interval > 0) {
tv.tv_sec = interval / 1000;
tv.tv_usec = int(interval * 1000) % 1000;
ptv = &tv;
}
// wait for /dev/random te become writable which means the entropy-
// level dropped below a certain threshold
fd_set write_fd;
FD_ZERO(&write_fd);
FD_SET(dev_random_fd, &write_fd);
dolog(LOG_DEBUG, "wait for low-event");
for(;!do_exit;)
{
int rc = select(dev_random_fd + 1, NULL, &write_fd, NULL, ptv);
printf("%d\n", rc);
if (rc >= 0)
break;
if (errno != EINTR && errno != EAGAIN)
error_exit("Select error: %m");
}
if (do_exit)
break;
int n_bits_in_kernel_rng = kernel_rng_get_entropy_count();
dolog(LOG_DEBUG, "kernel rng bit count: %d", n_bits_in_kernel_rng);
if (n_bits_in_kernel_rng < write_threshold)
{
/* find out how many bits to add */
int n_bits_to_get = max_bits_in_kernel_rng - n_bits_in_kernel_rng;
if (n_bits_to_get <= 0)
{
dolog(LOG_DEBUG, "number of bits to get <= 0: %d", n_bits_to_get);
continue;
}
if (n_bits_to_get > 9999)
n_bits_to_get = 9999;
if (n_bits_to_get < 8)
n_bits_to_get = 8;
dolog(LOG_INFO, "%d bits left (%d max), will get %d bits", n_bits_in_kernel_rng, max_bits_in_kernel_rng, n_bits_to_get);
int n_bytes_to_get = (n_bits_to_get + 7) / 8;
unsigned char *buffer = static_cast<unsigned char *>(malloc(n_bytes_to_get));
if (!buffer)
error_exit("out of memory allocating %d bytes", n_bytes_to_get);
lock_mem(buffer, n_bytes_to_get);
int n_bytes = p -> request_bytes(buffer, n_bits_to_get, false, &do_exit);
if (do_exit)
break;
int is_n_bits = bce.get_bit_count(reinterpret_cast<unsigned char *>(buffer), n_bytes);
int rc = kernel_rng_add_entropy(reinterpret_cast<unsigned char *>(buffer), n_bytes, is_n_bits);
if (rc == -1)
error_exit("error submiting entropy data to kernel");
dolog(LOG_DEBUG, "new entropy count: %d", kernel_rng_get_entropy_count());
memset(buffer, 0x00, n_bytes_to_get);
unlock_mem(buffer, n_bytes_to_get);
free(buffer);
}
}
unlink(pid_file);
delete p;
return 0;
}