← Back to branch summary

~ubuntu-branches/ubuntu/utopic/dropbear/utopic-proposed

« back to all changes in this revision

Viewing changes to libtomcrypt/src/headers/tomcrypt_pk.h

  • Committer: Bazaar Package Importer
  • Author(s): Gerrit Pape, Matt Johnston, Gerrit Pape
  • Date: 2008-03-27 20:08:06 UTC
  • mfrom: (1.4.1 upstream) (9 hardy)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20080327200806-c1hhdgt3ht2gk496
Tags: 0.51-1
[ Matt Johnston ]
* New upstream release.
  - Wait until a process exits before the server closes a connection,
    so that an exit code can be sent. This fixes problems with exit
    codes not being returned, which could cause scp to fail (closes:
    #448397, #472483).

[ Gerrit Pape ]
* debian/dropbear.postinst: don't print an error message if the
  update-service program is not installed (thx Matt).

Show diffs side-by-side

added added

removed removed

Lines of Context:
libtomcrypt/src/headers/tomcrypt_pk.h
1
1
/* ---- NUMBER THEORY ---- */
2
 
#ifdef MPI
3
 
 
4
 
#include "ltc_tommath.h"
5
 
 
6
 
/* in/out macros */
7
 
#define OUTPUT_BIGNUM(num, out, y, z)                                                             \
8
 
{                                                                                                 \
9
 
      if ((y + 4) > *outlen) { return CRYPT_BUFFER_OVERFLOW; }                                    \
10
 
      z = (unsigned long)mp_unsigned_bin_size(num);                                               \
11
 
      STORE32L(z, out+y);                                                                         \
12
 
      y += 4;                                                                                     \
13
 
      if ((y + z) > *outlen) { return CRYPT_BUFFER_OVERFLOW; }                                    \
14
 
      if ((err = mp_to_unsigned_bin(num, out+y)) != MP_OKAY) { return mpi_to_ltc_error(err); }    \
15
 
      y += z;                                                                                     \
16
 
}
17
 
 
18
 
 
19
 
#define INPUT_BIGNUM(num, in, x, y, inlen)                       \
20
 
{                                                                \
21
 
     /* load value */                                            \
22
 
     if ((y + 4) > inlen) {                                      \
23
 
        err = CRYPT_INVALID_PACKET;                              \
24
 
        goto error;                                              \
25
 
     }                                                           \
26
 
     LOAD32L(x, in+y);                                           \
27
 
     y += 4;                                                     \
28
 
                                                                 \
29
 
     /* sanity check... */                                       \
30
 
     if ((x+y) > inlen) {                                        \
31
 
        err = CRYPT_INVALID_PACKET;                              \
32
 
        goto error;                                              \
33
 
     }                                                           \
34
 
                                                                 \
35
 
     /* load it */                                               \
36
 
     if ((err = mp_read_unsigned_bin(num, (unsigned char *)in+y, (int)x)) != MP_OKAY) {\
37
 
        err = mpi_to_ltc_error(err);                             \
38
 
        goto error;                                              \
39
 
     }                                                           \
40
 
     y += x;                                                     \
41
 
     if ((err = mp_shrink(num)) != MP_OKAY) {                    \
42
 
        err = mpi_to_ltc_error(err);                             \
43
 
        goto error;                                              \
44
 
     }                                                           \
45
 
}
46
 
 
47
 
 int is_prime(mp_int *, int *);
48
 
 int rand_prime(mp_int *N, long len, prng_state *prng, int wprng);
49
 
 
50
 
#else
51
 
   #ifdef MRSA
52
 
      #error RSA requires the big int library 
53
 
   #endif
54
 
   #ifdef MECC
55
 
      #error ECC requires the big int library 
56
 
   #endif
57
 
   #ifdef MDH
58
 
      #error DH requires the big int library 
59
 
   #endif
60
 
   #ifdef MDSA
61
 
      #error DSA requires the big int library 
62
 
   #endif
63
 
#endif /* MPI */
64
 
 
65
 
 
66
 
/* ---- PUBLIC KEY CRYPTO ---- */
67
 
 
68
 
#define PK_PRIVATE            0        /* PK private keys */
69
 
#define PK_PUBLIC             1        /* PK public keys */
70
 
 
71
 
/* ---- PACKET ---- */
72
 
#ifdef PACKET
73
 
 
74
 
void packet_store_header(unsigned char *dst, int section, int subsection);
75
 
int packet_valid_header(unsigned char *src, int section, int subsection);
76
 
 
77
 
#endif
78
 
 
 
2
 
 
3
enum {
 
4
   PK_PUBLIC=0,
 
5
   PK_PRIVATE=1
 
6
};
 
7
 
 
8
int rand_prime(void *N, long len, prng_state *prng, int wprng);
79
9
 
80
10
/* ---- RSA ---- */
81
11
#ifdef MRSA
84
14
#define MIN_RSA_SIZE 1024
85
15
#define MAX_RSA_SIZE 4096
86
16
 
 
17
/** RSA PKCS style key */
87
18
typedef struct Rsa_key {
 
19
    /** Type of key, PK_PRIVATE or PK_PUBLIC */
88
20
    int type;
89
 
    mp_int e, d, N, p, q, qP, dP, dQ;
 
21
    /** The public exponent */
 
22
    void *e; 
 
23
    /** The private exponent */
 
24
    void *d; 
 
25
    /** The modulus */
 
26
    void *N; 
 
27
    /** The p factor of N */
 
28
    void *p; 
 
29
    /** The q factor of N */
 
30
    void *q; 
 
31
    /** The 1/q mod p CRT param */
 
32
    void *qP; 
 
33
    /** The d mod (p - 1) CRT param */
 
34
    void *dP; 
 
35
    /** The d mod (q - 1) CRT param */
 
36
    void *dQ;
90
37
} rsa_key;
91
38
 
92
39
int rsa_make_key(prng_state *prng, int wprng, int size, long e, rsa_key *key);
98
45
void rsa_free(rsa_key *key);
99
46
 
100
47
/* These use PKCS #1 v2.0 padding */
101
 
int rsa_encrypt_key(const unsigned char *in,     unsigned long inlen,
102
 
                          unsigned char *out,    unsigned long *outlen,
103
 
                    const unsigned char *lparam, unsigned long lparamlen,
104
 
                    prng_state *prng, int prng_idx, int hash_idx, rsa_key *key);
105
 
                                        
106
 
int rsa_decrypt_key(const unsigned char *in,       unsigned long inlen,
107
 
                          unsigned char *out,      unsigned long *outlen, 
108
 
                    const unsigned char *lparam,   unsigned long lparamlen,
109
 
                          int            hash_idx, int *stat,
110
 
                          rsa_key       *key);
111
 
 
112
 
int rsa_sign_hash(const unsigned char *in,     unsigned long  inlen, 
113
 
                        unsigned char *out,    unsigned long *outlen, 
114
 
                        prng_state    *prng,     int            prng_idx,
115
 
                        int            hash_idx, unsigned long  saltlen,
116
 
                        rsa_key *key);
117
 
 
118
 
int rsa_verify_hash(const unsigned char *sig,      unsigned long siglen,
119
 
                    const unsigned char *hash,     unsigned long hashlen,
120
 
                          int            hash_idx, unsigned long saltlen,
121
 
                          int           *stat,     rsa_key      *key);
 
48
#define rsa_encrypt_key(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _prng, _prng_idx, _hash_idx, _key) \
 
49
  rsa_encrypt_key_ex(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _prng, _prng_idx, _hash_idx, LTC_PKCS_1_OAEP, _key)
 
50
 
 
51
#define rsa_decrypt_key(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _hash_idx, _stat, _key) \
 
52
  rsa_decrypt_key_ex(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _hash_idx, LTC_PKCS_1_OAEP, _stat, _key)
 
53
 
 
54
#define rsa_sign_hash(_in, _inlen, _out, _outlen, _prng, _prng_idx, _hash_idx, _saltlen, _key) \
 
55
  rsa_sign_hash_ex(_in, _inlen, _out, _outlen, LTC_PKCS_1_PSS, _prng, _prng_idx, _hash_idx, _saltlen, _key)
 
56
 
 
57
#define rsa_verify_hash(_sig, _siglen, _hash, _hashlen, _hash_idx, _saltlen, _stat, _key) \
 
58
  rsa_verify_hash_ex(_sig, _siglen, _hash, _hashlen, LTC_PKCS_1_PSS, _hash_idx, _saltlen, _stat, _key)
 
59
 
 
60
/* These can be switched between PKCS #1 v2.x and PKCS #1 v1.5 paddings */
 
61
int rsa_encrypt_key_ex(const unsigned char *in,     unsigned long inlen,
 
62
                             unsigned char *out,    unsigned long *outlen,
 
63
                       const unsigned char *lparam, unsigned long lparamlen,
 
64
                       prng_state *prng, int prng_idx, int hash_idx, int padding, rsa_key *key);
 
65
 
 
66
int rsa_decrypt_key_ex(const unsigned char *in,       unsigned long  inlen,
 
67
                             unsigned char *out,      unsigned long *outlen,
 
68
                       const unsigned char *lparam,   unsigned long  lparamlen,
 
69
                             int            hash_idx, int            padding,
 
70
                             int           *stat,     rsa_key       *key);
 
71
 
 
72
int rsa_sign_hash_ex(const unsigned char *in,       unsigned long  inlen,
 
73
                           unsigned char *out,      unsigned long *outlen,
 
74
                           int            padding,
 
75
                           prng_state    *prng,     int            prng_idx,
 
76
                           int            hash_idx, unsigned long  saltlen,
 
77
                           rsa_key *key);
 
78
 
 
79
int rsa_verify_hash_ex(const unsigned char *sig,      unsigned long siglen,
 
80
                       const unsigned char *hash,     unsigned long hashlen,
 
81
                             int            padding,
 
82
                             int            hash_idx, unsigned long saltlen,
 
83
                             int           *stat,     rsa_key      *key);
122
84
 
123
85
/* PKCS #1 import/export */
124
86
int rsa_export(unsigned char *out, unsigned long *outlen, int type, rsa_key *key);
126
88
                        
127
89
#endif
128
90
 
129
 
/* ---- DH Routines ---- */
130
 
#ifdef MDH 
131
 
 
132
 
typedef struct Dh_key {
133
 
    int idx, type;
134
 
    mp_int x, y;
135
 
} dh_key;
136
 
 
137
 
int dh_test(void);
138
 
void dh_sizes(int *low, int *high);
139
 
int dh_get_size(dh_key *key);
140
 
 
141
 
int dh_make_key(prng_state *prng, int wprng, int keysize, dh_key *key);
142
 
void dh_free(dh_key *key);
143
 
 
144
 
int dh_export(unsigned char *out, unsigned long *outlen, int type, dh_key *key);
145
 
int dh_import(const unsigned char *in, unsigned long inlen, dh_key *key);
146
 
 
147
 
int dh_shared_secret(dh_key        *private_key, dh_key        *public_key,
148
 
                     unsigned char *out,         unsigned long *outlen);
149
 
 
150
 
int dh_encrypt_key(const unsigned char *in,    unsigned long  keylen,
151
 
                         unsigned char *out,   unsigned long *outlen, 
152
 
                         prng_state    *prng,  int wprng, int hash, 
153
 
                         dh_key        *key);
154
 
 
155
 
int dh_decrypt_key(const unsigned char *in,  unsigned long  inlen, 
156
 
                         unsigned char *out, unsigned long *outlen, 
157
 
                         dh_key *key);
158
 
 
159
 
int dh_sign_hash(const unsigned char *in,   unsigned long inlen,
160
 
                       unsigned char *out,  unsigned long *outlen,
161
 
                       prng_state    *prng, int wprng, dh_key *key);
162
 
 
163
 
int dh_verify_hash(const unsigned char *sig,  unsigned long siglen,
164
 
                   const unsigned char *hash, unsigned long hashlen, 
165
 
                   int *stat, dh_key *key);
166
 
 
167
 
 
 
91
/* ---- Katja ---- */
 
92
#ifdef MKAT
 
93
 
 
94
/* Min and Max KAT key sizes (in bits) */
 
95
#define MIN_KAT_SIZE 1024
 
96
#define MAX_KAT_SIZE 4096
 
97
 
 
98
/** Katja PKCS style key */
 
99
typedef struct KAT_key {
 
100
    /** Type of key, PK_PRIVATE or PK_PUBLIC */
 
101
    int type;
 
102
    /** The private exponent */
 
103
    void *d; 
 
104
    /** The modulus */
 
105
    void *N; 
 
106
    /** The p factor of N */
 
107
    void *p; 
 
108
    /** The q factor of N */
 
109
    void *q; 
 
110
    /** The 1/q mod p CRT param */
 
111
    void *qP; 
 
112
    /** The d mod (p - 1) CRT param */
 
113
    void *dP; 
 
114
    /** The d mod (q - 1) CRT param */
 
115
    void *dQ;
 
116
    /** The pq param */
 
117
    void *pq;
 
118
} katja_key;
 
119
 
 
120
int katja_make_key(prng_state *prng, int wprng, int size, katja_key *key);
 
121
 
 
122
int katja_exptmod(const unsigned char *in,   unsigned long inlen,
 
123
                        unsigned char *out,  unsigned long *outlen, int which,
 
124
                        katja_key *key);
 
125
 
 
126
void katja_free(katja_key *key);
 
127
 
 
128
/* These use PKCS #1 v2.0 padding */
 
129
int katja_encrypt_key(const unsigned char *in,     unsigned long inlen,
 
130
                            unsigned char *out,    unsigned long *outlen,
 
131
                      const unsigned char *lparam, unsigned long lparamlen,
 
132
                      prng_state *prng, int prng_idx, int hash_idx, katja_key *key);
 
133
                                        
 
134
int katja_decrypt_key(const unsigned char *in,       unsigned long inlen,
 
135
                            unsigned char *out,      unsigned long *outlen, 
 
136
                      const unsigned char *lparam,   unsigned long lparamlen,
 
137
                            int            hash_idx, int *stat,
 
138
                            katja_key       *key);
 
139
 
 
140
/* PKCS #1 import/export */
 
141
int katja_export(unsigned char *out, unsigned long *outlen, int type, katja_key *key);
 
142
int katja_import(const unsigned char *in, unsigned long inlen, katja_key *key);
 
143
                        
168
144
#endif
169
145
 
170
146
/* ---- ECC Routines ---- */
171
147
#ifdef MECC
172
 
typedef struct {
173
 
    mp_int x, y, z;
 
148
 
 
149
/* size of our temp buffers for exported keys */
 
150
#define ECC_BUF_SIZE 256
 
151
 
 
152
/* max private key size */
 
153
#define ECC_MAXSIZE  66
 
154
 
 
155
/** Structure defines a NIST GF(p) curve */
 
156
typedef struct {
 
157
   /** The size of the curve in octets */
 
158
   int size;
 
159
 
 
160
   /** name of curve */
 
161
   char *name; 
 
162
 
 
163
   /** The prime that defines the field the curve is in (encoded in hex) */
 
164
   char *prime;
 
165
 
 
166
   /** The fields B param (hex) */
 
167
   char *B;
 
168
 
 
169
   /** The order of the curve (hex) */
 
170
   char *order;
 
171
  
 
172
   /** The x co-ordinate of the base point on the curve (hex) */
 
173
   char *Gx;
 
174
 
 
175
   /** The y co-ordinate of the base point on the curve (hex) */
 
176
   char *Gy;
 
177
} ltc_ecc_set_type;
 
178
 
 
179
/** A point on a ECC curve, stored in Jacbobian format such that (x,y,z) => (x/z^2, y/z^3, 1) when interpretted as affine */
 
180
typedef struct {
 
181
    /** The x co-ordinate */
 
182
    void *x;
 
183
 
 
184
    /** The y co-ordinate */
 
185
    void *y;
 
186
 
 
187
    /** The z co-ordinate */
 
188
    void *z;
174
189
} ecc_point;
175
190
 
 
191
/** An ECC key */
176
192
typedef struct {
177
 
    int type, idx;
 
193
    /** Type of key, PK_PRIVATE or PK_PUBLIC */
 
194
    int type;
 
195
 
 
196
    /** Index into the ltc_ecc_sets[] for the parameters of this curve; if -1, then this key is using user supplied curve in dp */
 
197
    int idx;
 
198
 
 
199
        /** pointer to domain parameters; either points to NIST curves (identified by idx >= 0) or user supplied curve */
 
200
        const ltc_ecc_set_type *dp;
 
201
 
 
202
    /** The public key */
178
203
    ecc_point pubkey;
179
 
    mp_int k;
 
204
 
 
205
    /** The private key */
 
206
    void *k;
180
207
} ecc_key;
181
208
 
182
 
int ecc_test(void);
 
209
/** the ECC params provided */
 
210
extern const ltc_ecc_set_type ltc_ecc_sets[];
 
211
 
 
212
int  ecc_test(void);
183
213
void ecc_sizes(int *low, int *high);
184
 
int ecc_get_size(ecc_key *key);
 
214
int  ecc_get_size(ecc_key *key);
185
215
 
186
 
int ecc_make_key(prng_state *prng, int wprng, int keysize, ecc_key *key);
 
216
int  ecc_make_key(prng_state *prng, int wprng, int keysize, ecc_key *key);
 
217
int  ecc_make_key_ex(prng_state *prng, int wprng, ecc_key *key, const ltc_ecc_set_type *dp);
187
218
void ecc_free(ecc_key *key);
188
219
 
189
 
int ecc_export(unsigned char *out, unsigned long *outlen, int type, ecc_key *key);
190
 
int ecc_import(const unsigned char *in, unsigned long inlen, ecc_key *key);
191
 
 
192
 
int ecc_shared_secret(ecc_key *private_key, ecc_key *public_key, 
193
 
                      unsigned char *out, unsigned long *outlen);
194
 
 
195
 
int ecc_encrypt_key(const unsigned char *in,   unsigned long inlen,
196
 
                          unsigned char *out,  unsigned long *outlen, 
197
 
                          prng_state *prng, int wprng, int hash, 
198
 
                          ecc_key *key);
199
 
 
200
 
int ecc_decrypt_key(const unsigned char *in,  unsigned long  inlen,
201
 
                          unsigned char *out, unsigned long *outlen, 
202
 
                          ecc_key *key);
203
 
 
204
 
int ecc_sign_hash(const unsigned char *in,  unsigned long inlen, 
205
 
                        unsigned char *out, unsigned long *outlen, 
206
 
                        prng_state *prng, int wprng, ecc_key *key);
207
 
 
208
 
int ecc_verify_hash(const unsigned char *sig,  unsigned long siglen,
209
 
                    const unsigned char *hash, unsigned long hashlen, 
210
 
                    int *stat, ecc_key *key);
 
220
int  ecc_export(unsigned char *out, unsigned long *outlen, int type, ecc_key *key);
 
221
int  ecc_import(const unsigned char *in, unsigned long inlen, ecc_key *key);
 
222
int  ecc_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, const ltc_ecc_set_type *dp);
 
223
 
 
224
int ecc_ansi_x963_export(ecc_key *key, unsigned char *out, unsigned long *outlen);
 
225
int ecc_ansi_x963_import(const unsigned char *in, unsigned long inlen, ecc_key *key);
 
226
int ecc_ansi_x963_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, ltc_ecc_set_type *dp);
 
