disable AES_convert_key by #if 0'ing it out (suggested by mcb30)
[people/indolent/gpxe.git/.git] / 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 #if 0 /** currently unused function **/
58 void AES_convert_key(AES_CTX *ctx);
59 #endif
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 /**************************************************************************
132  * RSA declarations 
133  **************************************************************************/
134
135 typedef struct 
136 {
137     bigint *m;              /* modulus */
138     bigint *e;              /* public exponent */
139     bigint *d;              /* private exponent */
140 #ifdef CONFIG_BIGINT_CRT
141     bigint *p;              /* p as in m = pq */
142     bigint *q;              /* q as in m = pq */
143     bigint *dP;             /* d mod (p-1) */
144     bigint *dQ;             /* d mod (q-1) */
145     bigint *qInv;           /* q^-1 mod p */
146 #endif
147     int num_octets;
148     bigint *sig_m;         /* signature modulus */
149     BI_CTX *bi_ctx;
150 } RSA_CTX;
151
152 void RSA_priv_key_new(RSA_CTX **rsa_ctx, 
153         const uint8_t *modulus, int mod_len,
154         const uint8_t *pub_exp, int pub_len,
155         const uint8_t *priv_exp, int priv_len
156 #ifdef CONFIG_BIGINT_CRT
157       , const uint8_t *p, int p_len,
158         const uint8_t *q, int q_len,
159         const uint8_t *dP, int dP_len,
160         const uint8_t *dQ, int dQ_len,
161         const uint8_t *qInv, int qInv_len
162 #endif
163         );
164 void RSA_pub_key_new(RSA_CTX **rsa_ctx, 
165         const uint8_t *modulus, int mod_len,
166         const uint8_t *pub_exp, int pub_len);
167 void RSA_free(RSA_CTX *ctx);
168 int RSA_decrypt(RSA_CTX *ctx, const uint8_t *in_data, uint8_t *out_data,
169         int is_decryption);
170 bigint *RSA_private(RSA_CTX *c, bigint *bi_msg);
171 #ifdef CONFIG_SSL_CERT_VERIFICATION
172 bigint *RSA_raw_sign_verify(RSA_CTX *c, bigint *bi_msg);
173 bigint *RSA_sign_verify(BI_CTX *ctx, const uint8_t *sig, int sig_len,
174         bigint *modulus, bigint *pub_exp);
175 bigint *RSA_public(RSA_CTX *c, bigint *bi_msg);
176 int RSA_encrypt(RSA_CTX *ctx, const uint8_t *in_data, uint16_t in_len, 
177         uint8_t *out_data, int is_signing);
178 void RSA_print(const RSA_CTX *ctx);
179 #endif
180
181 /**************************************************************************
182  * ASN1 declarations 
183  **************************************************************************/
184 #define X509_OK                             0
185 #define X509_NOT_OK                         -1
186 #define X509_VFY_ERROR_NO_TRUSTED_CERT      -2
187 #define X509_VFY_ERROR_BAD_SIGNATURE        -3      
188 #define X509_VFY_ERROR_NOT_YET_VALID        -4
189 #define X509_VFY_ERROR_EXPIRED              -5
190 #define X509_VFY_ERROR_SELF_SIGNED          -6
191 #define X509_VFY_ERROR_INVALID_CHAIN        -7
192 #define X509_VFY_ERROR_UNSUPPORTED_DIGEST   -8
193 #define X509_INVALID_PRIV_KEY               -9
194
195 /*
196  * The Distinguished Name
197  */
198 #define X509_NUM_DN_TYPES                   3
199 #define X509_COMMON_NAME                    0
200 #define X509_ORGANIZATION                   1
201 #define X509_ORGANIZATIONAL_TYPE            2
202
203 #define ASN1_INTEGER            0x02
204 #define ASN1_BIT_STRING         0x03
205 #define ASN1_OCTET_STRING       0x04
206 #define ASN1_NULL               0x05
207 #define ASN1_OID                0x06
208 #define ASN1_PRINTABLE_STR      0x13
209 #define ASN1_TELETEX_STR        0x14
210 #define ASN1_IA5_STR            0x16
211 #define ASN1_UTC_TIME           0x17
212 #define ASN1_SEQUENCE           0x30
213 #define ASN1_SET                0x31
214 #define ASN1_IMPLICIT_TAG       0x80
215 #define ASN1_EXPLICIT_TAG       0xa0
216
217 #define SALT_SIZE               8
218
219 struct _x509_ctx
220 {
221     char *ca_cert_dn[X509_NUM_DN_TYPES];
222     char *cert_dn[X509_NUM_DN_TYPES];
223 #if defined(_WIN32_WCE)
224     long not_before;
225     long not_after;
226 #else
227     time_t not_before;
228     time_t not_after;
229 #endif
230     uint8_t *signature;
231     uint16_t sig_len;
232     uint8_t sig_type;
233     RSA_CTX *rsa_ctx;
234     bigint *digest;
235     struct _x509_ctx *next;
236 };
237
238 typedef struct _x509_ctx X509_CTX;
239
240 #ifdef CONFIG_SSL_CERT_VERIFICATION
241 typedef struct 
242 {
243     X509_CTX *cert[CONFIG_X509_MAX_CA_CERTS];
244 } CA_CERT_CTX;
245 #endif
246
247 int asn1_get_private_key(const uint8_t *buf, int len, RSA_CTX **rsa_ctx);
248 int asn1_next_obj(const uint8_t *buf, int *offset, int obj_type);
249 int asn1_skip_obj(const uint8_t *buf, int *offset, int obj_type);
250 int asn1_get_int(const uint8_t *buf, int *offset, uint8_t **object);
251 int x509_new(const uint8_t *cert, int *len, X509_CTX **ctx);
252 void x509_free(X509_CTX *x509_ctx);
253 #ifdef CONFIG_SSL_CERT_VERIFICATION
254 int x509_verify(const CA_CERT_CTX *ca_cert_ctx, const X509_CTX *cert);
255 const uint8_t *x509_get_signature(const uint8_t *asn1_signature, int *len);
256 #endif
257 #ifdef CONFIG_SSL_FULL_MODE
258 void x509_print(CA_CERT_CTX *ca_cert_ctx, const X509_CTX *cert);
259 void x509_display_error(int error);
260 #endif
261
262 /**************************************************************************
263  * MISC declarations 
264  **************************************************************************/
265
266 extern const char * const unsupported_str;
267
268 typedef void (*crypt_func)(void *, const uint8_t *, uint8_t *, int);
269 typedef void (*hmac_func)(const uint8_t *msg, int length, const uint8_t *key, 
270         int key_len, uint8_t *digest);
271
272 typedef struct
273 {
274     uint8_t *pre_data;  /* include the ssl record bytes */
275     uint8_t *data;      /* the regular ssl data */
276     int max_len;
277     int index;
278 } BUF_MEM;
279
280 BUF_MEM buf_new(void);
281 void buf_grow(BUF_MEM *bm, int len);
282 void buf_free(BUF_MEM *bm);
283 int get_file(const char *filename, uint8_t **buf);
284
285 #if defined(CONFIG_SSL_FULL_MODE) || defined(WIN32) || defined(CONFIG_DEBUG)
286 void print_blob(const char *format, const uint8_t *data, int size, ...);
287 #else
288     #define print_blob(...)
289 #endif
290
291 #ifdef __cplusplus
292 }
293 #endif
294
295 #endif