de1dbeb478b4c9c99abc491e5518daf1ac87346f
[people/asdlkf/gpxe.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 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