227
 
 
228
int  ecc_shared_secret(ecc_key *private_key, ecc_key *public_key, 
 
229
                       unsigned char *out, unsigned long *outlen);
 
230
 
 
231
int  ecc_encrypt_key(const unsigned char *in,   unsigned long inlen,
 
232
                           unsigned char *out,  unsigned long *outlen, 
 
233
                           prng_state *prng, int wprng, int hash, 
 
234
                           ecc_key *key);
 
235
 
 
236
int  ecc_decrypt_key(const unsigned char *in,  unsigned long  inlen,
 
237
                           unsigned char *out, unsigned long *outlen, 
 
238
                           ecc_key *key);
 
239
 
 
240
int  ecc_sign_hash(const unsigned char *in,  unsigned long inlen, 
 
241
                         unsigned char *out, unsigned long *outlen, 
 
242
                         prng_state *prng, int wprng, ecc_key *key);
 
243
 
 
244
int  ecc_verify_hash(const unsigned char *sig,  unsigned long siglen,
 
245
                     const unsigned char *hash, unsigned long hashlen, 
 
246
                     int *stat, ecc_key *key);
 
247
 
 
248
/* low level functions */
 
249
ecc_point *ltc_ecc_new_point(void);
 
250
void       ltc_ecc_del_point(ecc_point *p);
 
