Home | History | Annotate | Download | only in axtls 
      1 /*
      2  *  Copyright(C) 2006 Cameron Rich
      3  *
      4  *  This library is free software; you can redistribute it and/or modify
      5  *  it under the terms of the GNU Lesser General Public License as published by
      6  *  the Free Software Foundation; either version 2 of the License, or
      7  *  (at your option) any later version.
      8  *
      9  *  This library is distributed in the hope that it will be useful,
     10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     12  *  GNU Lesser General Public License for more details.
     13  *
     14  *  You should have received a copy of the GNU Lesser General Public License
     15  *  along with this library; if not, write to the Free Software
     16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     17  */
     18 
     19 /**
     20  * @file crypto.h
     21  */
     22 
     23 #ifndef HEADER_CRYPTO_H
     24 #define HEADER_CRYPTO_H
     25 
     26 #ifdef __cplusplus
     27 extern "C" {
     28 #endif
     29 
     30 #include "bigint.h"
     31 
     32 /**************************************************************************
     33  * AES declarations
     34  **************************************************************************/
     35 
     36 #define AES_MAXROUNDS			14
     37 
     38 typedef struct aes_key_st
     39 {
     40     uint16_t rounds;
     41     uint16_t key_size;
     42     uint32_t ks[(AES_MAXROUNDS+1)*8];
     43     uint8_t iv[16];
     44 } AES_CTX;
     45 
     46 typedef enum
     47 {
     48     AES_MODE_128,
     49     AES_MODE_256
     50 } AES_MODE;
     51 
     52 void AES_set_key(AES_CTX *ctx, const uint8_t *key,
     53         const uint8_t *iv, AES_MODE mode);
     54 void AES_cbc_encrypt(AES_CTX *ctx, const uint8_t *msg,
     55         uint8_t *out, int length);
     56 void AES_cbc_decrypt(AES_CTX *ks, const uint8_t *in, uint8_t *out, int length);
     57 void AES_convert_key(AES_CTX *ctx);
     58 void AES_encrypt(const AES_CTX *ctx, uint32_t *data);
     59 void AES_decrypt(const AES_CTX *ctx, uint32_t *data);
     60 
     61 /**************************************************************************
     62  * RC4 declarations
     63  **************************************************************************/
     64 
     65 typedef struct
     66 {
     67     int x, y, m[256];
     68 } RC4_CTX;
     69 
     70 void RC4_setup(RC4_CTX *s, const uint8_t *key, int length);
     71 void RC4_crypt(RC4_CTX *s, const uint8_t *msg, uint8_t *data, int length);
     72 
     73 /**************************************************************************
     74  * SHA1 declarations
     75  **************************************************************************/
     76 
     77 #define SHA1_SIZE   20
     78 
     79 /*
     80  *  This structure will hold context information for the SHA-1
     81  *  hashing operation
     82  */
     83 typedef struct
     84 {
     85     uint32_t Intermediate_Hash[SHA1_SIZE/4]; /* Message Digest  */
     86     uint32_t Length_Low;            /* Message length in bits      */
     87     uint32_t Length_High;           /* Message length in bits      */
     88     uint16_t Message_Block_Index;   /* Index into message block array   */
     89     uint8_t Message_Block[64];      /* 512-bit message blocks      */
     90 } SHA1_CTX;
     91 
     92 void SHA1Init(SHA1_CTX *);
     93 void SHA1Update(SHA1_CTX *, const uint8_t * msg, int len);
     94 void SHA1Final(SHA1_CTX *, uint8_t *digest);
     95 
     96 /**************************************************************************
     97  * MD5 declarations
     98  **************************************************************************/
     99 
    100 /* MD5 context. */
    101 
    102 #define MD5_SIZE    16
    103 
    104 typedef struct
    105 {
    106   uint32_t state[4];        /* state (ABCD) */
    107   uint32_t count[2];        /* number of bits, modulo 2^64 (lsb first) */
    108   uint8_t buffer[64];       /* input buffer */
    109 } MD5_CTX;
    110 
    111 void MD5Init(MD5_CTX *);
    112 void MD5Update(MD5_CTX *, const uint8_t *msg, int len);
    113 void MD5Final(MD5_CTX *, uint8_t *digest);
    114 
    115 /**************************************************************************
    116  * HMAC declarations
    117  **************************************************************************/
    118 void hmac_md5(const uint8_t *msg, int length, const uint8_t *key,
    119         int key_len, uint8_t *digest);
    120 void hmac_sha1(const uint8_t *msg, int length, const uint8_t *key,
    121         int key_len, uint8_t *digest);
    122 
    123 /**************************************************************************
    124  * RNG declarations
    125  **************************************************************************/
    126 void RNG_initialize(const uint8_t *seed_buf, int size);
    127 void RNG_terminate(void);
    128 void get_random(int num_rand_bytes, uint8_t *rand_data);
    129 //void get_random_NZ(int num_rand_bytes, uint8_t *rand_data);
    130 
    131 #include <string.h>
    132 static inline void get_random_NZ(int num_rand_bytes, uint8_t *rand_data) {
    133 	memset ( rand_data, 0x01, num_rand_bytes );
    134 }
    135 
    136 /**************************************************************************
    137  * RSA declarations
    138  **************************************************************************/
    139 
    140 typedef struct
    141 {
    142     bigint *m;              /* modulus */
    143     bigint *e;              /* public exponent */
    144     bigint *d;              /* private exponent */
    145 #ifdef CONFIG_BIGINT_CRT
    146     bigint *p;              /* p as in m = pq */
    147     bigint *q;              /* q as in m = pq */
    148     bigint *dP;             /* d mod (p-1) */
    149     bigint *dQ;             /* d mod (q-1) */
    150     bigint *qInv;           /* q^-1 mod p */
    151 #endif
    152     int num_octets;
    153     bigint *sig_m;         /* signature modulus */
    154     BI_CTX *bi_ctx;
    155 } RSA_CTX;
    156 
    157 void RSA_priv_key_new(RSA_CTX **rsa_ctx,
    158         const uint8_t *modulus, int mod_len,
    159         const uint8_t *pub_exp, int pub_len,
    160         const uint8_t *priv_exp, int priv_len
    161 #ifdef CONFIG_BIGINT_CRT
    162       , const uint8_t *p, int p_len,
    163         const uint8_t *q, int q_len,
    164         const uint8_t *dP, int dP_len,
    165         const uint8_t *dQ, int dQ_len,
    166         const uint8_t *qInv, int qInv_len
    167 #endif
    168         );
    169 void RSA_pub_key_new(RSA_CTX **rsa_ctx,
    170         const uint8_t *modulus, int mod_len,
    171         const uint8_t *pub_exp, int pub_len);
    172 void RSA_free(RSA_CTX *ctx);
    173 int RSA_decrypt(const RSA_CTX *ctx, const uint8_t *in_data, uint8_t *out_data,
    174         int is_decryption);
    175 bigint *RSA_private(const RSA_CTX *c, bigint *bi_msg);
    176 #ifdef CONFIG_SSL_CERT_VERIFICATION
    177 bigint *RSA_raw_sign_verify(RSA_CTX *c, bigint *bi_msg);
    178 bigint *RSA_sign_verify(BI_CTX *ctx, const uint8_t *sig, int sig_len,
    179         bigint *modulus, bigint *pub_exp);
    180 bigint *RSA_public(const RSA_CTX *c, bigint *bi_msg);
    181 int RSA_encrypt(const RSA_CTX *ctx, const uint8_t *in_data, uint16_t in_len,
    182         uint8_t *out_data, int is_signing);
    183 void RSA_print(const RSA_CTX *ctx);
    184 #endif
    185 
    186 /**************************************************************************
    187  * ASN1 declarations
    188  **************************************************************************/
    189 #define X509_OK                             0
    190 #define X509_NOT_OK                         -1
    191 #define X509_VFY_ERROR_NO_TRUSTED_CERT      -2
    192 #define X509_VFY_ERROR_BAD_SIGNATURE        -3
    193 #define X509_VFY_ERROR_NOT_YET_VALID        -4
    194 #define X509_VFY_ERROR_EXPIRED              -5
    195 #define X509_VFY_ERROR_SELF_SIGNED          -6
    196 #define X509_VFY_ERROR_INVALID_CHAIN        -7
    197 #define X509_VFY_ERROR_UNSUPPORTED_DIGEST   -8
    198 #define X509_INVALID_PRIV_KEY               -9
    199 
    200 /*
    201  * The Distinguished Name
    202  */
    203 #define X509_NUM_DN_TYPES                   3
    204 #define X509_COMMON_NAME                    0
    205 #define X509_ORGANIZATION                   1
    206 #define X509_ORGANIZATIONAL_TYPE            2
    207 
    208 #define ASN1_INTEGER            0x02
    209 #define ASN1_BIT_STRING         0x03
    210 #define ASN1_OCTET_STRING       0x04
    211 #define ASN1_NULL               0x05
    212 #define ASN1_OID                0x06
    213 #define ASN1_PRINTABLE_STR      0x13
    214 #define ASN1_TELETEX_STR        0x14
    215 #define ASN1_IA5_STR            0x16
    216 #define ASN1_UTC_TIME           0x17
    217 #define ASN1_SEQUENCE           0x30
    218 #define ASN1_SET                0x31
    219 #define ASN1_IMPLICIT_TAG       0x80
    220 #define ASN1_EXPLICIT_TAG       0xa0
    221 
    222 #define SALT_SIZE               8
    223 
    224 struct _x509_ctx
    225 {
    226     char *ca_cert_dn[X509_NUM_DN_TYPES];
    227     char *cert_dn[X509_NUM_DN_TYPES];
    228 #if defined(_WIN32_WCE)
    229     long not_before;
    230     long not_after;
    231 #else
    232     time_t not_before;
    233     time_t not_after;
    234 #endif
    235     uint8_t *signature;
    236     uint16_t sig_len;
    237     uint8_t sig_type;
    238     RSA_CTX *rsa_ctx;
    239     bigint *digest;
    240     struct _x509_ctx *next;
    241 };
    242 
    243 typedef struct _x509_ctx X509_CTX;
    244 
    245 #ifdef CONFIG_SSL_CERT_VERIFICATION
    246 typedef struct
    247 {
    248     X509_CTX *cert[CONFIG_X509_MAX_CA_CERTS];
    249 } CA_CERT_CTX;
    250 #endif
    251 
    252 int asn1_get_private_key(const uint8_t *buf, int len, RSA_CTX **rsa_ctx);
    253 int asn1_next_obj(const uint8_t *buf, int *offset, int obj_type);
    254 int asn1_skip_obj(const uint8_t *buf, int *offset, int obj_type);
    255 int asn1_get_int(const uint8_t *buf, int *offset, uint8_t **object);
    256 int x509_new(const uint8_t *cert, int *len, X509_CTX **ctx);
    257 void x509_free(X509_CTX *x509_ctx);
    258 #ifdef CONFIG_SSL_CERT_VERIFICATION
    259 int x509_verify(const CA_CERT_CTX *ca_cert_ctx, const X509_CTX *cert);
    260 const uint8_t *x509_get_signature(const uint8_t *asn1_signature, int *len);
    261 #endif
    262 #ifdef CONFIG_SSL_FULL_MODE
    263 void x509_print(CA_CERT_CTX *ca_cert_ctx, const X509_CTX *cert);
    264 void x509_display_error(int error);
    265 #endif
    266 
    267 /**************************************************************************
    268  * MISC declarations
    269  **************************************************************************/
    270 
    271 extern const char * const unsupported_str;
    272 
    273 typedef void (*crypt_func)(void *, const uint8_t *, uint8_t *, int);
    274 typedef void (*hmac_func)(const uint8_t *msg, int length, const uint8_t *key,
    275         int key_len, uint8_t *digest);
    276 
    277 typedef struct
    278 {
    279     uint8_t *pre_data;	/* include the ssl record bytes */
    280     uint8_t *data;	/* the regular ssl data */
    281     int max_len;
    282     int index;
    283 } BUF_MEM;
    284 
    285 BUF_MEM buf_new(void);
    286 void buf_grow(BUF_MEM *bm, int len);
    287 void buf_free(BUF_MEM *bm);
    288 int get_file(const char *filename, uint8_t **buf);
    289 
    290 #if defined(CONFIG_SSL_FULL_MODE) || defined(WIN32) || defined(CONFIG_DEBUG)
    291 void print_blob(const char *format, const uint8_t *data, int size, ...);
    292 #else
    293     #define print_blob(...)
    294 #endif
    295 
    296 #ifdef __cplusplus
    297 }
    298 #endif
    299 
    300 #endif
    301