1: /*
2: * $Id: libnet_asn1.c,v 1.1.1.1 2012/02/21 22:14:23 misho Exp $
3: *
4: * libnet 1.1
5: * libnet_asn1.c - Abstract Syntax Notation One routines
6: *
7: * Abstract Syntax Notation One, ASN.1
8: * As defined in ISO/IS 8824 and ISO/IS 8825
9: * This implements a subset of the above International Standards that
10: * is sufficient to implement SNMP.
11: *
12: * Encodes abstract data types into a machine independent stream of bytes.
13: *
14: * Copyright 1988, 1989, 1991, 1992 by Carnegie Mellon University
15: * All rights reserved.
16: *
17: * Permission to use, copy, modify, and distribute this software and its
18: * documentation for any purpose and without fee is hereby granted,
19: * provided that the above copyright notice appear in all copies and that
20: * both that copyright notice and this permission notice appear in
21: * supporting documentation, and that the name of CMU not be
22: * used in advertising or publicity pertaining to distribution of the
23: * software without specific, written prior permission.
24: *
25: * CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
26: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
27: * CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
28: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
29: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
30: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
31: * SOFTWARE.
32: *
33: * Copyright (c) 1998 - 2004 Mike D. Schiffman <mike@infonexus.com>
34: * All rights reserved.
35: *
36: * Copyright (c) 1993, 1994, 1995, 1996, 1998
37: * The Regents of the University of California. All rights reserved.
38: *
39: * Redistribution and use in source and binary forms, with or without
40: * modification, are permitted provided that: (1) source code distributions
41: * retain the above copyright notice and this paragraph in its entirety, (2)
42: * distributions including binary code include the above copyright notice and
43: * this paragraph in its entirety in the documentation or other materials
44: * provided with the distribution, and (3) all advertising materials mentioning
45: * features or use of this software display the following acknowledgement:
46: * ``This product includes software developed by the University of California,
47: * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
48: * the University nor the names of its contributors may be used to endorse
49: * or promote products derived from this software without specific prior
50: * written permission.
51: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
52: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
53: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
54: */
55:
56: #if (HAVE_CONFIG_H)
57: #include "../include/config.h"
58: #endif
59: #if (!(_WIN32) || (__CYGWIN__))
60: #include "../include/libnet.h"
61: #else
62: #include "../include/win32/libnet.h"
63: #endif
64:
65: u_int8_t *
66: libnet_build_asn1_int(u_int8_t *data, int *datalen, u_int8_t type, int32_t *int_p,
67: int int_s)
68: {
69: /*
70: * ASN.1 integer ::= 0x02 asnlength byte {byte}*
71: */
72: register int32_t integer;
73: register u_int32_t mask;
74:
75: if (int_s != sizeof (int32_t))
76: {
77: return (NULL);
78: }
79: integer = *int_p;
80:
81: /*
82: * Truncate "unnecessary" bytes off of the most significant end of this
83: * 2's complement integer. There should be no sequence of 9 consecutive
84: * 1's or 0's at the most significant end of the integer.
85: */
86: mask = ((u_int32_t) 0x1FF) << ((8 * (sizeof (int32_t) - 1)) - 1);
87: /* mask is 0xFF800000 on a big-endian machine */
88:
89: while ((((integer & mask) == 0) || ((integer & mask) == mask)) && int_s > 1)
90: {
91: int_s--;
92: integer <<= 8;
93: }
94:
95: data = libnet_build_asn1_header(data, datalen, type, int_s);
96:
97: if (data == NULL || *datalen < int_s)
98: {
99: return (NULL);
100: }
101:
102: *datalen -= int_s;
103:
104: mask = ((u_int32_t) 0xFF) << (8 * (sizeof(int32_t) - 1));
105: /* mask is 0xFF000000 on a big-endian machine */
106:
107: while (int_s--)
108: {
109: *data++ = (u_int8_t)((integer & mask) >> (8 * (sizeof (int32_t) - 1)));
110: integer <<= 8;
111: }
112: return (data);
113: }
114:
115:
116: u_int8_t *
117: libnet_build_asn1_uint(u_int8_t *data, int *datalen, u_int8_t type, u_int32_t *int_p,
118: int int_s)
119: {
120: /*
121: * ASN.1 integer ::= 0x02 asnlength byte {byte}*
122: */
123: register u_int32_t integer;
124: register u_int32_t mask;
125: int add_null_byte = 0;
126:
127: if (int_s != sizeof (int32_t))
128: {
129: return (NULL);
130: }
131: integer = *int_p;
132:
133: mask = ((u_int32_t) 0xFF) << (8 * (sizeof (int32_t) - 1));
134: /* mask is 0xFF000000 on a big-endian machine */
135:
136: if ((u_int8_t)((integer & mask) >> (8 * (sizeof (int32_t) - 1))) & 0x80)
137: {
138: /* if MSB is set */
139: add_null_byte = 1;
140: int_s++;
141: }
142: else
143: {
144: /*
145: * Truncate "unnecessary" bytes off of the most significant end of this
146: * 2's complement integer. There should be no sequence of 9
147: * consecutive 1's or 0's at the most significant end of the
148: * integer.
149: */
150: mask = ((u_int32_t) 0x1FF) << ((8 * (sizeof(int32_t) - 1)) - 1);
151: /* mask is 0xFF800000 on a big-endian machine */
152:
153: while (((integer & mask) == 0) && int_s > 1)
154: {
155: int_s--;
156: integer <<= 8;
157: }
158: }
159:
160: data = libnet_build_asn1_header(data, datalen, type, int_s);
161:
162: if (data == NULL || *datalen < int_s)
163: {
164: return (NULL);
165: }
166:
167: *datalen -= int_s;
168:
169: if (add_null_byte == 1)
170: {
171: *data++ = '\0';
172: int_s--;
173: }
174:
175: mask = ((u_int32_t) 0xFF) << (8 * (sizeof(int32_t) - 1));
176: /* mask is 0xFF000000 on a big-endian machine */
177:
178: while (int_s--)
179: {
180: *data++ = (u_int8_t)((integer & mask) >> (8 * (sizeof (int32_t) - 1)));
181: integer <<= 8;
182: }
183: return (data);
184: }
185:
186:
187: u_int8_t *
188: libnet_build_asn1_string(u_int8_t *data, int *datalen, u_int8_t type,
189: u_int8_t *string, int str_s)
190: {
191:
192: /*
193: * ASN.1 octet string ::= primstring | cmpdstring
194: * primstring ::= 0x04 asnlength byte {byte}*
195: * cmpdstring ::= 0x24 asnlength string {string}*
196: * This code will never send a compound string.
197: */
198: data = libnet_build_asn1_header(data, datalen, type, str_s);
199:
200: if (data == NULL || *datalen < str_s)
201: {
202: return (NULL);
203: }
204: memmove(data, string, str_s);
205: *datalen -= str_s;
206:
207: return (data + str_s);
208: }
209:
210:
211: u_int8_t *
212: libnet_build_asn1_header(u_int8_t *data, int *datalen, u_int8_t type, int len)
213: {
214: if (*datalen < 1)
215: {
216: return (NULL);
217: }
218: *data++ = type;
219: (*datalen)--;
220:
221: return (libnet_build_asn1_length(data, datalen, len));
222: }
223:
224:
225: u_int8_t *
226: libnet_build_asn1_sequence(u_int8_t *data, int *datalen, u_int8_t type, int len)
227: {
228: *datalen -= 4;
229: if (*datalen < 0)
230: {
231: *datalen += 4; /* fix up before punting */
232: return (NULL);
233: }
234: *data++ = type;
235: *data++ = (u_int8_t)(0x02 | ASN_LONG_LEN);
236: *data++ = (u_int8_t)((len >> 8) & 0xFF);
237: *data++ = (u_int8_t)(len & 0xFF);
238: return (data);
239: }
240:
241:
242: u_int8_t *
243: libnet_build_asn1_length(u_int8_t *data, int *datalen, int len)
244: {
245: u_int8_t *start_data = data;
246:
247: /* no indefinite lengths sent */
248: if (len < 0x80)
249: {
250: if (*datalen < 1)
251: {
252: return (NULL);
253: }
254: *data++ = (u_int8_t)len;
255: }
256: else if (len <= 0xFF)
257: {
258: if (*datalen < 2)
259: {
260: return (NULL);
261: }
262: *data++ = (u_int8_t)(0x01 | ASN_LONG_LEN);
263: *data++ = (u_int8_t)len;
264: }
265: else /* 0xFF < len <= 0xFFFF */
266: {
267: if (*datalen < 3)
268: {
269: return (NULL);
270: }
271: *data++ = (u_int8_t)(0x02 | ASN_LONG_LEN);
272: *data++ = (u_int8_t)((len >> 8) & 0xFF);
273: *data++ = (u_int8_t)(len & 0xFF);
274: }
275: *datalen -= (data - start_data);
276: return (data);
277: }
278:
279:
280: u_int8_t *
281: libnet_build_asn1_objid(u_int8_t *data, int *datalen, u_int8_t type, oid *objid,
282: int objidlen)
283: {
284: /*
285: * ASN.1 objid ::= 0x06 asnlength subidentifier {subidentifier}*
286: * subidentifier ::= {leadingbyte}* lastbyte
287: * leadingbyte ::= 1 7bitvalue
288: * lastbyte ::= 0 7bitvalue
289: */
290: int asnlen;
291: register oid *op = objid;
292: u_int8_t objid_size[MAX_OID_LEN];
293: register u_int32_t objid_val;
294: u_int32_t first_objid_val;
295: register int i;
296:
297: /* check if there are at least 2 sub-identifiers */
298: if (objidlen < 2)
299: {
300: /* there are not, so make OID have two with value of zero */
301: objid_val = 0;
302: objidlen = 2;
303: }
304: else
305: {
306: /* combine the first two values */
307: objid_val = (op[0] * 40) + op[1];
308: op += 2;
309: }
310: first_objid_val = objid_val;
311:
312: /* calculate the number of bytes needed to store the encoded value */
313: for (i = 1, asnlen = 0;;)
314: {
315: if (objid_val < (unsigned)0x80)
316: {
317: objid_size[i] = 1;
318: asnlen += 1;
319: }
320: else if (objid_val < (unsigned)0x4000)
321: {
322: objid_size[i] = 2;
323: asnlen += 2;
324: }
325: else if (objid_val < (unsigned)0x200000)
326: {
327: objid_size[i] = 3;
328: asnlen += 3;
329: }
330: else if (objid_val < (unsigned)0x10000000)
331: {
332: objid_size[i] = 4;
333: asnlen += 4;
334: }
335: else
336: {
337: objid_size[i] = 5;
338: asnlen += 5;
339: }
340: i++;
341: if (i >= objidlen)
342: {
343: break;
344: }
345: objid_val = *op++;
346: }
347:
348: /* store the ASN.1 tag and length */
349: data = libnet_build_asn1_header(data, datalen, type, asnlen);
350: if (data == NULL || *datalen < asnlen)
351: {
352: return (NULL);
353: }
354:
355: /* store the encoded OID value */
356: for (i = 1, objid_val = first_objid_val, op = objid + 2; i < objidlen; i++)
357: {
358: if (i != 1)
359: {
360: objid_val = *op++;
361: }
362: switch (objid_size[i])
363: {
364: case 1:
365: *data++ = (u_int8_t)objid_val;
366: break;
367:
368: case 2:
369: *data++ = (u_int8_t)((objid_val >> 7) | 0x80);
370: *data++ = (u_int8_t)(objid_val & 0x07f);
371: break;
372: case 3:
373: *data++ = (u_int8_t)((objid_val >> 14) | 0x80);
374: *data++ = (u_int8_t)((objid_val >> 7 & 0x7f) | 0x80);
375: *data++ = (u_int8_t)(objid_val & 0x07f);
376: break;
377:
378: case 4:
379: *data++ = (u_int8_t)((objid_val >> 21) | 0x80);
380: *data++ = (u_int8_t)((objid_val >> 14 & 0x7f) | 0x80);
381: *data++ = (u_int8_t)((objid_val >> 7 & 0x7f) | 0x80);
382: *data++ = (u_int8_t)(objid_val & 0x07f);
383: break;
384:
385: case 5:
386: *data++ = (u_int8_t)((objid_val >> 28) | 0x80);
387: *data++ = (u_int8_t)((objid_val >> 21 & 0x7f) | 0x80);
388: *data++ = (u_int8_t)((objid_val >> 14 & 0x7f) | 0x80);
389: *data++ = (u_int8_t)((objid_val >> 7 & 0x7f) | 0x80);
390: *data++ = (u_int8_t)(objid_val & 0x07f);
391: break;
392: }
393: }
394:
395: /* return the length and data ptagr */
396: *datalen -= asnlen;
397: return (data);
398: }
399:
400:
401: u_int8_t *
402: libnet_build_asn1_null(u_int8_t *data, int *datalen, u_int8_t type)
403: {
404: /*
405: * ASN.1 null ::= 0x05 0x00
406: */
407: return (libnet_build_asn1_header(data, datalen, type, 0));
408: }
409:
410:
411: u_int8_t *
412: libnet_build_asn1_bitstring(u_int8_t *data, int *datalen, u_int8_t type,
413: u_int8_t *string, int str_s)
414: {
415:
416: /*
417: * ASN.1 bit string ::= 0x03 asnlength unused {byte}*
418: */
419: if (str_s < 1 || *string > 7)
420: {
421: return (NULL);
422: }
423: data = libnet_build_asn1_header(data, datalen, type, str_s);
424:
425: if (data == NULL || *datalen < str_s)
426: {
427: return (NULL);
428: }
429:
430: memmove(data, string, str_s);
431: *datalen -= str_s;
432:
433: return (data + str_s);
434: }
435:
436: /* EOF */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libnet_asn1.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libnet / src