251
int        ltc_ecc_is_valid_idx(int n);
 
252
 
 
253
/* point ops (mp == montgomery digit) */
 
254
#if !defined(MECC_ACCEL) || defined(LTM_DESC) || defined(GMP_DESC)
 
255
/* R = 2P */
 
256
int ltc_ecc_projective_dbl_point(ecc_point *P, ecc_point *R, void *modulus, void *mp);
 
257
 
 
258
/* R = P + Q */
 
259
int ltc_ecc_projective_add_point(ecc_point *P, ecc_point *Q, ecc_point *R, void *modulus, void *mp);
 
260
#endif
 
261
 
 
262
#if defined(MECC_FP)
 
263
int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *modulus, int map);
 
264
int ltc_ecc_fp_save_state(unsigned char **out, unsigned long *outlen);
 
265
int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen);
 
266
void ltc_ecc_fp_free(void);
 
267
#endif
 
268
 
 
269
/* R = kG */
 
270
int ltc_ecc_mulmod(void *k, ecc_point *G, ecc_point *R, void *modulus, int map);
 
271
 
 
272
#ifdef LTC_ECC_SHAMIR
 
273
/* kA*A + kB*B = C */
 
274
int ltc_ecc_mul2add(ecc_point *A, void *kA,
 
275
                    ecc_point *B, void *kB,
 
276
                    ecc_point *C,
 
277
                         void *modulus);
 
