mphell-util.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-util.h"

uint8_t 
bits_to_nblock (const uint16_t nbits)
{
    return (uint8_t)((nbits / BLOCK_SIZE) + ((nbits % BLOCK_SIZE) != 0));
}

uint8_t max_size(uint8_t a, uint8_t b)
{
    return b < a ? a : b;
}

time_t get_s(struct timespec * start,  struct timespec * end)
{
    if((end->tv_nsec - start->tv_nsec)>0)
    {
        return (end->tv_sec - start->tv_sec);
    }
    return (end->tv_sec - start->tv_sec - 1);
}

unsigned int get_ns(struct timespec * start,  struct timespec * end)
{
    long t = end->tv_nsec - start->tv_nsec;
    if (t>0)
    {
        return (unsigned int)floor(t/1000000);
    }
    return (unsigned int)floor((1000000000 + t)/1000000);
}

void print_bytes_string_hex(const uint8_t * bytes_string, uint16_t length)
{
    int i;
    for (i=0; i<length; i++)
    {
        printf("%02x", bytes_string[i]);
    }
}

void bytes_string2hex(char * hex_string, const uint8_t * bytes_string, uint16_t length)
{
    int i;
    char * hex_string_pointer = hex_string;
    for (i=0; i<length; i++)
    {
        sprintf(hex_string_pointer, "%02x", bytes_string[i]);
        hex_string_pointer+=2;
    }
}

void hex_string2bytes(uint8_t * bytes_string, const char * hex_string, uint16_t length)
{
    int i;
    char buf[5];
    buf[0]='0';
    buf[1]='x';
    buf[4]='\0';
    const char * hex_string_pointer = hex_string;
    for (i = 0; i < length; i++) 
    {
        buf[2] = hex_string_pointer[0];
        buf[3] = hex_string_pointer[1];
        bytes_string[i] = strtol(buf, NULL, 0);
        hex_string_pointer += 2;
    }
}

void bin2hex(const unsigned char *old, const uint32_t oldlen, unsigned char* result)
{
    uint32_t i, j;
    int32_t b = 0;

    for (i = j = 0; i < oldlen; i++) 
    {
        b = old[i] >> 4;
        result[j++] = (char) (87 + b + (((b - 10) >> 31) & -39));
        b = old[i] & 0xf;
        result[j++] = (char) (87 + b + (((b - 10) >> 31) & -39));
    }
    result[j] = '\0';
}


uint32_t hex2bin(const char *in, unsigned char *out)
{
    uint32_t n1, n2;
    unsigned char ch;
    uint32_t len = strlen(in);
    
    n2 = n1 = 0;
    if (len % 2 != 0) 
    {
        if ((in[n1] >= '0') && (in[n1] <= '9'))
            ch = in[n1++] - '0';
        else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
            ch = in[n1++] - 'A' + 10;
        else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
            ch = in[n1++] - 'a' + 10;
        else
            return -1;

        out[n2++] = ch;
    }

    for (; in[n1] && in[n1] != '\n' && in[n1] != '\r';) 
    {   /* first byte */
        if ((in[n1] >= '0') && (in[n1] <= '9'))
            ch = in[n1++] - '0';
        else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
            ch = in[n1++] - 'A' + 10;
        else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
            ch = in[n1++] - 'a' + 10;
        else
            return -1;
        if (!in[n1]) 
        {
            out[n2++] = ch;
            break;
        }
        out[n2] = ch << 4;
        /* second byte */
        if ((in[n1] >= '0') && (in[n1] <= '9'))
            ch = in[n1++] - '0';
        else if ((in[n1] >= 'A') && (in[n1] <= 'F'))
            ch = in[n1++] - 'A' + 10;
        else if ((in[n1] >= 'a') && (in[n1] <= 'f'))
            ch = in[n1++] - 'a' + 10;
        else
            return -1;
        out[n2++] |= ch;
    }
    return n2;
}

/* For aes test */

#define MAX_MARKER_LEN 50

int 
FindMarker (FILE *infile, const char *marker)
{
    char line[MAX_MARKER_LEN];
    int i, len;

    len = (int)strlen(marker);
    if ( len > MAX_MARKER_LEN-1 )
        len = MAX_MARKER_LEN-1;

    for ( i=0; i<len; i++ )
        if ( (line[i] = fgetc(infile)) == EOF )
            return 0;
    line[len] = '\0';

    while ( 1 ) 
    {
        if ( !strncmp(line, marker, len) )
            return 1;

        for ( i=0; i<len-1; i++ )
            line[i] = line[i+1];
        if ( (line[len-1] = fgetc(infile)) == EOF )
            return 0;
        line[len] = '\0';
    }
    return 0;
}

int 
ReadHex (FILE *infile, char *A, const int Length, char *str)
{
    int i, ch, started;
    uint8_t ich = 0;

    if ( Length == 0 ) {
        A[0] = 0x00;
        return 1;
    }
    memset(A, '0', Length/2);
    started = 0;
    i = 0;
    if ( FindMarker(infile, str) )
        while ( (ch = fgetc(infile)) != EOF ) 
        {
            if ( !isxdigit(ch) ) 
            {
                if ( !started ) 
                {
                    if ((ch == '\n') || (ch =='\0'))
                        break;
                    else
                        continue;
                }
                else
                    break;
            }
            started = 1;
            if ( (ch >= '0') && (ch <= '9') )
                ich = ch - '0';
            else if ( (ch >= 'A') && (ch <= 'F') )
                ich = ch - 'A' + 10;
            else if ( (ch >= 'a') && (ch <= 'f') )
                ich = ch - 'a' + 10;
            A[i / 2] = (A[i / 2] << 4) | ich;
            if ( (++i / 2) == Length )
                break;
        }
    else
        return 0;

    return 1;
}

/* For ecdsa benchmark */

void char2bin(char c, uint8_t * b)
{
    int8_t i;
    for (i = 7; i >= 0; --i)
    {
        if(c & (1 << i))
        {  
            *b ^= (1 << i);
        }
    }
}

void printchar2bin(uint8_t b)
{
    int8_t i;
    for (i = 7; i >= 0; --i)
    {
        if(b & (1 << i))
        {  
            printf("1");
        }
        else
        {
            printf("0");
        }
    }
    printf(" ");
}

void string2bin(char* s, uint8_t * output)
{
    uint32_t len = strlen(s);
    uint32_t i;
    for(i=0; i<len; i++)
    {
        char2bin(s[i], output+i); 
    }
}

void printstring2bin(uint8_t * s, uint32_t len)
{
    uint32_t i;
    for(i=0; i<len; i++)
    {
        printchar2bin(s[i]); 
    }
}