source/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 3 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, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21
  22 /* free an asn1 structure */
  23 void asn1_free(ASN1_DATA *data)
  24 {
  25         struct nesting *nesting = data->nesting;
  26
  27         while (nesting) {
  28                 struct nesting *nnext = nesting->next;
  29                 free(nesting);
  30                 nesting = nnext;
  31         };
  32         data->nesting = NULL;
  33         SAFE_FREE(data->data);
  34 }
  35
  36 /* write to the ASN1 buffer, advancing the buffer pointer */
  37 bool asn1_write(ASN1_DATA *data, const void *p, int len)
  38 {
  39         if (data->has_error) return False;
  40         if (data->length < data->ofs+len) {
  41                 data->data = SMB_REALLOC_ARRAY(data->data, unsigned char,
  42                                                data->ofs+len);
  43                 if (!data->data) {
  44                         data->has_error = True;
  45                         return False;
  46                 }
  47                 data->length = data->ofs+len;
  48         }
  49         memcpy(data->data + data->ofs, p, len);
  50         data->ofs += len;
  51         return True;
  52 }
  53
  54 /* useful fn for writing a uint8 */
  55 bool asn1_write_uint8(ASN1_DATA *data, uint8 v)
  56 {
  57         return asn1_write(data, &v, 1);
  58 }
  59
  60 /* push a tag onto the asn1 data buffer. Used for nested structures */
  61 bool asn1_push_tag(ASN1_DATA *data, uint8 tag)
  62 {
  63         struct nesting *nesting;
  64
  65         asn1_write_uint8(data, tag);
  66         nesting = SMB_MALLOC_P(struct nesting);
  67         if (!nesting) {
  68                 data->has_error = True;
  69                 return False;
  70         }
  71
  72         nesting->start = data->ofs;
  73         nesting->next = data->nesting;
  74         data->nesting = nesting;
  75         return asn1_write_uint8(data, 0xff);
  76 }
  77
  78 /* pop a tag */
  79 bool asn1_pop_tag(ASN1_DATA *data)
  80 {
  81         struct nesting *nesting;
  82         size_t len;
  83
  84         if (data->has_error) {
  85                 return False;
  86         }
  87
  88         nesting = data->nesting;
  89
  90         if (!nesting) {
  91                 data->has_error = True;
  92                 return False;
  93         }
  94         len = data->ofs - (nesting->start+1);
  95         /* yes, this is ugly. We don't know in advance how many bytes the length
  96            of a tag will take, so we assumed 1 byte. If we were wrong then we
  97            need to correct our mistake */
  98         if (len > 0xFFFF) {
  99                 data->data[nesting->start] = 0x83;
 100                 if (!asn1_write_uint8(data, 0)) return False;
 101                 if (!asn1_write_uint8(data, 0)) return False;
 102                 if (!asn1_write_uint8(data, 0)) return False;
 103                 memmove(data->data+nesting->start+4, data->data+nesting->start+1, len);
 104                 data->data[nesting->start+1] = (len>>16) & 0xFF;
 105                 data->data[nesting->start+2] = (len>>8) & 0xFF;
 106                 data->data[nesting->start+3] = len&0xff;
 107         } else if (len > 255) {
 108                 data->data[nesting->start] = 0x82;
 109                 if (!asn1_write_uint8(data, 0)) return False;
 110                 if (!asn1_write_uint8(data, 0)) return False;
 111                 memmove(data->data+nesting->start+3, data->data+nesting->start+1, len);
 112                 data->data[nesting->start+1] = len>>8;
 113                 data->data[nesting->start+2] = len&0xff;
 114         } else if (len > 127) {
 115                 data->data[nesting->start] = 0x81;
 116                 if (!asn1_write_uint8(data, 0)) return False;
 117                 memmove(data->data+nesting->start+2, data->data+nesting->start+1, len);
 118                 data->data[nesting->start+1] = len;
 119         } else {
 120                 data->data[nesting->start] = len;
 121         }
 122
 123         data->nesting = nesting->next;
 124         free(nesting);
 125         return True;
 126 }
 127
 128
 129 /* write an integer */
 130 bool asn1_write_Integer(ASN1_DATA *data, int i)
 131 {
 132         if (!asn1_push_tag(data, ASN1_INTEGER)) return False;
 133         do {
 134                 asn1_write_uint8(data, i);
 135                 i = i >> 8;
 136         } while (i);
 137         return asn1_pop_tag(data);
 138 }
 139
 140 /* write an object ID to a ASN1 buffer */
 141 bool asn1_write_OID(ASN1_DATA *data, const char *OID)
 142 {
 143         unsigned v, v2;
 144         const char *p = (const char *)OID;
 145         char *newp;
 146
 147         if (!asn1_push_tag(data, ASN1_OID))
 148                 return False;
 149         v = strtol(p, &newp, 10);
 150         p = newp;
 151         v2 = strtol(p, &newp, 10);
 152         p = newp;
 153         if (!asn1_write_uint8(data, 40*v + v2))
 154                 return False;
 155
 156         while (*p) {
 157                 v = strtol(p, &newp, 10);
 158                 p = newp;
 159                 if (v >= (1<<28)) asn1_write_uint8(data, 0x80 | ((v>>28)&0xff));
 160                 if (v >= (1<<21)) asn1_write_uint8(data, 0x80 | ((v>>21)&0xff));
 161                 if (v >= (1<<14)) asn1_write_uint8(data, 0x80 | ((v>>14)&0xff));
 162                 if (v >= (1<<7)) asn1_write_uint8(data, 0x80 | ((v>>7)&0xff));
 163                 if (!asn1_write_uint8(data, v&0x7f))
 164                         return False;
 165         }
 166         return asn1_pop_tag(data);
 167 }
 168
 169 /* write an octet string */
 170 bool asn1_write_OctetString(ASN1_DATA *data, const void *p, size_t length)
 171 {
 172         asn1_push_tag(data, ASN1_OCTET_STRING);
 173         asn1_write(data, p, length);
 174         asn1_pop_tag(data);
 175         return !data->has_error;
 176 }
 177
 178 /* write a general string */
 179 bool asn1_write_GeneralString(ASN1_DATA *data, const char *s)
 180 {
 181         asn1_push_tag(data, ASN1_GENERAL_STRING);
 182         asn1_write(data, s, strlen(s));
 183         asn1_pop_tag(data);
 184         return !data->has_error;
 185 }
 186
 187 /* write a BOOLEAN */
 188 bool asn1_write_BOOLEAN(ASN1_DATA *data, bool v)
 189 {
 190         asn1_write_uint8(data, ASN1_BOOLEAN);
 191         asn1_write_uint8(data, v);
 192         return !data->has_error;
 193 }
 194
 195 /* write a BOOLEAN - hmm, I suspect this one is the correct one, and the
 196    above boolean is bogus. Need to check */
 197 bool asn1_write_BOOLEAN2(ASN1_DATA *data, bool v)
 198 {
 199         asn1_push_tag(data, ASN1_BOOLEAN);
 200         asn1_write_uint8(data, v);
 201         asn1_pop_tag(data);
 202         return !data->has_error;
 203 }
 204
 205 /* check a BOOLEAN */
 206 bool asn1_check_BOOLEAN(ASN1_DATA *data, bool v)
 207 {
 208         uint8 b = 0;
 209
 210         asn1_read_uint8(data, &b);
 211         if (b != ASN1_BOOLEAN) {
 212                 data->has_error = True;
 213                 return False;
 214         }
 215         asn1_read_uint8(data, &b);
 216         if (b != v) {
 217                 data->has_error = True;
 218                 return False;
 219         }
 220         return !data->has_error;
 221 }
 222
 223
 224 /* load a ASN1_DATA structure with a lump of data, ready to be parsed */
 225 bool asn1_load(ASN1_DATA *data, DATA_BLOB blob)
 226 {
 227         ZERO_STRUCTP(data);
 228         data->data = (unsigned char *)memdup(blob.data, blob.length);
 229         if (!data->data) {
 230                 data->has_error = True;
 231                 return False;
 232         }
 233         data->length = blob.length;
 234         return True;
 235 }
 236
 237 /* read from a ASN1 buffer, advancing the buffer pointer */
 238 bool asn1_read(ASN1_DATA *data, void *p, int len)
 239 {
 240         if (data->has_error)
 241                 return False;
 242
 243         if (len < 0 || data->ofs + len < data->ofs || data->ofs + len < len) {
 244                 data->has_error = True;
 245                 return False;
 246         }
 247
 248         if (data->ofs + len > data->length) {
 249                 data->has_error = True;
 250                 return False;
 251         }
 252         memcpy(p, data->data + data->ofs, len);
 253         data->ofs += len;
 254         return True;
 255 }
 256
 257 /* read a uint8 from a ASN1 buffer */
 258 bool asn1_read_uint8(ASN1_DATA *data, uint8 *v)
 259 {
 260         return asn1_read(data, v, 1);
 261 }
 262
 263 /* start reading a nested asn1 structure */
 264 bool asn1_start_tag(ASN1_DATA *data, uint8 tag)
 265 {
 266         uint8 b;
 267         struct nesting *nesting;
 268
 269         if (!asn1_read_uint8(data, &b))
 270                 return False;
 271
 272         if (b != tag) {
 273                 data->has_error = True;
 274                 return False;
 275         }
 276         nesting = SMB_MALLOC_P(struct nesting);
 277         if (!nesting) {
 278                 data->has_error = True;
 279                 return False;
 280         }
 281
 282         if (!asn1_read_uint8(data, &b)) {
 283                 SAFE_FREE(nesting);
 284                 return False;
 285         }
 286
 287         if (b & 0x80) {
 288                 int n = b & 0x7f;
 289                 if (!asn1_read_uint8(data, &b)) {
 290                         SAFE_FREE(nesting);
 291                         return False;
 292                 }
 293                 nesting->taglen = b;
 294                 while (n > 1) {
 295                         if (!asn1_read_uint8(data, &b)) {
 296                                 SAFE_FREE(nesting);
 297                                 return False;
 298                         }
 299                         nesting->taglen = (nesting->taglen << 8) | b;
 300                         n--;
 301                 }
 302         } else {
 303                 nesting->taglen = b;
 304         }
 305         nesting->start = data->ofs;
 306         nesting->next = data->nesting;
 307         data->nesting = nesting;
 308         return !data->has_error;
 309 }
 310
 311
 312 /* stop reading a tag */
 313 bool asn1_end_tag(ASN1_DATA *data)
 314 {
 315         struct nesting *nesting;
 316
 317         /* make sure we read it all */
 318         if (asn1_tag_remaining(data) != 0) {
 319                 data->has_error = True;
 320                 return False;
 321         }
 322
 323         nesting = data->nesting;
 324
 325         if (!nesting) {
 326                 data->has_error = True;
 327                 return False;
 328         }
 329
 330         data->nesting = nesting->next;
 331         free(nesting);
 332         return True;
 333 }
 334
 335 /* work out how many bytes are left in this nested tag */
 336 int asn1_tag_remaining(ASN1_DATA *data)
 337 {
 338         if (data->has_error)
 339                 return 0;
 340
 341         if (!data->nesting) {
 342                 data->has_error = True;
 343                 return -1;
 344         }
 345         return data->nesting->taglen - (data->ofs - data->nesting->start);
 346 }
 347
 348 /* read an object ID from a ASN1 buffer */
 349 bool asn1_read_OID(ASN1_DATA *data, char **OID)
 350 {
 351         uint8 b = 0;
 352         char *oid_str = NULL;
 353
 354         *OID = NULL;
 355
 356         if (!asn1_start_tag(data, ASN1_OID)) {
 357                 return false;
 358         }
 359         asn1_read_uint8(data, &b);
 360
 361         oid_str = talloc_asprintf(NULL,
 362                         "%u",
 363                         b/40);
 364         if (!oid_str) {
 365                 data->has_error = true;
 366                 goto out;
 367         }
 368         oid_str = talloc_asprintf_append(oid_str,
 369                         " %u",
 370                         b%40);
 371         if (!oid_str) {
 372                 data->has_error = true;
 373                 goto out;
 374         }
 375
 376         while (asn1_tag_remaining(data) > 0) {
 377                 unsigned v = 0;
 378                 do {
 379                         asn1_read_uint8(data, &b);
 380                         v = (v<<7) | (b&0x7f);
 381                 } while (!data->has_error && b & 0x80);
 382                 oid_str = talloc_asprintf_append(oid_str,
 383                                         " %u",
 384                                         v);
 385                 if (!oid_str) {
 386                         data->has_error = true;
 387                         goto out;
 388                 }
 389         }
 390
 391   out:
 392
 393         asn1_end_tag(data);
 394
 395         if (!data->has_error) {
 396                 *OID = SMB_STRDUP(oid_str);
 397         }
 398
 399         TALLOC_FREE(oid_str);
 400
 401         return !data->has_error;
 402 }
 403
 404 /* check that the next object ID is correct */
 405 bool asn1_check_OID(ASN1_DATA *data, const char *OID)
 406 {
 407         char *id;
 408
 409         if (!asn1_read_OID(data, &id)) {
 410                 return False;
 411         }
 412
 413         if (strcmp(id, OID) != 0) {
 414                 data->has_error = True;
 415                 return False;
 416         }
 417         free(id);
 418         return True;
 419 }
 420
 421 /* read a GeneralString from a ASN1 buffer */
 422 bool asn1_read_GeneralString(ASN1_DATA *data, char **s)
 423 {
 424         int len;
 425         char *str;
 426
 427         *s = NULL;
 428
 429         if (!asn1_start_tag(data, ASN1_GENERAL_STRING)) {
 430                 return False;
 431         }
 432         len = asn1_tag_remaining(data);
 433         if (len < 0) {
 434                 data->has_error = True;
 435                 return False;
 436         }
 437         str = SMB_MALLOC_ARRAY(char, len+1);
 438         if (!str) {
 439                 data->has_error = True;
 440                 return False;
 441         }
 442         asn1_read(data, str, len);
 443         str[len] = 0;
 444         asn1_end_tag(data);
 445
 446         if (!data->has_error) {
 447                 *s = str;
 448         }
 449         return !data->has_error;
 450 }
 451
 452 /* read a octet string blob */
 453 bool asn1_read_OctetString(ASN1_DATA *data, DATA_BLOB *blob)
 454 {
 455         int len;
 456         ZERO_STRUCTP(blob);
 457         if (!asn1_start_tag(data, ASN1_OCTET_STRING)) return False;
 458         len = asn1_tag_remaining(data);
 459         if (len < 0) {
 460                 data->has_error = True;
 461                 return False;
 462         }
 463         *blob = data_blob(NULL, len);
 464         asn1_read(data, blob->data, len);
 465         asn1_end_tag(data);
 466         return !data->has_error;
 467 }
 468
 469 /* read an interger */
 470 bool asn1_read_Integer(ASN1_DATA *data, int *i)
 471 {
 472         uint8 b;
 473         *i = 0;
 474
 475         if (!asn1_start_tag(data, ASN1_INTEGER)) return False;
 476         while (asn1_tag_remaining(data)>0) {
 477                 asn1_read_uint8(data, &b);
 478                 *i = (*i << 8) + b;
 479         }
 480         return asn1_end_tag(data);
 481
 482 }
 483
 484 /* check a enumarted value is correct */
 485 bool asn1_check_enumerated(ASN1_DATA *data, int v)
 486 {
 487         uint8 b;
 488         if (!asn1_start_tag(data, ASN1_ENUMERATED)) return False;
 489         asn1_read_uint8(data, &b);
 490         asn1_end_tag(data);
 491
 492         if (v != b)
 493                 data->has_error = False;
 494
 495         return !data->has_error;
 496 }
 497
 498 /* write an enumarted value to the stream */
 499 bool asn1_write_enumerated(ASN1_DATA *data, uint8 v)
 500 {
 501         if (!asn1_push_tag(data, ASN1_ENUMERATED)) return False;
 502         asn1_write_uint8(data, v);
 503         asn1_pop_tag(data);
 504         return !data->has_error;
 505 }