278
 
 
279
#ifdef MECC_FP
 
280
int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
 
281
                       ecc_point *B, void *kB,
 
282
                       ecc_point *C, void *modulus);
 
283
#endif
 
284
 
 
285
#endif
 
286
 
 
287
 
 
288
/* map P to affine from projective */
 
289
int ltc_ecc_map(ecc_point *P, void *modulus, void *mp);
211
290
 
212
291
#endif
213
292
 
214
293
#ifdef MDSA
215
294
 
 
295
/* Max diff between group and modulus size in bytes */
 
296
#define MDSA_DELTA     512
 
297
 
 
298
/* Max DSA group size in bytes (default allows 4k-bit groups) */
 
299
#define MDSA_MAX_GROUP 512
 
300
 
 
301
/** DSA key structure */
216
302
typedef struct {
217
 
   int type, qord;
218
 
   mp_int g, q, p, x, y;
 
303
   /** The key type, PK_PRIVATE or PK_PUBLIC */
 
304
   int type; 
 
305
 
 
306
   /** The order of the sub-group used in octets */
 
307
   int qord;
 
308
 
 
309
   /** The generator  */
 
310
   void *g;
 
311
 
 
312
   /** The prime used to generate the sub-group */
 
313
   void *q;
 
314
 
 
315
   /** The large prime that generats the field the contains the sub-group */
 
316
   void *p;
 
317
 
 
318
   /** The private key */
 
319
   void *x;
 
320
 
 
321
   /** The public key */
 
322
   void *y;
219
323
} dsa_key;
220
324
 
