source3/libsmb/asn1.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    simple SPNEGO routines
   4    Copyright (C) Andrew Tridgell 2001
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 /* free an asn1 structure */
  24 void asn1_free(ASN1_DATA *data)
  25 {
  26         SAFE_FREE(data->data);
  27 }
  28
  29 /* write to the ASN1 buffer, advancing the buffer pointer */
  30 BOOL asn1_write(ASN1_DATA *data, const void *p, int len)
  31 {
  32         if (data->has_error) return False;
  33         if (data->length < data->ofs+len) {
  34                 uint8 *newp;
  35                 newp = Realloc(data->data, data->ofs+len);
  36                 if (!newp) {
  37                         SAFE_FREE(data->data);
  38                         data->has_error = True;
  39                         return False;
  40                 }
  41                 data->data = newp;
  42                 data->length = data->ofs+len;
  43         }
  44         memcpy(data->data + data->ofs, p, len);
  45         data->ofs += len;
  46         return True;
  47 }
  48
  49 /* useful fn for writing a uint8 */
  50 BOOL asn1_write_uint8(ASN1_DATA *data, uint8 v)
  51 {
  52         return asn1_write(data, &v, 1);
  53 }
  54
  55 /* push a tag onto the asn1 data buffer. Used for nested structures */
  56 BOOL asn1_push_tag(ASN1_DATA *data, uint8 tag)
  57 {
  58         struct nesting *nesting;
  59
  60         asn1_write_uint8(data, tag);
  61         nesting = (struct nesting *)malloc(sizeof(struct nesting));
  62         if (!nesting) {
  63                 data->has_error = True;
  64                 return False;
  65         }
  66
  67         nesting->start = data->ofs;
  68         nesting->next = data->nesting;
  69         data->nesting = nesting;
  70         return asn1_write_uint8(data, 0xff);
  71 }
  72
  73 /* pop a tag */
  74 BOOL asn1_pop_tag(ASN1_DATA *data)
  75 {
  76         struct nesting *nesting;
  77         size_t len;
  78
  79         nesting = data->nesting;
  80
  81         if (!nesting) {
  82                 data->has_error = True;
  83                 return False;
  84         }
  85         len = data->ofs - (nesting->start+1);
  86         /* yes, this is ugly. We don't know in advance how many bytes the length
  87            of a tag will take, so we assumed 1 byte. If we were wrong then we
  88            need to correct our mistake */
  89         if (len > 255) {
  90                 data->data[nesting->start] = 0x82;
  91                 if (!asn1_write_uint8(data, 0)) return False;
  92                 if (!asn1_write_uint8(data, 0)) return False;
  93                 memmove(data->data+nesting->start+3, data->data+nesting->start+1, len);
  94                 data->data[nesting->start+1] = len>>8;
  95                 data->data[nesting->start+2] = len&0xff;
  96         } else if (len > 127) {
  97                 data->data[nesting->start] = 0x81;
  98                 if (!asn1_write_uint8(data, 0)) return False;
  99                 memmove(data->data+nesting->start+2, data->data+nesting->start+1, len);
 100                 data->data[nesting->start+1] = len;
 101         } else {
 102                 data->data[nesting->start] = len;
 103         }
 104
 105         data->nesting = nesting->next;
 106         free(nesting);
 107         return True;
 108 }
 109
 110
 111 /* write an integer */
 112 BOOL asn1_write_Integer(ASN1_DATA *data, int i)
 113 {
 114         if (!asn1_push_tag(data, ASN1_INTEGER)) return False;
 115         do {
 116                 asn1_write_uint8(data, i);
 117                 i = i >> 8;
 118         } while (i);
 119         return asn1_pop_tag(data);
 120 }
 121
 122 /* write an object ID to a ASN1 buffer */
 123 BOOL asn1_write_OID(ASN1_DATA *data, const char *OID)
 124 {
 125         unsigned v, v2;
 126         const char *p = (const char *)OID;
 127         char *newp;
 128
 129         if (!asn1_push_tag(data, ASN1_OID))
 130                 return False;
 131         v = strtol(p, &newp, 10);
 132         p = newp;
 133         v2 = strtol(p, &newp, 10);
 134         p = newp;
 135         if (!asn1_write_uint8(data, 40*v + v2))
 136                 return False;
 137
 138         while (*p) {
 139                 v = strtol(p, &newp, 10);
 140                 p = newp;
 141                 if (v >= (1<<28)) asn1_write_uint8(data, 0x80 | ((v>>28)&0xff));
 142                 if (v >= (1<<21)) asn1_write_uint8(data, 0x80 | ((v>>21)&0xff));
 143                 if (v >= (1<<14)) asn1_write_uint8(data, 0x80 | ((v>>14)&0xff));
 144                 if (v >= (1<<7)) asn1_write_uint8(data, 0x80 | ((v>>7)&0xff));
 145                 if (!asn1_write_uint8(data, v&0x7f))
 146                         return False;
 147         }
 148         return asn1_pop_tag(data);
 149 }
 150
 151 /* write an octet string */
 152 BOOL asn1_write_OctetString(ASN1_DATA *data, const void *p, size_t length)
 153 {
 154         asn1_push_tag(data, ASN1_OCTET_STRING);
 155         asn1_write(data, p, length);
 156         asn1_pop_tag(data);
 157         return !data->has_error;
 158 }
 159
 160 /* write a general string */
 161 BOOL asn1_write_GeneralString(ASN1_DATA *data, const char *s)
 162 {
 163         asn1_push_tag(data, ASN1_GENERAL_STRING);
 164         asn1_write(data, s, strlen(s));
 165         asn1_pop_tag(data);
 166         return !data->has_error;
 167 }
 168
 169 /* write a BOOLEAN */
 170 BOOL asn1_write_BOOLEAN(ASN1_DATA *data, BOOL v)
 171 {
 172         asn1_write_uint8(data, ASN1_BOOLEAN);
 173         asn1_write_uint8(data, v);
 174         return !data->has_error;
 175 }
 176
 177 /* write a BOOLEAN - hmm, I suspect this one is the correct one, and the
 178    above boolean is bogus. Need to check */
 179 BOOL asn1_write_BOOLEAN2(ASN1_DATA *data, BOOL v)
 180 {
 181         asn1_push_tag(data, ASN1_BOOLEAN);
 182         asn1_write_uint8(data, v);
 183         asn1_pop_tag(data);
 184         return !data->has_error;
 185 }
 186
 187 /* check a BOOLEAN */
 188 BOOL asn1_check_BOOLEAN(ASN1_DATA *data, BOOL v)
 189 {
 190         uint8 b = 0;
 191
 192         asn1_read_uint8(data, &b);
 193         if (b != ASN1_BOOLEAN) {
 194                 data->has_error = True;
 195                 return False;
 196         }
 197         asn1_read_uint8(data, &b);
 198         if (b != v) {
 199                 data->has_error = True;
 200                 return False;
 201         }
 202         return !data->has_error;
 203 }
 204
 205
 206 /* load a ASN1_DATA structure with a lump of data, ready to be parsed */
 207 BOOL asn1_load(ASN1_DATA *data, DATA_BLOB blob)
 208 {
 209         ZERO_STRUCTP(data);
 210         data->data = memdup(blob.data, blob.length);
 211         if (!data->data) {
 212                 data->has_error = True;
 213                 return False;
 214         }
 215         data->length = blob.length;
 216         return True;
 217 }
 218
 219 /* read from a ASN1 buffer, advancing the buffer pointer */
 220 BOOL asn1_read(ASN1_DATA *data, void *p, int len)
 221 {
 222         if (data->ofs + len > data->length) {
 223                 data->has_error = True;
 224                 return False;
 225         }
 226         memcpy(p, data->data + data->ofs, len);
 227         data->ofs += len;
 228         return True;
 229 }
 230
 231 /* read a uint8 from a ASN1 buffer */
 232 BOOL asn1_read_uint8(ASN1_DATA *data, uint8 *v)
 233 {
 234         return asn1_read(data, v, 1);
 235 }
 236
 237 /* start reading a nested asn1 structure */
 238 BOOL asn1_start_tag(ASN1_DATA *data, uint8 tag)
 239 {
 240         uint8 b;
 241         struct nesting *nesting;
 242
 243         if (!asn1_read_uint8(data, &b))
 244                 return False;
 245
 246         if (b != tag) {
 247                 data->has_error = True;
 248                 return False;
 249         }
 250         nesting = (struct nesting *)malloc(sizeof(struct nesting));
 251         if (!nesting) {
 252                 data->has_error = True;
 253                 return False;
 254         }
 255
 256         if (!asn1_read_uint8(data, &b)) {
 257                 return False;
 258         }
 259
 260         if (b & 0x80) {
 261                 int n = b & 0x7f;
 262                 if (!asn1_read_uint8(data, &b))
 263                         return False;
 264                 nesting->taglen = b;
 265                 while (n > 1) {
 266                         if (!asn1_read_uint8(data, &b))
 267                                 return False;
 268                         nesting->taglen = (nesting->taglen << 8) | b;
 269                         n--;
 270                 }
 271         } else {
 272                 nesting->taglen = b;
 273         }
 274         nesting->start = data->ofs;
 275         nesting->next = data->nesting;
 276         data->nesting = nesting;
 277         return !data->has_error;
 278 }
 279
 280
 281 /* stop reading a tag */
 282 BOOL asn1_end_tag(ASN1_DATA *data)
 283 {
 284         struct nesting *nesting;
 285
 286         /* make sure we read it all */
 287         if (asn1_tag_remaining(data) != 0) {
 288                 data->has_error = True;
 289                 return False;
 290         }
 291
 292         nesting = data->nesting;
 293
 294         if (!nesting) {
 295                 data->has_error = True;
 296                 return False;
 297         }
 298
 299         data->nesting = nesting->next;
 300         free(nesting);
 301         return True;
 302 }
 303
 304 /* work out how many bytes are left in this nested tag */
 305 int asn1_tag_remaining(ASN1_DATA *data)
 306 {
 307         if (!data->nesting) {
 308                 data->has_error = True;
 309                 return -1;
 310         }
 311         return data->nesting->taglen - (data->ofs - data->nesting->start);
 312 }
 313
 314 /* read an object ID from a ASN1 buffer */
 315 BOOL asn1_read_OID(ASN1_DATA *data, char **OID)
 316 {
 317         uint8 b;
 318         pstring oid;
 319         fstring el;
 320
 321         if (!asn1_start_tag(data, ASN1_OID)) return False;
 322         asn1_read_uint8(data, &b);
 323
 324         oid[0] = 0;
 325         fstr_sprintf(el, "%u",  b/40);
 326         pstrcat(oid, el);
 327         fstr_sprintf(el, " %u",  b%40);
 328         pstrcat(oid, el);
 329
 330         while (asn1_tag_remaining(data) > 0) {
 331                 unsigned v = 0;
 332                 do {
 333                         asn1_read_uint8(data, &b);
 334                         v = (v<<7) | (b&0x7f);
 335                 } while (!data->has_error && b & 0x80);
 336                 fstr_sprintf(el, " %u",  v);
 337                 pstrcat(oid, el);
 338         }
 339
 340         asn1_end_tag(data);
 341
 342         *OID = strdup(oid);
 343
 344         return !data->has_error;
 345 }
 346
 347 /* check that the next object ID is correct */
 348 BOOL asn1_check_OID(ASN1_DATA *data, const char *OID)
 349 {
 350         char *id;
 351
 352         if (!asn1_read_OID(data, &id)) return False;
 353
 354         if (strcmp(id, OID) != 0) {
 355                 data->has_error = True;
 356                 return False;
 357         }
 358         free(id);
 359         return True;
 360 }
 361
 362 /* read a GeneralString from a ASN1 buffer */
 363 BOOL asn1_read_GeneralString(ASN1_DATA *data, char **s)
 364 {
 365         int len;
 366         if (!asn1_start_tag(data, ASN1_GENERAL_STRING)) return False;
 367         len = asn1_tag_remaining(data);
 368         *s = malloc(len+1);
 369         if (! *s) {
 370                 data->has_error = True;
 371                 return False;
 372         }
 373         asn1_read(data, *s, len);
 374         (*s)[len] = 0;
 375         asn1_end_tag(data);
 376         return !data->has_error;
 377 }
 378
 379 /* read a octet string blob */
 380 BOOL asn1_read_OctetString(ASN1_DATA *data, DATA_BLOB *blob)
 381 {
 382         int len;
 383         ZERO_STRUCTP(blob);
 384         if (!asn1_start_tag(data, ASN1_OCTET_STRING)) return False;
 385         len = asn1_tag_remaining(data);
 386         *blob = data_blob(NULL, len);
 387         asn1_read(data, blob->data, len);
 388         asn1_end_tag(data);
 389         return !data->has_error;
 390 }
 391
 392 /* read an interger */
 393 BOOL asn1_read_Integer(ASN1_DATA *data, int *i)
 394 {
 395         uint8 b;
 396         *i = 0;
 397
 398         if (!asn1_start_tag(data, ASN1_INTEGER)) return False;
 399         while (asn1_tag_remaining(data)>0) {
 400                 asn1_read_uint8(data, &b);
 401                 *i = (*i << 8) + b;
 402         }
 403         return asn1_end_tag(data);
 404
 405 }
 406
 407 /* check a enumarted value is correct */
 408 BOOL asn1_check_enumerated(ASN1_DATA *data, int v)
 409 {
 410         uint8 b;
 411         if (!asn1_start_tag(data, ASN1_ENUMERATED)) return False;
 412         asn1_read_uint8(data, &b);
 413         asn1_end_tag(data);
 414
 415         if (v != b)
 416                 data->has_error = False;
 417
 418         return !data->has_error;
 419 }
 420
 421 /* write an enumarted value to the stream */
 422 BOOL asn1_write_enumerated(ASN1_DATA *data, uint8 v)
 423 {
 424         if (!asn1_push_tag(data, ASN1_ENUMERATED)) return False;
 425         asn1_write_uint8(data, v);
 426         asn1_pop_tag(data);
 427         return !data->has_error;
 428 }