From 8a930f2783cfdc4422bf9e568b1d9cee5506215e Mon Sep 17 00:00:00 2001 From: Manuel Domke Date: Sat, 11 Aug 2018 23:16:50 +0200 Subject: [PATCH] fix buffer size for multiplier mode --- software/infnoise.c | 16 +++++++----- software/libinfnoise.c | 48 +++++++++++++++++++++------------- software/libinfnoise_private.h | 2 +- 3 files changed, 41 insertions(+), 25 deletions(-) diff --git a/software/infnoise.c b/software/infnoise.c index 27ebe0c..9d47697 100644 --- a/software/infnoise.c +++ b/software/infnoise.c @@ -86,7 +86,11 @@ bool outputBytes(uint8_t *bytes, uint32_t length, uint32_t entropy, bool writeDe return false; #endif #ifdef LINUX + fputs("room?", stderr); inmWaitForPoolToHaveRoom(); + fputs("room!", stderr); + printf("length: - %ul\n", length); + printf("entropy: - %ul\n", entropy); inmWriteEntropyToPool(bytes, length, entropy); #endif } @@ -274,14 +278,14 @@ int main(int argc, char **argv) { } else { resultSize = opts.outputMultiplier * 32u; } + //fprintf(stderr, "resultsize: %lu\n", resultSize); // endless loop uint64_t totalBytesWritten = 0u; while (true) { uint8_t result[resultSize]; - uint64_t prevTotalBytesWritten = totalBytesWritten; - - totalBytesWritten += readData(&context, result, opts.raw, opts.outputMultiplier); + uint64_t bytesWritten = readData(&context, result, opts.raw, opts.outputMultiplier); + totalBytesWritten += bytesWritten; //fprintf(stderr, "Stats: %d\n", context.entropyThisTime); if (context.errorFlag) { @@ -290,7 +294,7 @@ int main(int argc, char **argv) { } if (!opts.noOutput) { - if (!outputBytes(result, totalBytesWritten - prevTotalBytesWritten, context.entropyThisTime, opts.devRandom, + if (!outputBytes(result, bytesWritten, context.entropyThisTime, opts.devRandom, &context.message)) { fprintf(stderr, "Error: %s\n", context.message); return 1; @@ -298,8 +302,8 @@ int main(int argc, char **argv) { } if (opts.debug && - (1u << 20u) * (totalBytesWritten / (1u << 20u)) > (1u << 20u) * (prevTotalBytesWritten / (1u << 20u))) { + (1u << 20u) * (totalBytesWritten / (1u << 20u)) > (1u << 20u) * (totalBytesWritten + bytesWritten / (1u << 20u))) { fprintf(stderr, "Output %lu bytes\n", (unsigned long) totalBytesWritten); } } -} \ No newline at end of file +} diff --git a/software/libinfnoise.c b/software/libinfnoise.c index 1dc0e94..68885c2 100644 --- a/software/libinfnoise.c +++ b/software/libinfnoise.c @@ -25,6 +25,7 @@ uint8_t keccakState[KeccakPermutationSizeInBytes]; bool initInfnoise(struct infnoise_context *context, char *serial, bool keccak, bool debug) { + context->message=""; prepareOutputBuffer(); // initialize health check @@ -45,6 +46,7 @@ bool initInfnoise(struct infnoise_context *context, char *serial, bool keccak, b if (keccak) { KeccakInitialize(); KeccakInitializeState(keccakState); + //fprintf(stderr, "debug: keccak init: %s\n", context->message); } // let healthcheck collect some data @@ -97,6 +99,7 @@ uint32_t extractBytes(uint8_t *bytes, uint8_t *inBuf, char **message, bool *erro if (!inmHealthCheckAddBit(evenBit, oddBit, even)) { *message = "Health check of Infinite Noise Multiplier failed!"; *errorFlag = true; + fprintf(stderr, "Error: %s\n", *message); return 0; } } @@ -111,12 +114,12 @@ uint32_t extractBytes(uint8_t *bytes, uint8_t *inBuf, char **message, bool *erro // outputMultiplier is 0, we output only as many bits as we measure in entropy. // This allows a user to generate hundreds of MiB per second if needed, for use // as cryptographic keys. -uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t entropy, +uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t *entropy, bool raw, uint32_t outputMultiplier, char **message, bool *errorFlag) { //Use the lower of the measured entropy and the provable lower bound on //average entropy. - if (entropy > inmExpectedEntropyPerBit * BUFLEN / INM_ACCURACY) { - entropy = inmExpectedEntropyPerBit * BUFLEN / INM_ACCURACY; + if (*entropy > inmExpectedEntropyPerBit * BUFLEN / INM_ACCURACY) { + *entropy = inmExpectedEntropyPerBit * BUFLEN / INM_ACCURACY; } if (raw) { // In raw mode, we just output raw data from the INM. @@ -134,21 +137,22 @@ uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t entropy, // gets a snapshot of the keccak state. BUFLEN must be a multiple of 64, since // Keccak-1600 uses 64-bit "lanes". KeccakAbsorb(keccakState, bytes, BUFLEN / 64u); - uint8_t dataOut[16u * 8u]; // ??? + if (outputMultiplier == 0u) { + uint8_t dataOut[*entropy/8u]; // ??? // Output all the bytes of entropy we have - KeccakExtract(keccakState, dataOut, (entropy + 63u) / 64u); + KeccakExtract(keccakState, dataOut, (*entropy + 63u) / 64u); if (result != NULL) { - memcpy(result, dataOut, entropy / 8u * sizeof(uint8_t)); + memcpy(result, dataOut, *entropy / 8u * sizeof(uint8_t)); } - return entropy / 8u; + return *entropy / 8u; } // Output 256*outputMultipler bits. uint32_t numBits = outputMultiplier * 256u; uint32_t bytesWritten = 0u; - + uint8_t dataOut[outputMultiplier * 32u]; // ??? while (numBits > 0u) { // Write up to 1024 bits at a time. uint32_t bytesToWrite = 1024u / 8u; @@ -156,30 +160,34 @@ uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t entropy, bytesToWrite = numBits / 8u; } KeccakExtract(keccakState, dataOut, bytesToWrite / 8u); - uint32_t entropyThisTime = entropy; + uint32_t entropyThisTime = *entropy; if (entropyThisTime > 8u * bytesToWrite) { entropyThisTime = 8u * bytesToWrite; } - memcpy(result + bytesWritten, dataOut, bytesToWrite * sizeof(uint8_t)); // ? +// memcpy(result + bytesWritten, dataOut, bytesToWrite * sizeof(uint8_t)); // ? // alternative: loop through dataOut and append array elements to result.. -// if (result != NULL) { -// for (uint32_t i = 0; i < bytesToWrite; i++) { -// result[bytesWritten + i] = dataOut[i]; -// } -// } + if (result != NULL) { + for (uint32_t i = 0; i < bytesToWrite; i++) { + result[bytesWritten + i] = dataOut[i]; + } + } + //fprintf(stderr, "bytesWritten: %ul\n", bytesWritten); + //fprintf(stderr, "entropy: %ul\n", *entropy); bytesWritten += bytesToWrite; numBits -= bytesToWrite * 8u; - entropy -= entropyThisTime; + *entropy -= entropyThisTime; if (numBits > 0u) { KeccakPermutation(keccakState); } } if (bytesWritten != outputMultiplier * (256u / 8u)) { *message = "Internal error outputting bytes"; + //fprintf(stderr, "ERROR: %ul", bytesWritten); *errorFlag = true; return 0; } + //fprintf(stderr, "bytesWritten_end: %ul\n", bytesWritten); return bytesWritten; } @@ -339,6 +347,7 @@ uint32_t readData(struct infnoise_context *context, uint8_t *result, bool raw, u if (ftdi_read_data(&context->ftdic, inBuf, BUFLEN) != BUFLEN) { context->message = "USB read failed"; context->errorFlag = true; + return 0; } struct timespec end; @@ -347,10 +356,13 @@ uint32_t readData(struct infnoise_context *context, uint8_t *result, bool raw, u if (us <= MAX_MICROSEC_FOR_SAMPLES) { uint8_t bytes[BUFLEN / 8u]; context->entropyThisTime = extractBytes(bytes, inBuf, &context->message, &context->errorFlag); - + if (context->errorFlag) { + //fprintf(stderr, "ERROR1: %ul\n", context->entropyThisTime); + return 0; + } // call health check and return bytes if OK if (inmHealthCheckOkToUseData() && inmEntropyOnTarget(context->entropyThisTime, BUFLEN)) { - return processBytes(bytes, result, context->entropyThisTime, raw, outputMultiplier, &context->message, + return processBytes(bytes, result, &context->entropyThisTime, raw, outputMultiplier, &context->message, &context->errorFlag); } } diff --git a/software/libinfnoise_private.h b/software/libinfnoise_private.h index 253f773..53032f3 100644 --- a/software/libinfnoise_private.h +++ b/software/libinfnoise_private.h @@ -60,7 +60,7 @@ uint32_t extractBytes(uint8_t *bytes, uint8_t *inBuf, char **message, bool *erro bool outputBytes(uint8_t *bytes, uint32_t length, uint32_t entropy, bool writeDevRandom, char **message); -uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t entropy, bool raw, +uint32_t processBytes(uint8_t *bytes, uint8_t *result, uint32_t *entropy, bool raw, uint32_t outputMultiplier, char **message, bool *errorFlag); //uint32_t readData_private(struct infnoise_context *context, uint8_t *result, char **message, bool *errorFlag, bool noOutput, bool raw, uint32_t outputMultiplier, bool devRandom);