221
325
int dsa_make_key(prng_state *prng, int wprng, int group_size, int modulus_size, dsa_key *key);
222
326
void dsa_free(dsa_key *key);
223
327
 
224
 
 
225
328
int dsa_sign_hash_raw(const unsigned char *in,  unsigned long inlen,
226
 
                                   mp_int *r,   mp_int *s,
 
329
                                   void *r,   void *s,
227
330
                               prng_state *prng, int wprng, dsa_key *key);
228
331
 
229
332
int dsa_sign_hash(const unsigned char *in,  unsigned long inlen,
230
333
                        unsigned char *out, unsigned long *outlen,
231
334
                        prng_state *prng, int wprng, dsa_key *key);
232
335
 
233
 
int dsa_verify_hash_raw(         mp_int *r,          mp_int *s,
 
336
int dsa_verify_hash_raw(         void *r,          void *s,
234
337
                    const unsigned char *hash, unsigned long hashlen, 
235
338
                                    int *stat,      dsa_key *key);
236
339
 
238
341
                    const unsigned char *hash, unsigned long hashlen, 
239
342
                          int           *stat, dsa_key       *key);
240
343
 
 
344
int dsa_encrypt_key(const unsigned char *in,   unsigned long inlen,
 
345
                          unsigned char *out,  unsigned long *outlen, 
 
346
                          prng_state *prng, int wprng, int hash, 
 
347
                          dsa_key *key);
 
