salfter/infnoise
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #84 from psiegl/master

Browse Source 
Recursive listUSBdev.()
This commit is contained in:
Manuel Domke
2019-04-01 16:58:15 +02:00
committed by GitHub
parent 561b6b0374 3f12964521
commit 1ee29a0de3
5 changed files with 73 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
software/infnoise.c
View File

@@ -16,8 +16,6 @@
#include <string.h>
#include <signal.h>
#include <time.h>
#include <sys/types.h>
#include <ftdi.h> // requires <sys/types.h>
#include <getopt.h>
#include "infnoise.h"
#include "libinfnoise.h"
@@ -62,7 +60,7 @@ static struct option longopts[] = {
{NULL, 0, NULL, 0}};
// Write the bytes to either stdout, or /dev/random.
bool outputBytes(uint8_t *bytes, uint32_t length, uint32_t entropy, bool writeDevRandom, char **message) {
bool outputBytes(uint8_t *bytes, uint32_t length, uint32_t entropy, bool writeDevRandom, const char **message) {
if (!writeDevRandom) {
if (fwrite(bytes, 1, length, stdout) != length) {
*message = "Unable to write output from Infinite Noise Multiplier";
@@ -223,19 +221,19 @@ int main(int argc, char **argv) {
}
if (opts.listDevices) {
devlist_node devlist = listUSBDevices(&context.message);
infnoise_devlist_node_t* devlist = listUSBDevices(&context.message);
if (devlist == NULL) {
fprintf(stderr, "Error: %s\n", context.message);
return 1;
}
devlist_node curdev;
for (curdev = devlist; curdev != NULL; ) {
infnoise_devlist_node_t* curdev;
int id = 0;
for (curdev = devlist; curdev != NULL; id++) {
printf("ID: %i, Manufacturer: %s, Description: %s, Serial: %s\n",
curdev->id, curdev->manufacturer,
curdev->description, curdev->serial);
id, curdev->manufacturer, curdev->description, curdev->serial);
// cleanup:
devlist_node olddev = curdev;
infnoise_devlist_node_t* olddev = curdev;
curdev = curdev->next;
free(olddev);
}

1
software/infnoise.h
View File

@@ -6,7 +6,6 @@
#else
#include <linux/limits.h>
#endif
#include <ftdi.h>
// Structure for parsed command line options
struct opt_struct {

94
software/libinfnoise.c
View File

@@ -73,6 +73,7 @@ bool initInfnoise(struct infnoise_context *context, char *serial, bool keccak, b
void deinitInfnoise(struct infnoise_context *context)
{
inmHealthCheckStop();
ftdi_usb_close(&context->ftdic);
ftdi_deinit(&context->ftdic);
}
@@ -93,7 +94,7 @@ void prepareOutputBuffer() {
// changes, not both, so alternate reading bits from them. We get 1 INM bit of output
// per byte read. Feed bits from the INM to the health checker. Return the expected
// bits of entropy.
uint32_t extractBytes(uint8_t *bytes, uint32_t length, uint8_t *inBuf, char **message, bool *errorFlag) {
uint32_t extractBytes(uint8_t *bytes, uint32_t length, uint8_t *inBuf, const char **message, bool *errorFlag) {
inmClearEntropyLevel();
uint32_t i;
for (i = 0u; i < length; i++) {
@@ -198,55 +199,76 @@ bool isSuperUser(void) {
return (geteuid() == 0);
}
// let's do it recursive, because if sth. fails we can easily wipe the malloc()
infnoise_devlist_node_t* inf_get_devstrings(struct ftdi_context* ftdic,
struct ftdi_device_list* curdev,
const char** message,
infnoise_devlist_node_t* bgn,
infnoise_devlist_node_t* end) {
if( curdev != NULL ) {
infnoise_devlist_node_t* cur;
cur = (infnoise_devlist_node_t*) malloc (sizeof(infnoise_devlist_node_t));
cur->next = NULL;
int rc = ftdi_usb_get_strings(ftdic, curdev->dev,
cur->manufacturer, sizeof(cur->manufacturer),
cur->description, sizeof(cur->description),
cur->serial, sizeof(cur->serial));
if (rc < 0) {
*message = ftdi_get_error_string(ftdic);
free( cur );
return NULL;
}
else {
// in case bgn is NULL, then implicitly end is NULL, also the other way around
if(bgn == NULL) {
bgn = cur;
}
else {
end->next = cur;
}
infnoise_devlist_node_t* ret;
ret = inf_get_devstrings(ftdic, curdev->next, message, bgn, cur);
// a next dev triggered issue? -> wipe current
if( ret == NULL ) {
free( cur );
}
return ret;
}
}
return bgn;
}
// Return a list of all infinite noise multipliers found.
devlist_node listUSBDevices(char **message) {
infnoise_devlist_node_t* listUSBDevices(const char **message) {
struct ftdi_context ftdic;
ftdi_init(&ftdic);
if(ftdi_init(&ftdic) < 0) {
*message = "Failed to init";
return NULL;
}
infnoise_devlist_node_t* retlist = NULL;
struct ftdi_device_list *devlist = NULL;
// search devices
int rc = ftdi_usb_find_all(&ftdic, &devlist, INFNOISE_VENDOR_ID, INFNOISE_PRODUCT_ID);
if (rc < 0) {
if (ftdi_usb_find_all(&ftdic, &devlist, INFNOISE_VENDOR_ID, INFNOISE_PRODUCT_ID) < 0
|| devlist == NULL) {
if (!isSuperUser()) {
*message = "Can't find Infinite Noise Multiplier. Try running as super user?";
} else {
*message = "Can't find Infinite Noise Multiplier.";
}
return NULL;
}
else {
retlist = inf_get_devstrings(&ftdic, devlist, message, NULL, NULL);
ftdi_list_free2(devlist);
}
devlist_node return_list = malloc(sizeof(struct infnoise_devlist_node));
devlist_node current_entry = return_list;
int i = 0;
struct ftdi_device_list *curdev = NULL;
for (curdev = devlist; curdev != NULL; curdev = curdev->next, i++) {
rc = ftdi_usb_get_strings(&ftdic, curdev->dev,
current_entry->manufacturer, sizeof(current_entry->manufacturer),
current_entry->description, sizeof(current_entry->description),
current_entry->serial, sizeof(current_entry->serial));
if (rc < 0) {
if (!isSuperUser()) {
*message = "Can't find Infinite Noise Multiplier. Try running as super user?";
} else {
sprintf(*message, "ftdi_usb_get_strings failed: %d (%s)", rc, ftdi_get_error_string(&ftdic));
}
return NULL;
}
current_entry->id = i;
if (curdev->next) {
current_entry->next = malloc(sizeof(struct infnoise_devlist_node));
current_entry = current_entry->next;
} else {
current_entry->next = NULL;
}
}
ftdi_list_free2(devlist);
return return_list;
ftdi_deinit(&ftdic);
return retlist;
}
// Initialize the Infinite Noise Multiplier USB interface.
bool initializeUSB(struct ftdi_context *ftdic, char **message, char *serial) {
bool initializeUSB(struct ftdi_context *ftdic, const char **message, char *serial) {
ftdi_init(ftdic);
struct ftdi_device_list *devlist;

12
software/libinfnoise.h
View File

@@ -16,7 +16,7 @@
struct infnoise_context {
struct ftdi_context ftdic;
uint32_t entropyThisTime;
char *message;
const char *message;
bool errorFlag;
//uint8_t keccakState[KeccakPermutationSizeInBytes];
@@ -25,16 +25,14 @@ struct infnoise_context {
uint32_t bytesWritten;
};
struct infnoise_devlist_node {
uint8_t id;
typedef struct _infnoise_devlist_node_t infnoise_devlist_node_t;
struct _infnoise_devlist_node_t {
char manufacturer[128];
char description[128];
char serial[128];
struct infnoise_devlist_node *next;
infnoise_devlist_node_t *next;
};
typedef struct infnoise_devlist_node *devlist_node;
/*
* returns a struct of infnoise_devlist_node listing all connected FTDI FT240 devices by their USB descriptors
*
@@ -43,7 +41,7 @@ typedef struct infnoise_devlist_node *devlist_node;
*
* returns: NULL when none found or infnoise_devlist_node
*/
devlist_node listUSBDevices(char **message);
infnoise_devlist_node_t* listUSBDevices(const char **message);
/*
* initialize the Infinite Noise TRNG - must be called once before readData() works

7
software/libinfnoise_private.h
View File

@@ -51,14 +51,13 @@ void inmDumpStats(void);
extern double inmK, inmExpectedEntropyPerBit;
bool initializeUSB(struct ftdi_context *ftdic, char **message,char *serial);
bool initializeUSB(struct ftdi_context *ftdic, const char **message,char *serial);
void prepareOutputBuffer();
struct timespec;
double diffTime(struct timespec *start, struct timespec *end);
uint32_t extractBytes(uint8_t *bytes, uint32_t length, uint8_t *inBuf, char **message, bool *errorFlag);
uint32_t extractBytes(uint8_t *bytes, uint32_t length, uint8_t *inBuf, const char **message, bool *errorFlag);
bool outputBytes(uint8_t *bytes, uint32_t length, uint32_t entropy, bool writeDevRandom, char **message);
bool outputBytes(uint8_t *bytes, uint32_t length, uint32_t entropy, bool writeDevRandom, const char **message);
uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t *entropy, uint32_t *numBits, uint32_t *bytesWritten, bool raw,
uint32_t outputMultiplier);