entropy_source.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2020 HAW Hamburg
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stddef.h>
#include <inttypes.h>
#include <assert.h>
 
typedef enum {
    ENTROPY_SOURCE_OK               =  0,   
    ENTROPY_SOURCE_ERR_INIT         = -1,   
    ENTROPY_SOURCE_ERR_CONFIG       = -2,   
    ENTROPY_SOURCE_ERR_TEST_REP     = -3,   
    ENTROPY_SOURCE_ERR_TEST_PROP    = -4,   
    ENTROPY_SOURCE_ERR_TEST_BOTH    = -5,   
    ENTROPY_SOURCE_ERR_COND         = -6,   
} entropy_source_error_t;
 
typedef struct {
    uint8_t old_sample;     
    uint16_t cnt_rep;       
    uint8_t c_rep;          
} entropy_source_tests_rep_t;
 
typedef struct {
    uint8_t old_sample;     
    uint16_t cnt_prop;      
    uint16_t cnt_window;    
    uint16_t c_prop;        
} entropy_source_tests_prop_t;
 
#define ENTROPY_SOURCE_HMIN_SCALE(x)    ((x * (1UL << 16)))
 
#define ENTROPY_SOURCE_HMIN_SCALE_BACK(x)    ((float)x / (1UL << 16))
 
#ifndef CONFIG_ENTROPY_SOURCE_TESTS_WIN
#define CONFIG_ENTROPY_SOURCE_TESTS_WIN     (512)
#endif
 
#ifndef CONFIG_ENTROPY_SOURCE_NEUMANN_ABORT
#define CONFIG_ENTROPY_SOURCE_NEUMANN_ABORT (5)
#endif
typedef int (*entropy_source_sample_func_t)(uint8_t *sample);
 
int entropy_source_neumann_unbias(entropy_source_sample_func_t func,
                                  uint8_t *out, size_t len);
 
static inline uint32_t entropy_source_test_rep_cutoff(uint32_t entropy_per_sample)
{
    return (1 + ((20 * 65536) / entropy_per_sample));
}
 
static inline int entropy_source_test_prop_cutoff(uint32_t entropy_per_sample)
{
    int ret;
 
    if (entropy_per_sample < 49152UL) {        /* 0.75 bit/sample */
        ret = 410;
    }
    else if (entropy_per_sample < 98304UL) {   /* 1.5 bit/sample */
        ret = 311;
    }
    else if (entropy_per_sample < 196608UL) {   /* 3 bit/sample */
        ret = 177;
    }
    else if (entropy_per_sample < 393216UL) {   /* 6 bit/sample */
        ret = 62;
    }
    else if (entropy_per_sample <= 524288UL) {  /* 8 bit/sample */
        ret = 13;
    }
    else {
        ret = ENTROPY_SOURCE_ERR_CONFIG;
    }
 
    return ret;
}
 
static inline void entropy_source_test_rep_init(
    entropy_source_tests_rep_t *state, uint16_t c_rep)
{
    assert(state != NULL);
 
    state->old_sample = 0;
    state->cnt_rep = 0;
    state->c_rep = c_rep;
}
 
static inline void entropy_source_test_prop_init(
    entropy_source_tests_prop_t *state, uint16_t c_prop)
{
    assert(state != NULL);
 
    state->old_sample = 0;
    state->cnt_prop = 0;
    state->cnt_window = CONFIG_ENTROPY_SOURCE_TESTS_WIN;
    state->c_prop = c_prop;
}
 
int entropy_source_test_rep(entropy_source_tests_rep_t *state, uint8_t sample);
 
int entropy_source_test_prop(entropy_source_tests_prop_t *state,
                             uint8_t sample);
 
static inline int entropy_source_test(entropy_source_tests_rep_t *state_rep,
                                      entropy_source_tests_prop_t *state_prop,
                                      uint8_t sample)
{
    int ret = ENTROPY_SOURCE_OK;
 
    if (entropy_source_test_rep(state_rep, sample) < 0) {
        ret = ENTROPY_SOURCE_ERR_TEST_REP;
    }
    if (entropy_source_test_prop(state_prop, sample) < 0) {
        /* If repetition count failed before, indicate that both tests failed */
        if (ret == ENTROPY_SOURCE_ERR_TEST_REP) {
            ret = ENTROPY_SOURCE_ERR_TEST_BOTH;
        }
        else {
            ret = ENTROPY_SOURCE_ERR_TEST_PROP;
        }
    }
    return ret;
}
 
#ifdef __cplusplus
}
#endif