348
                      
 
349
int dsa_decrypt_key(const unsigned char *in,  unsigned long  inlen,
 
350
                          unsigned char *out, unsigned long *outlen, 
 
351
                          dsa_key *key);
 
352
                          
241
353
int dsa_import(const unsigned char *in, unsigned long inlen, dsa_key *key);
242
 
 
243
354
int dsa_export(unsigned char *out, unsigned long *outlen, int type, dsa_key *key);
244
 
 
245
355
int dsa_verify_key(dsa_key *key, int *stat);
246
356
 
 
357
int dsa_shared_secret(void          *private_key, void *base,
 
358
                      dsa_key       *public_key,
 
359
                      unsigned char *out,         unsigned long *outlen);
247
360
#endif
248
361
 
249
362
#ifdef LTC_DER
251
364
 
252
365
enum {
253
366
 LTC_ASN1_EOL,
 
367
 LTC_ASN1_BOOLEAN,
254
368
 LTC_ASN1_INTEGER,
255
369
 LTC_ASN1_SHORT_INTEGER,
256
370
 LTC_ASN1_BIT_STRING,
259
373
 LTC_ASN1_OBJECT_IDENTIFIER,
260
374
 LTC_ASN1_IA5_STRING,
261
375
 LTC_ASN1_PRINTABLE_STRING,
 
376
 LTC_ASN1_UTF8_STRING,
262
377
 LTC_ASN1_UTCTIME,
263
 
 
264
378
 LTC_ASN1_CHOICE,
265
 
