Annotation of embedaddon/strongswan/src/libstrongswan/asn1/asn1.h, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2011-2017 Tobias Brunner
3: * Copyright (C) 2006 Martin Will
4: * Copyright (C) 2000-2008 Andreas Steffen
5: * HSR Hochschule fuer Technik Rapperswil
6: *
7: * This program is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2 of the License, or (at your
10: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
11: *
12: * This program is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15: * for more details.
16: */
17:
18: /**
19: * @defgroup asn1i asn1
20: * @{ @ingroup asn1
21: */
22:
23: #ifndef ASN1_H_
24: #define ASN1_H_
25:
26: #include <stdarg.h>
27:
28: #include <library.h>
29: #include <asn1/asn1.h>
30:
31: /**
32: * Definition of some primitive ASN1 types
33: */
34: typedef enum {
35: ASN1_EOC = 0x00,
36: ASN1_BOOLEAN = 0x01,
37: ASN1_INTEGER = 0x02,
38: ASN1_BIT_STRING = 0x03,
39: ASN1_OCTET_STRING = 0x04,
40: ASN1_NULL = 0x05,
41: ASN1_OID = 0x06,
42: ASN1_ENUMERATED = 0x0A,
43: ASN1_UTF8STRING = 0x0C,
44: ASN1_NUMERICSTRING = 0x12,
45: ASN1_PRINTABLESTRING = 0x13,
46: ASN1_T61STRING = 0x14,
47: ASN1_VIDEOTEXSTRING = 0x15,
48: ASN1_IA5STRING = 0x16,
49: ASN1_UTCTIME = 0x17,
50: ASN1_GENERALIZEDTIME = 0x18,
51: ASN1_GRAPHICSTRING = 0x19,
52: ASN1_VISIBLESTRING = 0x1A,
53: ASN1_GENERALSTRING = 0x1B,
54: ASN1_UNIVERSALSTRING = 0x1C,
55: ASN1_BMPSTRING = 0x1E,
56:
57: ASN1_CONSTRUCTED = 0x20,
58:
59: ASN1_SEQUENCE = 0x30,
60: ASN1_SET = 0x31,
61:
62: ASN1_CONTEXT_S_0 = 0x80,
63: ASN1_CONTEXT_S_1 = 0x81,
64: ASN1_CONTEXT_S_2 = 0x82,
65: ASN1_CONTEXT_S_3 = 0x83,
66: ASN1_CONTEXT_S_4 = 0x84,
67: ASN1_CONTEXT_S_5 = 0x85,
68: ASN1_CONTEXT_S_6 = 0x86,
69: ASN1_CONTEXT_S_7 = 0x87,
70: ASN1_CONTEXT_S_8 = 0x88,
71:
72: ASN1_CONTEXT_C_0 = 0xA0,
73: ASN1_CONTEXT_C_1 = 0xA1,
74: ASN1_CONTEXT_C_2 = 0xA2,
75: ASN1_CONTEXT_C_3 = 0xA3,
76: ASN1_CONTEXT_C_4 = 0xA4,
77: ASN1_CONTEXT_C_5 = 0xA5,
78:
79: ASN1_INVALID = 0x100,
80: } asn1_t;
81:
82: #define ASN1_INVALID_LENGTH 0xffffffff
83:
84: /**
85: * Some common prefabricated ASN.1 constants
86: */
87: extern const chunk_t ASN1_INTEGER_0;
88: extern const chunk_t ASN1_INTEGER_1;
89: extern const chunk_t ASN1_INTEGER_2;
90:
91:
92: /** Some ASN.1 analysis functions */
93:
94: /**
95: * Build an algorithmIdentifier from a known OID with empty parameters.
96: *
97: * @param oid known OID index
98: * @return body of the corresponding ASN.1 structure, allocated
99: */
100: chunk_t asn1_algorithmIdentifier(int oid);
101:
102: /**
103: * Build an algorithmIdentifier from a known OID and the given parameters.
104: *
105: * @param oid known OID index
106: * @param params parameters to encode in the algorithmIdentifier (adopted)
107: * @return body of the corresponding ASN.1 structure, allocated
108: */
109: chunk_t asn1_algorithmIdentifier_params(int oid, chunk_t params);
110:
111: /**
112: * Converts an ASN.1 OID into a known OID index
113: *
114: * @param object body of an OID
115: * @return index into the oid_names[] table or OID_UNKNOWN
116: */
117: int asn1_known_oid(chunk_t object);
118:
119: /**
120: * Converts a known OID index to an ASN.1 OID
121: *
122: * @param n index into the oid_names[] table
123: * @return allocated OID chunk, chunk_empty if index out of range
124: */
125: chunk_t asn1_build_known_oid(int n);
126:
127: /**
128: * Convert human readable OID to ASN.1 DER encoding, without OID header.
129: *
130: * @param str OID string (e.g. 1.2.345.67.8)
131: * @return allocated ASN.1 encoded OID, chunk_empty on error
132: */
133: chunk_t asn1_oid_from_string(char *str);
134:
135: /**
136: * Convert a DER encoded ASN.1 OID to a human readable string.
137: *
138: * @param oid DER encoded OID, without header
139: * @return human readable OID string, allocated, NULL on error
140: */
141: char* asn1_oid_to_string(chunk_t oid);
142:
143: /**
144: * Returns the length of an ASN.1 object
145: * The blob pointer is advanced past the tag length fields
146: *
147: * @param blob pointer to an ASN.1 coded blob
148: * @return length of ASN.1 object
149: */
150: size_t asn1_length(chunk_t *blob);
151:
152: /**
153: * Unwrap the inner content of an ASN.1 type/length wrapped object.
154: *
155: * @param blob blob to parse header from, moved behind parsed content
156: * @param content inner content
157: * @return parsed type, ASN1_INVALID if length parsing failed
158: */
159: int asn1_unwrap(chunk_t *blob, chunk_t *content);
160:
161: /**
162: * Parses an ASN.1 algorithmIdentifier object
163: *
164: * @param blob ASN.1 coded blob
165: * @param level0 top-most level offset
166: * @param params returns optional [ASN.1 coded] parameters
167: * @return known OID index or OID_UNKNOWN
168: */
169: int asn1_parse_algorithmIdentifier(chunk_t blob, int level0, chunk_t *params);
170:
171: /**
172: * Parse the top-most level of an ASN.1 object
173: *
174: * @param object ASN.1 coded object
175: * @param type Expected ASN.1 type
176: * @param level0 top-most level offset
177: * @param name descriptive name of object
178: * @return TRUE if parsing successful
179: */
180: bool asn1_parse_simple_object(chunk_t *object, asn1_t type, u_int level0,
181: const char* name);
182:
183: /**
184: * Converts an ASN.1 INTEGER object to an uint64_t. If the INTEGER is longer
185: * than 8 bytes only the 8 LSBs are returned.
186: *
187: * @param blob body of an ASN.1 coded integer object
188: * @return converted integer
189: */
190: uint64_t asn1_parse_integer_uint64(chunk_t blob);
191:
192: /**
193: * Converts an uint64_t to an ASN.1 INTEGER object.
194: *
195: * @param val integer to convert
196: * @return body of an ASN.1 coded integer object
197: */
198: chunk_t asn1_integer_from_uint64(uint64_t val);
199:
200: /**
201: * Print the value of an ASN.1 simple object
202: *
203: * @param object ASN.1 object to be printed
204: * @param type asn1_t type
205: * @param private ASN.1 data is confidential (use debug level 4)
206: */
207: void asn1_debug_simple_object(chunk_t object, asn1_t type, bool private);
208:
209: /**
210: * Converts an ASN.1 UTCTIME or GENERALIZEDTIME string to time_t
211: *
212: * On systems where sizeof(time_t) == 4 there will be an overflow
213: * for dates
214: * > Tue, 19 Jan 2038 03:14:07 UTC (0x7fffffff)
215: * and
216: * < Fri, 13 Dec 1901 20:45:52 UTC (0x80000000)
217: * in both cases TIME_32_BIT_SIGNED_MAX is returned.
218: *
219: * @param utctime body of an ASN.1 coded time object
220: * @param type ASN1_UTCTIME or ASN1_GENERALIZEDTIME
221: * @return time_t in UTC
222: */
223: time_t asn1_to_time(const chunk_t *utctime, asn1_t type);
224:
225: /**
226: * Converts time_t to an ASN.1 UTCTIME or GENERALIZEDTIME string
227: *
228: * @note The type is automatically changed to GENERALIZEDTIME if needed
229: *
230: * @param time time_t in UTC
231: * @param type ASN1_UTCTIME or ASN1_GENERALIZEDTIME
232: * @return body of an ASN.1 code time object
233: */
234: chunk_t asn1_from_time(const time_t *time, asn1_t type);
235:
236: /**
237: * Parse an ASN.1 UTCTIME or GENERALIZEDTIME object
238: *
239: * @param blob ASN.1 coded time object
240: * @param level0 top-most level offset
241: * @return time_t in UTC
242: */
243: time_t asn1_parse_time(chunk_t blob, int level0);
244:
245: /**
246: * Determines if a binary blob is ASN.1 coded
247: *
248: * @param blob blob to be tested
249: * @return TRUE if blob is ASN.1 coded (SEQUENCE or SET)
250: */
251: bool is_asn1(chunk_t blob);
252:
253: /**
254: * Determines if a character string can be coded as PRINTABLESTRING
255: *
256: * @param str character string to be tested
257: * @return TRUE if no special characters are contained
258: */
259: bool asn1_is_printablestring(chunk_t str);
260:
261:
262: /** some ASN.1 synthesis functions */
263:
264: /**
265: * Build an empty ASN.1 object with tag and length fields already filled in
266: *
267: * @param object returned object - memory is allocated by function
268: * @param type ASN.1 type to be created
269: * @param datalen size of the body to be created
270: * @return points to the first position in the body
271: */
272: u_char* asn1_build_object(chunk_t *object, asn1_t type, size_t datalen);
273:
274: /**
275: * Build a simple ASN.1 object
276: *
277: * @param tag ASN.1 type to be created
278: * @param content content of the ASN.1 object
279: * @return chunk containing the ASN.1 coded object
280: */
281: chunk_t asn1_simple_object(asn1_t tag, chunk_t content);
282:
283: /**
284: * Build an ASN.1 BITSTRING object
285: *
286: * @param mode 'c' for copy or 'm' for move
287: * @param content content of the BITSTRING
288: * @return chunk containing the ASN.1 coded BITSTRING
289: */
290: chunk_t asn1_bitstring(const char *mode, chunk_t content);
291:
292: /**
293: * Build an ASN.1 INTEGER object
294: *
295: * @param mode 'c' for copy or 'm' for move
296: * @param content content of the INTEGER
297: * @return chunk containing the ASN.1 coded INTEGER
298: */
299: chunk_t asn1_integer(const char *mode, chunk_t content);
300:
301: /**
302: * Build an ASN.1 object from a variable number of individual chunks
303: *
304: * The mode string specifies the number of chunks, and how to handle each of
305: * them with a single character: 'c' for copy (allocate new chunk), 'm' for move
306: * (free given chunk) or 's' for sensitive-copy (clear given chunk, then free).
307: *
308: * @param type ASN.1 type to be created
309: * @param mode for each list member: 'c', 'm' or 's'
310: * @return chunk containing the ASN.1 coded object
311: */
312: chunk_t asn1_wrap(asn1_t type, const char *mode, ...);
313:
314: #endif /** ASN1_H_ @}*/
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to asn1.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / asn1