/* LibTomCrypt, modular cryptographic library -- Tom St Denis
 *
 * LibTomCrypt is a library that provides various cryptographic
 * algorithms in a highly modular and flexible manner.
 *
 * The library is free for all purposes without any express
 * guarantee it works.
 *
 * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
 */
#include "tomcrypt.h"

/**
  @file crypt_constants.c

  Make various constants available to dynamic languages
  like Python - Larry Bugbee, February 2013

  LB - Dec 2013 - revised to include compiler define options
  LB - Mar 2014 - added endianness and word size
*/

typedef struct {
    const char *name;
    const int value;
} crypt_constant;

#define _C_STRINGIFY(s) { #s, s }

static const crypt_constant _crypt_constants[] = {
    _C_STRINGIFY(PK_PUBLIC),
    _C_STRINGIFY(PK_PRIVATE),

    _C_STRINGIFY(PKA_RSA),
    _C_STRINGIFY(PKA_DSA),

#ifdef LTC_PKCS_1
    {"LTC_PKCS_1", 1},
    /* Block types */
    _C_STRINGIFY(LTC_PKCS_1_EMSA),
    _C_STRINGIFY(LTC_PKCS_1_EME),

    /* Padding types */
    _C_STRINGIFY(LTC_PKCS_1_V1_5),
    _C_STRINGIFY(LTC_PKCS_1_OAEP),
    _C_STRINGIFY(LTC_PKCS_1_PSS),
#else
    {"LTC_PKCS_1", 0},
#endif

#ifdef LTC_MRSA
    {"LTC_MRSA", 1},
    _C_STRINGIFY(MIN_RSA_SIZE),
    _C_STRINGIFY(MAX_RSA_SIZE),
#else
    {"LTC_MRSA", 0},
#endif

#ifdef LTC_MKAT
    {"LTC_MKAT", 1},
    _C_STRINGIFY(MIN_KAT_SIZE),
    _C_STRINGIFY(MAX_KAT_SIZE),
#else
    {"LTC_MKAT", 0},
#endif

#ifdef LTC_MECC
    {"LTC_MECC", 1},
    _C_STRINGIFY(ECC_BUF_SIZE),
    _C_STRINGIFY(ECC_MAXSIZE),
#else
    {"LTC_MECC", 0},
#endif

#ifdef LTC_MDSA
    {"LTC_MDSA", 1},
    _C_STRINGIFY(LTC_MDSA_DELTA),
    _C_STRINGIFY(LTC_MDSA_MAX_GROUP),
#else
    {"LTC_MDSA", 0},
#endif

#ifdef LTC_CTR_MODE
    {"LTC_CTR_MODE", 1},
    _C_STRINGIFY(CTR_COUNTER_LITTLE_ENDIAN),
    _C_STRINGIFY(CTR_COUNTER_BIG_ENDIAN),
    _C_STRINGIFY(LTC_CTR_RFC3686),
#else
    {"LTC_CTR_MODE", 0},
#endif

    _C_STRINGIFY(MAXBLOCKSIZE),
    _C_STRINGIFY(TAB_SIZE),
    _C_STRINGIFY(ARGTYPE),

#ifdef LTM_DESC
    {"LTM_DESC", 1},
#else
    {"LTM_DESC", 0},
#endif
#ifdef TFM_DESC
    {"TFM_DESC", 1},
#else
    {"TFM_DESC", 0},
#endif
#ifdef GMP_DESC
    {"GMP_DESC", 1},
#else
    {"GMP_DESC", 0},
#endif

#ifdef LTC_FAST
    {"LTC_FAST", 1},
#else
    {"LTC_FAST", 0},
#endif

#ifdef LTC_NO_FILE
    {"LTC_NO_FILE", 1},
#else
    {"LTC_NO_FILE", 0},
#endif

#ifdef ENDIAN_LITTLE
    {"ENDIAN_LITTLE",             1},
#else
    {"ENDIAN_LITTLE",             0},
#endif

#ifdef ENDIAN_BIG
    {"ENDIAN_BIG",                1},
#else
    {"ENDIAN_BIG",                0},
#endif

#ifdef ENDIAN_32BITWORD
    {"ENDIAN_32BITWORD",          1},
#else
    {"ENDIAN_32BITWORD",          0},
#endif

#ifdef ENDIAN_64BITWORD
    {"ENDIAN_64BITWORD",          1},
#else
    {"ENDIAN_64BITWORD",          0},
#endif

#ifdef ENDIAN_NEUTRAL
    {"ENDIAN_NEUTRAL",            1},
#else
    {"ENDIAN_NEUTRAL",            0},
#endif
};


/* crypt_get_constant()
 * valueout will be the value of the named constant
 * return -1 if named item not found
 */
int crypt_get_constant(const char* namein, int *valueout) {
    int i;
    int _crypt_constants_len = sizeof(_crypt_constants) / sizeof(_crypt_constants[0]);
    for (i=0; i<_crypt_constants_len; i++) {
        if (XSTRCMP(_crypt_constants[i].name, namein) == 0) {
            *valueout = _crypt_constants[i].value;
            return 0;
        }
    }
    return 1;
}

/* crypt_list_all_constants()
 * if names_list is NULL, names_list_size will be the minimum
 *     number of bytes needed to receive the complete names_list
 * if names_list is NOT NULL, names_list must be the addr of
 *     sufficient memory allocated into which the names_list
 *     is to be written.  Also, the value in names_list_size
 *     sets the upper bound of the number of characters to be
 *     written.
 * a -1 return value signifies insufficient space made available
 */
int crypt_list_all_constants(char *names_list, unsigned int *names_list_size) {
    int i;
    unsigned int total_len = 0;
    char number[32], *ptr;
    int number_len;
    int count = sizeof(_crypt_constants) / sizeof(_crypt_constants[0]);

    /* calculate amount of memory required for the list */
    for (i=0; i<count; i++) {
        total_len += strlen(_crypt_constants[i].name) + 1;
        /* the above +1 is for the commas */
        number_len = snprintf(number, sizeof(number), "%d", _crypt_constants[i].value);
        if ((number_len < 0) ||
            ((unsigned int)number_len >= sizeof(number)))
          return -1;
        total_len += number_len + 1;
        /* this last +1 is for newlines (and ending NULL) */
    }

    if (names_list == NULL) {
        *names_list_size = total_len;
    } else {
        if (total_len > *names_list_size) {
            return -1;
        }
        /* build the names list */
        ptr = names_list;
        for (i=0; i<count; i++) {
            strcpy(ptr, _crypt_constants[i].name);
            ptr += strlen(_crypt_constants[i].name);
            strcpy(ptr, ",");
            ptr += 1;

            number_len = snprintf(number, sizeof(number), "%d", _crypt_constants[i].value);
            strcpy(ptr, number);
            ptr += number_len;
            strcpy(ptr, "\n");
            ptr += 1;
        }
        /* to remove the trailing new-line */
        ptr -= 1;
        *ptr = 0;
    }
    return 0;
}


/* $Source$ */
/* $Revision$ */
/* $Date$ */