 LTC_ASN1_SEQUENCE
 
379
 LTC_ASN1_SEQUENCE,
 
380
 LTC_ASN1_SET,
 
381
 LTC_ASN1_SETOF
266
382
};
267
383
 
268
 
typedef struct {
 
384
/** A LTC ASN.1 list type */
 
385
typedef struct ltc_asn1_list_ {
 
386
   /** The LTC ASN.1 enumerated type identifier */
269
387
   int           type;
 
388
   /** The data to encode or place for decoding */
270
389
   void         *data;
 
390
   /** The size of the input or resulting output */
271
391
   unsigned long size;
 
392
   /** The used flag, this is used by the CHOICE ASN.1 type to indicate which choice was made */
272
393
   int           used;
 
394
   /** prev/next entry in the list */
 
395
   struct ltc_asn1_list_ *prev, *next, *child, *parent;
273
396
} ltc_asn1_list;
274
397
 
275
398
#define LTC_SET_ASN1(list, index, Type, Data, Size)  \
277
400
      int LTC_MACRO_temp            = (index);       \
278
401
      ltc_asn1_list *LTC_MACRO_list = (list);        \
279
402
      LTC_MACRO_list[LTC_MACRO_temp].type = (Type);  \
280
 
      LTC_MACRO_list[LTC_MACRO_temp].data = (Data);  \
 
403
      LTC_MACRO_list[LTC_MACRO_temp].data = (void*)(Data);  \
281
404
      LTC_MACRO_list[LTC_MACRO_temp].size = (Size);  \
282
405
      LTC_MACRO_list[LTC_MACRO_temp].used = 0;       \
283
406
   } while (0);
284
407
 
285
408
/* SEQUENCE */
286
 
int der_encode_sequence(ltc_asn1_list *list, unsigned long inlen,
287
 
                        unsigned char *out,  unsigned long *outlen);
 
409
int der_encode_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
 
410
                           unsigned char *out,  unsigned long *outlen, int type_of);
 
411
                          
 
412
#define der_encode_sequence(list, inlen, out, outlen) der_encode_sequence_ex(list, inlen, out, outlen, LTC_ASN1_SEQUENCE)                        
288
413
 
289
 
int der_decode_sequence(const unsigned char *in,   unsigned long  inlen,
290
 
                              ltc_asn1_list *list, unsigned long  outlen);
 
