src/crypto/axtls/crypto.h

   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
  59 /**************************************************************************
  60  * RC4 declarations
  61  **************************************************************************/
  62
  63 typedef struct
  64 {
  65     int x, y, m[256];
  66 } RC4_CTX;
  67
  68 void RC4_setup(RC4_CTX *s, const uint8_t *key, int length);
  69 void RC4_crypt(RC4_CTX *s, const uint8_t *msg, uint8_t *data, int length);
  70
  71 /**************************************************************************
  72  * SHA1 declarations
  73  **************************************************************************/
  74
  75 #define SHA1_SIZE   20
  76
  77 /*
  78  *  This structure will hold context information for the SHA-1
  79  *  hashing operation
  80  */
  81 typedef struct
  82 {
  83     uint32_t Intermediate_Hash[SHA1_SIZE/4]; /* Message Digest  */
  84     uint32_t Length_Low;            /* Message length in bits      */
  85     uint32_t Length_High;           /* Message length in bits      */
  86     uint16_t Message_Block_Index;   /* Index into message block array   */
  87     uint8_t Message_Block[64];      /* 512-bit message blocks      */
  88 } SHA1_CTX;
  89
  90 void SHA1Init(SHA1_CTX *);
  91 void SHA1Update(SHA1_CTX *, const uint8_t * msg, int len);
  92 void SHA1Final(SHA1_CTX *, uint8_t *digest);
  93
  94 /**************************************************************************
  95  * MD5 declarations
  96  **************************************************************************/
  97
  98 /* MD5 context. */
  99
 100 #define MD5_SIZE    16
 101
 102 typedef struct
 103 {
 104   uint32_t state[4];        /* state (ABCD) */
 105   uint32_t count[2];        /* number of bits, modulo 2^64 (lsb first) */
 106   uint8_t buffer[64];       /* input buffer */
 107 } MD5_CTX;
 108
 109 void MD5Init(MD5_CTX *);
 110 void MD5Update(MD5_CTX *, const uint8_t *msg, int len);
 111 void MD5Final(MD5_CTX *, uint8_t *digest);
 112
 113 /**************************************************************************
 114  * HMAC declarations
 115  **************************************************************************/
 116 void hmac_md5(const uint8_t *msg, int length, const uint8_t *key,
 117         int key_len, uint8_t *digest);
 118 void hmac_sha1(const uint8_t *msg, int length, const uint8_t *key,
 119         int key_len, uint8_t *digest);
 120
 121 /**************************************************************************
 122  * RNG declarations
 123  **************************************************************************/
 124 void RNG_initialize(const uint8_t *seed_buf, int size);
 125 void RNG_terminate(void);
 126 void get_random(int num_rand_bytes, uint8_t *rand_data);
 127 //void get_random_NZ(int num_rand_bytes, uint8_t *rand_data);
 128
 129 #include <string.h>
 130 static inline void get_random_NZ(int num_rand_bytes, uint8_t *rand_data) {
 131         memset ( rand_data, 0x01, num_rand_bytes );
 132 }
 133
 134 /**************************************************************************
 135  * RSA declarations
 136  **************************************************************************/
 137
 138 typedef struct
 139 {
 140     bigint *m;              /* modulus */
 141     bigint *e;              /* public exponent */
 142     bigint *d;              /* private exponent */
 143 #ifdef CONFIG_BIGINT_CRT
 144     bigint *p;              /* p as in m = pq */
 145     bigint *q;              /* q as in m = pq */
 146     bigint *dP;             /* d mod (p-1) */
 147     bigint *dQ;             /* d mod (q-1) */
 148     bigint *qInv;           /* q^-1 mod p */
 149 #endif
 150     int num_octets;
 151     bigint *sig_m;         /* signature modulus */
 152     BI_CTX *bi_ctx;
 153 } RSA_CTX;
 154
 155 void RSA_priv_key_new(RSA_CTX **rsa_ctx,
 156         const uint8_t *modulus, int mod_len,
 157         const uint8_t *pub_exp, int pub_len,
 158         const uint8_t *priv_exp, int priv_len
 159 #ifdef CONFIG_BIGINT_CRT
 160       , const uint8_t *p, int p_len,
 161         const uint8_t *q, int q_len,
 162         const uint8_t *dP, int dP_len,
 163         const uint8_t *dQ, int dQ_len,
 164         const uint8_t *qInv, int qInv_len
 165 #endif
 166         );
 167 void RSA_pub_key_new(RSA_CTX **rsa_ctx,
 168         const uint8_t *modulus, int mod_len,
 169         const uint8_t *pub_exp, int pub_len);
 170 void RSA_free(RSA_CTX *ctx);
 171 int RSA_decrypt(const RSA_CTX *ctx, const uint8_t *in_data, uint8_t *out_data,
 172         int is_decryption);
 173 bigint *RSA_private(const RSA_CTX *c, bigint *bi_msg);
 174 #ifdef CONFIG_SSL_CERT_VERIFICATION
 175 bigint *RSA_raw_sign_verify(RSA_CTX *c, bigint *bi_msg);
 176 bigint *RSA_sign_verify(BI_CTX *ctx, const uint8_t *sig, int sig_len,
 177         bigint *modulus, bigint *pub_exp);
 178 bigint *RSA_public(const RSA_CTX *c, bigint *bi_msg);
 179 int RSA_encrypt(const RSA_CTX *ctx, const uint8_t *in_data, uint16_t in_len,
 180         uint8_t *out_data, int is_signing);
 181 void RSA_print(const RSA_CTX *ctx);
 182 #endif
 183
 184 /**************************************************************************
 185  * ASN1 declarations
 186  **************************************************************************/
 187 #define X509_OK                             0
 188 #define X509_NOT_OK                         -1
 189 #define X509_VFY_ERROR_NO_TRUSTED_CERT      -2
 190 #define X509_VFY_ERROR_BAD_SIGNATURE        -3
 191 #define X509_VFY_ERROR_NOT_YET_VALID        -4
 192 #define X509_VFY_ERROR_EXPIRED              -5
 193 #define X509_VFY_ERROR_SELF_SIGNED          -6
 194 #define X509_VFY_ERROR_INVALID_CHAIN        -7
 195 #define X509_VFY_ERROR_UNSUPPORTED_DIGEST   -8
 196 #define X509_INVALID_PRIV_KEY               -9
 197
 198 /*
 199  * The Distinguished Name
 200  */
 201 #define X509_NUM_DN_TYPES                   3
 202 #define X509_COMMON_NAME                    0
 203 #define X509_ORGANIZATION                   1
 204 #define X509_ORGANIZATIONAL_TYPE            2
 205
 206 #define ASN1_INTEGER            0x02
 207 #define ASN1_BIT_STRING         0x03
 208 #define ASN1_OCTET_STRING       0x04
 209 #define ASN1_NULL               0x05
 210 #define ASN1_OID                0x06
 211 #define ASN1_PRINTABLE_STR      0x13
 212 #define ASN1_TELETEX_STR        0x14
 213 #define ASN1_IA5_STR            0x16
 214 #define ASN1_UTC_TIME           0x17
 215 #define ASN1_SEQUENCE           0x30
 216 #define ASN1_SET                0x31
 217 #define ASN1_IMPLICIT_TAG       0x80
 218 #define ASN1_EXPLICIT_TAG       0xa0
 219
 220 #define SALT_SIZE               8
 221
 222 struct _x509_ctx
 223 {
 224     char *ca_cert_dn[X509_NUM_DN_TYPES];
 225     char *cert_dn[X509_NUM_DN_TYPES];
 226 #if defined(_WIN32_WCE)
 227     long not_before;
 228     long not_after;
 229 #else
 230     time_t not_before;
 231     time_t not_after;
 232 #endif
 233     uint8_t *signature;
 234     uint16_t sig_len;
 235     uint8_t sig_type;
 236     RSA_CTX *rsa_ctx;
 237     bigint *digest;
 238     struct _x509_ctx *next;
 239 };
 240
 241 typedef struct _x509_ctx X509_CTX;
 242
 243 #ifdef CONFIG_SSL_CERT_VERIFICATION
 244 typedef struct
 245 {
 246     X509_CTX *cert[CONFIG_X509_MAX_CA_CERTS];
 247 } CA_CERT_CTX;
 248 #endif
 249
 250 int asn1_get_private_key(const uint8_t *buf, int len, RSA_CTX **rsa_ctx);
 251 int asn1_next_obj(const uint8_t *buf, int *offset, int obj_type);
 252 int asn1_skip_obj(const uint8_t *buf, int *offset, int obj_type);
 253 int asn1_get_int(const uint8_t *buf, int *offset, uint8_t **object);
 254 int x509_new(const uint8_t *cert, int *len, X509_CTX **ctx);
 255 void x509_free(X509_CTX *x509_ctx);
 256 #ifdef CONFIG_SSL_CERT_VERIFICATION
 257 int x509_verify(const CA_CERT_CTX *ca_cert_ctx, const X509_CTX *cert);
 258 const uint8_t *x509_get_signature(const uint8_t *asn1_signature, int *len);
 259 #endif
 260 #ifdef CONFIG_SSL_FULL_MODE
 261 void x509_print(CA_CERT_CTX *ca_cert_ctx, const X509_CTX *cert);
 262 void x509_display_error(int error);
 263 #endif
 264
 265 /**************************************************************************
 266  * MISC declarations
 267  **************************************************************************/
 268
 269 extern const char * const unsupported_str;
 270
 271 typedef void (*crypt_func)(void *, const uint8_t *, uint8_t *, int);
 272 typedef void (*hmac_func)(const uint8_t *msg, int length, const uint8_t *key,
 273         int key_len, uint8_t *digest);
 274
 275 typedef struct
 276 {
 277     uint8_t *pre_data;  /* include the ssl record bytes */
 278     uint8_t *data;      /* the regular ssl data */
 279     int max_len;
 280     int index;
 281 } BUF_MEM;
 282
 283 BUF_MEM buf_new(void);
 284 void buf_grow(BUF_MEM *bm, int len);
 285 void buf_free(BUF_MEM *bm);
 286 int get_file(const char *filename, uint8_t **buf);
 287
 288 #if defined(CONFIG_SSL_FULL_MODE) || defined(WIN32) || defined(CONFIG_DEBUG)
 289 void print_blob(const char *format, const uint8_t *data, int size, ...);
 290 #else
 291     #define print_blob(...)
 292 #endif
 293
 294 #ifdef __cplusplus
 295 }
 296 #endif
 297
 298 #endif