]> pd.if.org Git - zpackage/blob - libtomcrypt/src/pk/asn1/der/sequence/der_encode_sequence_ex.c
fix compile process for elf programs
[zpackage] / libtomcrypt / src / pk / asn1 / der / sequence / der_encode_sequence_ex.c
1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis
2  *
3  * LibTomCrypt is a library that provides various cryptographic
4  * algorithms in a highly modular and flexible manner.
5  *
6  * The library is free for all purposes without any express
7  * guarantee it works.
8  */
9 #include "tomcrypt.h"
10
11
12 /**
13   @file der_encode_sequence_ex.c
14   ASN.1 DER, encode a SEQUENCE, Tom St Denis
15 */
16
17 #ifdef LTC_DER
18
19 /**
20    Encode a SEQUENCE
21    @param list      The list of items to encode
22    @param inlen     The number of items in the list
23    @param out       [out] The destination
24    @param outlen    [in/out] The size of the output
25    @param type_of   LTC_ASN1_SEQUENCE or LTC_ASN1_SET/LTC_ASN1_SETOF
26    @return CRYPT_OK on success
27 */
28 int der_encode_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
29                            unsigned char *out,  unsigned long *outlen, int type_of)
30 {
31    int           err;
32    ltc_asn1_type type;
33    unsigned long size, x, y, z, i;
34    void          *data;
35
36    LTC_ARGCHK(list    != NULL);
37    LTC_ARGCHK(out     != NULL);
38    LTC_ARGCHK(outlen  != NULL);
39
40    /* get size of output that will be required */
41    y = 0; z = 0;
42    if ((err = der_length_sequence_ex(list, inlen, &y, &z)) != CRYPT_OK) return CRYPT_INVALID_ARG;
43
44    /* too big ? */
45    if (*outlen < y) {
46       *outlen = y;
47       err = CRYPT_BUFFER_OVERFLOW;
48       goto LBL_ERR;
49    }
50
51    /* store header */
52    x = 0;
53    out[x++] = (type_of == LTC_ASN1_SEQUENCE) ? 0x30 : 0x31;
54
55    if (z < 128) {
56       out[x++] = (unsigned char)z;
57    } else if (z < 256) {
58       out[x++] = 0x81;
59       out[x++] = (unsigned char)z;
60    } else if (z < 65536UL) {
61       out[x++] = 0x82;
62       out[x++] = (unsigned char)((z>>8UL)&255);
63       out[x++] = (unsigned char)(z&255);
64    } else if (z < 16777216UL) {
65       out[x++] = 0x83;
66       out[x++] = (unsigned char)((z>>16UL)&255);
67       out[x++] = (unsigned char)((z>>8UL)&255);
68       out[x++] = (unsigned char)(z&255);
69    }
70
71    /* store data */
72    *outlen -= x;
73    for (i = 0; i < inlen; i++) {
74        type = list[i].type;
75        size = list[i].size;
76        data = list[i].data;
77
78        if (type == LTC_ASN1_EOL) {
79           break;
80        }
81
82        switch (type) {
83             case LTC_ASN1_BOOLEAN:
84                z = *outlen;
85                if ((err = der_encode_boolean(*((int *)data), out + x, &z)) != CRYPT_OK) {
86                   goto LBL_ERR;
87                }
88                break;
89
90            case LTC_ASN1_INTEGER:
91                z = *outlen;
92                if ((err = der_encode_integer(data, out + x, &z)) != CRYPT_OK) {
93                   goto LBL_ERR;
94                }
95                break;
96
97            case LTC_ASN1_SHORT_INTEGER:
98                z = *outlen;
99                if ((err = der_encode_short_integer(*((unsigned long*)data), out + x, &z)) != CRYPT_OK) {
100                   goto LBL_ERR;
101                }
102                break;
103
104            case LTC_ASN1_BIT_STRING:
105                z = *outlen;
106                if ((err = der_encode_bit_string(data, size, out + x, &z)) != CRYPT_OK) {
107                   goto LBL_ERR;
108                }
109                break;
110
111            case LTC_ASN1_RAW_BIT_STRING:
112                z = *outlen;
113                if ((err = der_encode_raw_bit_string(data, size, out + x, &z)) != CRYPT_OK) {
114                   goto LBL_ERR;
115                }
116                break;
117
118            case LTC_ASN1_OCTET_STRING:
119                z = *outlen;
120                if ((err = der_encode_octet_string(data, size, out + x, &z)) != CRYPT_OK) {
121                   goto LBL_ERR;
122                }
123                break;
124
125            case LTC_ASN1_NULL:
126                out[x] = 0x05;
127                out[x+1] = 0x00;
128                z = 2;
129                break;
130
131            case LTC_ASN1_OBJECT_IDENTIFIER:
132                z = *outlen;
133                if ((err = der_encode_object_identifier(data, size, out + x, &z)) != CRYPT_OK) {
134                   goto LBL_ERR;
135                }
136                break;
137
138            case LTC_ASN1_IA5_STRING:
139                z = *outlen;
140                if ((err = der_encode_ia5_string(data, size, out + x, &z)) != CRYPT_OK) {
141                   goto LBL_ERR;
142                }
143                break;
144
145            case LTC_ASN1_PRINTABLE_STRING:
146                z = *outlen;
147                if ((err = der_encode_printable_string(data, size, out + x, &z)) != CRYPT_OK) {
148                   goto LBL_ERR;
149                }
150                break;
151
152            case LTC_ASN1_UTF8_STRING:
153                z = *outlen;
154                if ((err = der_encode_utf8_string(data, size, out + x, &z)) != CRYPT_OK) {
155                   goto LBL_ERR;
156                }
157                break;
158
159            case LTC_ASN1_UTCTIME:
160                z = *outlen;
161                if ((err = der_encode_utctime(data, out + x, &z)) != CRYPT_OK) {
162                   goto LBL_ERR;
163                }
164                break;
165
166            case LTC_ASN1_GENERALIZEDTIME:
167                z = *outlen;
168                if ((err = der_encode_generalizedtime(data, out + x, &z)) != CRYPT_OK) {
169                   goto LBL_ERR;
170                }
171                break;
172
173            case LTC_ASN1_SET:
174                z = *outlen;
175                if ((err = der_encode_set(data, size, out + x, &z)) != CRYPT_OK) {
176                   goto LBL_ERR;
177                }
178                break;
179
180            case LTC_ASN1_SETOF:
181                z = *outlen;
182                if ((err = der_encode_setof(data, size, out + x, &z)) != CRYPT_OK) {
183                   goto LBL_ERR;
184                }
185                break;
186
187            case LTC_ASN1_SEQUENCE:
188                z = *outlen;
189                if ((err = der_encode_sequence_ex(data, size, out + x, &z, type)) != CRYPT_OK) {
190                   goto LBL_ERR;
191                }
192                break;
193
194            case LTC_ASN1_CHOICE:
195            case LTC_ASN1_CONSTRUCTED:
196            case LTC_ASN1_CONTEXT_SPECIFIC:
197            case LTC_ASN1_EOL:
198            case LTC_ASN1_TELETEX_STRING:
199                err = CRYPT_INVALID_ARG;
200                goto LBL_ERR;
201        }
202
203        x       += z;
204        *outlen -= z;
205    }
206    *outlen = x;
207    err = CRYPT_OK;
208
209 LBL_ERR:
210    return err;
211 }
212
213 #endif
214
215 /* ref:         $Format:%D$ */
216 /* git commit:  $Format:%H$ */
217 /* commit time: $Format:%ai$ */