414
int der_decode_sequence_ex(const unsigned char *in, unsigned long  inlen,
 
415
                           ltc_asn1_list *list,     unsigned long  outlen, int ordered);
 
416
                              
 
417
#define der_decode_sequence(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, 1)
291
418
 
292
419
int der_length_sequence(ltc_asn1_list *list, unsigned long inlen,
293
420
                        unsigned long *outlen);
294
421
 
295
 
/* VA list handy helpers */
 
422
/* SET */
 
423
#define der_decode_set(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, 0)
 
424
#define der_length_set der_length_sequence
 
425
int der_encode_set(ltc_asn1_list *list, unsigned long inlen,
 
426
                   unsigned char *out,  unsigned long *outlen);
 
427
 
 
428
int der_encode_setof(ltc_asn1_list *list, unsigned long inlen,
 
429
                     unsigned char *out,  unsigned long *outlen);
 
430
                        
 
431
/* VA list handy helpers with triplets of <type, size, data> */
296
432
int der_encode_sequence_multi(unsigned char *out, unsigned long *outlen, ...);
297
433
int der_decode_sequence_multi(const unsigned char *in, unsigned long inlen, ...);
298
434
 
 
435
/* FLEXI DECODER handle unknown list decoder */
 
436
int  der_decode_sequence_flexi(const unsigned char *in, unsigned long *inlen, ltc_asn1_list **out);
 
437
void der_free_sequence_flexi(ltc_asn1_list *list);
 
438
void der_sequence_free(ltc_asn1_list *in);
 
439
 
 
440
/* BOOLEAN */
 
441
int der_length_boolean(unsigned long *outlen);
 
442
int der_encode_boolean(int in, 
 
443
                       unsigned char *out, unsigned long *outlen);
 
444
int der_decode_boolean(const unsigned char *in, unsigned long inlen,
 
445
                                       int *out);                      
299
446
/* INTEGER */
300
 
int der_encode_integer(mp_int *num, unsigned char *out, unsigned long *outlen);
301
 
int der_decode_integer(const unsigned char *in, unsigned long inlen, mp_int *num);
302
 
int der_length_integer(mp_int *num, unsigned long *len);
 
447
int der_encode_integer(void *num, unsigned char *out, unsigned long *outlen);
 
448
int der_decode_integer(const unsigned char *in, unsigned long inlen, void *num);
 
449
int der_length_integer(void *num, unsigned long *len);
303
450
 
304
451
/* INTEGER -- handy for 0..2^32-1 values */
305
452
int der_decode_short_integer(const unsigned char *in, unsigned long inlen, unsigned long *num);
348
495
int der_printable_char_encode(int c);
349
496
int der_printable_value_decode(int v);
350
497
 
 
498
/* UTF-8 */
 
499
#if (defined(SIZE_MAX) || __STDC_VERSION__ >= 199901L || defined(WCHAR_MAX) || defined(_WCHAR_T) || defined(_WCHAR_T_DEFINED)) && !defined(LTC_NO_WCHAR)
 
500
#include <wchar.h>
 
501
#else
 
502
typedef ulong32 wchar_t;
 
503
#endif
 
504
 
 
505
int der_encode_utf8_string(const wchar_t *in,  unsigned long inlen,
 
506
                           unsigned char *out, unsigned long *outlen);
 
507
 
 
508
int der_decode_utf8_string(const unsigned char *in,  unsigned long inlen,
 
509
                                       wchar_t *out, unsigned long *outlen);
 
510
unsigned long der_utf8_charsize(const wchar_t c);
 
511
int der_length_utf8_string(const wchar_t *in, unsigned long noctets, unsigned long *outlen);
 
512
 
 
513
 
351
514
/* CHOICE */
352
515
int der_decode_choice(const unsigned char *in,   unsigned long *inlen,
353
516
                            ltc_asn1_list *list, unsigned long  outlen);
377
540
#endif
378
541
 
379
542
/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_pk.h,v $ */
380
 
/* $Revision: 1.30 $ */
381
 
/* $Date: 2005/06/19 11:23:03 $ */
 
543
/* $Revision: 1.77 $ */
 
544
/* $Date: 2006/12/03 00:39:56 $ */