mphell-entropy.c

Go to the documentation of this file.

/* 
  MPHELL-4.0 
  Author(s): The MPHELL team

 (C) Copyright 2015-2018 - Institut Fourier / Univ. Grenoble Alpes (France) 

 This file is part of the MPHELL Library.
 MPHELL is free software: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, version 3 of the License.
 
 MPHELL is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with MPHELL.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "mphell-entropy.h"

typedef struct cpuid_struct {
    unsigned int eax;
    unsigned int ebx;
    unsigned int ecx;
    unsigned int edx;
} cpuid_t;

void cpuid (cpuid_t *info, unsigned int leaf, unsigned int subleaf)
{
#if __x86_64__
    asm volatile("cpuid"
    : "=a" (info->eax), "=b" (info->ebx), "=c" (info->ecx), "=d" (info->edx)
    : "a" (leaf), "c" (subleaf)
    );
#endif
}

int _is_intel_cpu ()
{
    static int intel_cpu= -1;
#if __x86_64__
    cpuid_t info;

    if ( intel_cpu == -1 ) {
        cpuid(&info, 0, 0);

        if (
            memcmp((char *) &info.ebx, "Genu", 4) ||
            memcmp((char *) &info.edx, "ineI", 4) ||
            memcmp((char *) &info.ecx, "ntel", 4)
        ) {
            intel_cpu= 0;
        } else {
            intel_cpu= 1;
        }
    }
#endif
    return intel_cpu;
}

/* These are bits that are OR’d together */

#define DRNG_NO_SUPPORT 0x0 /* For clarity */
#define DRNG_HAS_RDRAND 0x1
#define DRNG_HAS_RDSEED 0x2

int get_drng_support ()
{
    static int drng_features= -1;
#if __x86_64__
    /* So we don't call cpuid multiple times for 
     * the same information */

    if ( drng_features == -1 ) {
        drng_features= DRNG_NO_SUPPORT;

        if ( _is_intel_cpu() ) {
            cpuid_t info;

            cpuid(&info, 1, 0);

            if ( (info.ecx & 0x40000000) == 0x40000000 ) {
                drng_features|= DRNG_HAS_RDRAND;
            }

            cpuid(&info, 7, 0);

            if ( (info.ebx & 0x40000) == 0x40000 ) {
                drng_features|= DRNG_HAS_RDSEED;
            }
        } 
    }
#endif
    return drng_features;
}

#if MPHELL_USE_RDSEED == 1

int rdseed16_step (uint16_t *seed)
{
    unsigned char ok;
 
    asm volatile ("rdseed %0; setc %1"
        : "=r" (*seed), "=qm" (ok));
 
    return (int) ok;
}

int rdseed16_with_retry (uint16_t *seed, uint8_t nb_retry)
{
    int success = 0;
    uint8_t c = 0;
    while(c < nb_retry)
    {
        success=rdseed16_step(seed);
        c++;
        if(success)
        {
            return success;
        }
    }
    return success;
}

#elif MPHELL_USE_RDSEED == 0

int rdseed16_with_retry (uint16_t *seed, uint8_t nb_retry)
{
    /* Intel instruction RDSEED is not available, nb: gcc >= 4.8 is required */
    return 0;
}

#endif

void intel_rdseed(mphell_status ret, uint8_t *data, const uint16_t length)
{
    if(get_drng_support() < 2)
    {
        ret->flag = MPHELL_CATASTROPHIC_ERROR_RANDOM;
        char *text = "intel_rdrand : intel rdseed not available";
        ret->info = malloc(strlen(text));
        memcpy(ret->info, text, strlen(text));
        memset(data, 0, length);
        return;    
    }

    uint16_t nb = ceil((float)length / 2);
    uint16_t tmp[nb];
    uint16_t i = 0;

    for(i = 0; i < nb; i++)
    {
        if(rdseed16_with_retry(tmp + i, 10) != 1)
        {
            ret->flag = MPHELL_ERROR_RANDOM;
            char *text = "intel_rdseed : unable to generate bytes";
            mphell_error("RDSEED pb step\n");
            ret->info = malloc(strlen(text));
            memcpy(ret->info, text, strlen(text));
            memset(data, 0, length);
            return;
        }
    }
    memcpy(data, tmp, length);

    ret->flag = MPHELL_SUCCESS;   
}

void dev_urandom(mphell_status ret, uint8_t *data, const uint16_t length)
{
    FILE *fd = NULL;

    fd = fopen("/dev/urandom", "rb"); 

    if(fd == NULL)
    {
        ret->flag = MPHELL_CATASTROPHIC_ERROR_RANDOM;
        char *text = "dev_urandom : file /dev/urandom not available";
        ret->info = malloc(strlen(text));
        memcpy(ret->info, text, strlen(text));
        memset(data, 0, length);
        return;
    }

    if(fread(data, 1, length, fd) != length)
    {
        ret->flag = MPHELL_ERROR_RANDOM;
        char *text = "dev_urandom : unable to generate bytes";
        ret->info = malloc(strlen(text));
        memcpy(ret->info, text, strlen(text));
        memset(data, 0, length);
        fclose(fd);
        return;
    }
    fclose(fd);
    ret->flag = MPHELL_SUCCESS;
}

void dev_random(mphell_status ret, uint8_t *data, const uint16_t length)
{
    FILE *fd = NULL;

    fd = fopen("/dev/random", "rb"); 
    
    if(fd == NULL)
    {
        ret->flag = MPHELL_CATASTROPHIC_ERROR_RANDOM;
        char *text = "dev_random : file /dev/random not available";
        ret->info = malloc(strlen(text));
        memcpy(ret->info, text, strlen(text));
        memset(data, 0, length);
        return;
    }

    if(fread(data, 1, length, fd) != length)
    {
        ret->flag = MPHELL_ERROR_RANDOM;
        char *text = "dev_random : unable to generate bytes";
        ret->info = malloc(strlen(text));
        memcpy(ret->info, text, strlen(text));
        memset(data, 0, length);
        fclose(fd);
        return;
    }
    fclose(fd);
    ret->flag = MPHELL_SUCCESS;
}

void
get_entropy_input(mphell_status ret, uint8_t *data,
        const entropy_type entropy_src, const uint16_t length)
{
    switch(entropy_src)
    {
        case INTEL :
            intel_rdseed(ret, data, length);
            break;

        case DEVURANDOM :
            dev_urandom(ret, data, length);
            break;

        case DEVRANDOM :
            dev_random(ret, data, length);
            break;

        default :
            ret->flag = MPHELL_ERROR_RANDOM;
            char *text = "get_entropy_input : Invalid entropy src";
            ret->info = malloc(strlen(text));
            memcpy(ret->info, text, strlen(text));
    }    
}