source3/libsmb/clispnego.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    simple kerberos5/SPNEGO routines
   4    Copyright (C) Andrew Tridgell 2001
   5    Copyright (C) Jim McDonough   2002
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /*
  25   generate a negTokenInit packet given a GUID, a list of supported
  26   OIDs (the mechanisms) and a principal name string
  27 */
  28 DATA_BLOB spnego_gen_negTokenInit(uint8 guid[16],
  29                                   const char *OIDs[],
  30                                   const char *principal)
  31 {
  32         int i;
  33         ASN1_DATA data;
  34         DATA_BLOB ret;
  35
  36         memset(&data, 0, sizeof(data));
  37
  38         asn1_write(&data, guid, 16);
  39         asn1_push_tag(&data,ASN1_APPLICATION(0));
  40         asn1_write_OID(&data,OID_SPNEGO);
  41         asn1_push_tag(&data,ASN1_CONTEXT(0));
  42         asn1_push_tag(&data,ASN1_SEQUENCE(0));
  43
  44         asn1_push_tag(&data,ASN1_CONTEXT(0));
  45         asn1_push_tag(&data,ASN1_SEQUENCE(0));
  46         for (i=0; OIDs[i]; i++) {
  47                 asn1_write_OID(&data,OIDs[i]);
  48         }
  49         asn1_pop_tag(&data);
  50         asn1_pop_tag(&data);
  51
  52         asn1_push_tag(&data, ASN1_CONTEXT(3));
  53         asn1_push_tag(&data, ASN1_SEQUENCE(0));
  54         asn1_push_tag(&data, ASN1_CONTEXT(0));
  55         asn1_write_GeneralString(&data,principal);
  56         asn1_pop_tag(&data);
  57         asn1_pop_tag(&data);
  58         asn1_pop_tag(&data);
  59
  60         asn1_pop_tag(&data);
  61         asn1_pop_tag(&data);
  62
  63         asn1_pop_tag(&data);
  64
  65         if (data.has_error) {
  66                 DEBUG(1,("Failed to build negTokenInit at offset %d\n", (int)data.ofs));
  67                 asn1_free(&data);
  68         }
  69
  70         ret = data_blob(data.data, data.length);
  71         asn1_free(&data);
  72
  73         return ret;
  74 }
  75
  76 /*
  77   Generate a negTokenInit as used by the client side ... It has a mechType
  78   (OID), and a mechToken (a security blob) ...
  79
  80   Really, we need to break out the NTLMSSP stuff as well, because it could be
  81   raw in the packets!
  82 */
  83 DATA_BLOB gen_negTokenInit(const char *OID, DATA_BLOB blob)
  84 {
  85         ASN1_DATA data;
  86         DATA_BLOB ret;
  87
  88         memset(&data, 0, sizeof(data));
  89
  90         asn1_push_tag(&data, ASN1_APPLICATION(0));
  91         asn1_write_OID(&data,OID_SPNEGO);
  92         asn1_push_tag(&data, ASN1_CONTEXT(0));
  93         asn1_push_tag(&data, ASN1_SEQUENCE(0));
  94
  95         asn1_push_tag(&data, ASN1_CONTEXT(0));
  96         asn1_push_tag(&data, ASN1_SEQUENCE(0));
  97         asn1_write_OID(&data, OID);
  98         asn1_pop_tag(&data);
  99         asn1_pop_tag(&data);
 100
 101         asn1_push_tag(&data, ASN1_CONTEXT(2));
 102         asn1_write_OctetString(&data,blob.data,blob.length);
 103         asn1_pop_tag(&data);
 104
 105         asn1_pop_tag(&data);
 106         asn1_pop_tag(&data);
 107
 108         asn1_pop_tag(&data);
 109
 110         if (data.has_error) {
 111                 DEBUG(1,("Failed to build negTokenInit at offset %d\n", (int)data.ofs));
 112                 asn1_free(&data);
 113         }
 114
 115         ret = data_blob(data.data, data.length);
 116         asn1_free(&data);
 117
 118         return ret;
 119 }
 120
 121 /*
 122   parse a negTokenInit packet giving a GUID, a list of supported
 123   OIDs (the mechanisms) and a principal name string
 124 */
 125 BOOL spnego_parse_negTokenInit(DATA_BLOB blob,
 126                                char *OIDs[ASN1_MAX_OIDS],
 127                                char **principal)
 128 {
 129         int i;
 130         BOOL ret;
 131         ASN1_DATA data;
 132
 133         asn1_load(&data, blob);
 134
 135         asn1_start_tag(&data,ASN1_APPLICATION(0));
 136         asn1_check_OID(&data,OID_SPNEGO);
 137         asn1_start_tag(&data,ASN1_CONTEXT(0));
 138         asn1_start_tag(&data,ASN1_SEQUENCE(0));
 139
 140         asn1_start_tag(&data,ASN1_CONTEXT(0));
 141         asn1_start_tag(&data,ASN1_SEQUENCE(0));
 142         for (i=0; asn1_tag_remaining(&data) > 0 && i < ASN1_MAX_OIDS; i++) {
 143                 char *oid = NULL;
 144                 asn1_read_OID(&data,&oid);
 145                 OIDs[i] = oid;
 146         }
 147         OIDs[i] = NULL;
 148         asn1_end_tag(&data);
 149         asn1_end_tag(&data);
 150
 151         asn1_start_tag(&data, ASN1_CONTEXT(3));
 152         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 153         asn1_start_tag(&data, ASN1_CONTEXT(0));
 154         asn1_read_GeneralString(&data,principal);
 155         asn1_end_tag(&data);
 156         asn1_end_tag(&data);
 157         asn1_end_tag(&data);
 158
 159         asn1_end_tag(&data);
 160         asn1_end_tag(&data);
 161
 162         asn1_end_tag(&data);
 163
 164         ret = !data.has_error;
 165         asn1_free(&data);
 166         return ret;
 167 }
 168
 169
 170 /*
 171   generate a negTokenTarg packet given a list of OIDs and a security blob
 172 */
 173 DATA_BLOB gen_negTokenTarg(const char *OIDs[], DATA_BLOB blob)
 174 {
 175         int i;
 176         ASN1_DATA data;
 177         DATA_BLOB ret;
 178
 179         memset(&data, 0, sizeof(data));
 180
 181         asn1_push_tag(&data, ASN1_APPLICATION(0));
 182         asn1_write_OID(&data,OID_SPNEGO);
 183         asn1_push_tag(&data, ASN1_CONTEXT(0));
 184         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 185
 186         asn1_push_tag(&data, ASN1_CONTEXT(0));
 187         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 188         for (i=0; OIDs[i]; i++) {
 189                 asn1_write_OID(&data,OIDs[i]);
 190         }
 191         asn1_pop_tag(&data);
 192         asn1_pop_tag(&data);
 193
 194         asn1_push_tag(&data, ASN1_CONTEXT(2));
 195         asn1_write_OctetString(&data,blob.data,blob.length);
 196         asn1_pop_tag(&data);
 197
 198         asn1_pop_tag(&data);
 199         asn1_pop_tag(&data);
 200
 201         asn1_pop_tag(&data);
 202
 203         if (data.has_error) {
 204                 DEBUG(1,("Failed to build negTokenTarg at offset %d\n", (int)data.ofs));
 205                 asn1_free(&data);
 206         }
 207
 208         ret = data_blob(data.data, data.length);
 209         asn1_free(&data);
 210
 211         return ret;
 212 }
 213
 214
 215 /*
 216   parse a negTokenTarg packet giving a list of OIDs and a security blob
 217 */
 218 BOOL parse_negTokenTarg(DATA_BLOB blob, char *OIDs[ASN1_MAX_OIDS], DATA_BLOB *secblob)
 219 {
 220         int i;
 221         ASN1_DATA data;
 222
 223         asn1_load(&data, blob);
 224         asn1_start_tag(&data, ASN1_APPLICATION(0));
 225         asn1_check_OID(&data,OID_SPNEGO);
 226         asn1_start_tag(&data, ASN1_CONTEXT(0));
 227         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 228
 229         asn1_start_tag(&data, ASN1_CONTEXT(0));
 230         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 231         for (i=0; asn1_tag_remaining(&data) > 0 && i < ASN1_MAX_OIDS; i++) {
 232                 char *oid = NULL;
 233                 asn1_read_OID(&data,&oid);
 234                 OIDs[i] = oid;
 235         }
 236         OIDs[i] = NULL;
 237         asn1_end_tag(&data);
 238         asn1_end_tag(&data);
 239
 240         asn1_start_tag(&data, ASN1_CONTEXT(2));
 241         asn1_read_OctetString(&data,secblob);
 242         asn1_end_tag(&data);
 243
 244         asn1_end_tag(&data);
 245         asn1_end_tag(&data);
 246
 247         asn1_end_tag(&data);
 248
 249         if (data.has_error) {
 250                 DEBUG(1,("Failed to parse negTokenTarg at offset %d\n", (int)data.ofs));
 251                 asn1_free(&data);
 252                 return False;
 253         }
 254
 255         asn1_free(&data);
 256         return True;
 257 }
 258
 259 /*
 260   generate a krb5 GSS-API wrapper packet given a ticket
 261 */
 262 DATA_BLOB spnego_gen_krb5_wrap(DATA_BLOB ticket)
 263 {
 264         ASN1_DATA data;
 265         DATA_BLOB ret;
 266
 267         memset(&data, 0, sizeof(data));
 268
 269         asn1_push_tag(&data, ASN1_APPLICATION(0));
 270         asn1_write_OID(&data, OID_KERBEROS5);
 271         asn1_write_BOOLEAN(&data, 0);
 272         asn1_write(&data, ticket.data, ticket.length);
 273         asn1_pop_tag(&data);
 274
 275         if (data.has_error) {
 276                 DEBUG(1,("Failed to build krb5 wrapper at offset %d\n", (int)data.ofs));
 277                 asn1_free(&data);
 278         }
 279
 280         ret = data_blob(data.data, data.length);
 281         asn1_free(&data);
 282
 283         return ret;
 284 }
 285
 286 /*
 287   parse a krb5 GSS-API wrapper packet giving a ticket
 288 */
 289 BOOL spnego_parse_krb5_wrap(DATA_BLOB blob, DATA_BLOB *ticket)
 290 {
 291         BOOL ret;
 292         ASN1_DATA data;
 293         int data_remaining;
 294
 295         asn1_load(&data, blob);
 296         asn1_start_tag(&data, ASN1_APPLICATION(0));
 297         asn1_check_OID(&data, OID_KERBEROS5);
 298         asn1_check_BOOLEAN(&data, 0);
 299
 300         data_remaining = asn1_tag_remaining(&data);
 301
 302         if (data_remaining < 1) {
 303                 data.has_error = True;
 304         } else {
 305
 306                 *ticket = data_blob(data.data, data_remaining);
 307                 asn1_read(&data, ticket->data, ticket->length);
 308         }
 309
 310         asn1_end_tag(&data);
 311
 312         ret = !data.has_error;
 313
 314         asn1_free(&data);
 315
 316         return ret;
 317 }
 318
 319
 320 /*
 321    generate a SPNEGO negTokenTarg packet, ready for a EXTENDED_SECURITY
 322    kerberos session setup
 323 */
 324 DATA_BLOB spnego_gen_negTokenTarg(const char *principal, int time_offset)
 325 {
 326         DATA_BLOB tkt, tkt_wrapped, targ;
 327         const char *krb_mechs[] = {OID_KERBEROS5_OLD, OID_NTLMSSP, NULL};
 328
 329         /* get a kerberos ticket for the service */
 330         tkt = krb5_get_ticket(principal, time_offset);
 331
 332         /* wrap that up in a nice GSS-API wrapping */
 333         tkt_wrapped = spnego_gen_krb5_wrap(tkt);
 334
 335         /* and wrap that in a shiny SPNEGO wrapper */
 336         targ = gen_negTokenTarg(krb_mechs, tkt_wrapped);
 337
 338         data_blob_free(&tkt_wrapped);
 339         data_blob_free(&tkt);
 340
 341         return targ;
 342 }
 343
 344
 345 /*
 346   parse a spnego NTLMSSP challenge packet giving two security blobs
 347 */
 348 BOOL spnego_parse_challenge(DATA_BLOB blob,
 349                             DATA_BLOB *chal1, DATA_BLOB *chal2)
 350 {
 351         BOOL ret;
 352         ASN1_DATA data;
 353
 354         ZERO_STRUCTP(chal1);
 355         ZERO_STRUCTP(chal2);
 356
 357         asn1_load(&data, blob);
 358         asn1_start_tag(&data,ASN1_CONTEXT(1));
 359         asn1_start_tag(&data,ASN1_SEQUENCE(0));
 360
 361         asn1_start_tag(&data,ASN1_CONTEXT(0));
 362         asn1_check_enumerated(&data,1);
 363         asn1_end_tag(&data);
 364
 365         asn1_start_tag(&data,ASN1_CONTEXT(1));
 366         asn1_check_OID(&data, OID_NTLMSSP);
 367         asn1_end_tag(&data);
 368
 369         asn1_start_tag(&data,ASN1_CONTEXT(2));
 370         asn1_read_OctetString(&data, chal1);
 371         asn1_end_tag(&data);
 372
 373         /* the second challenge is optional (XP doesn't send it) */
 374         if (asn1_tag_remaining(&data)) {
 375                 asn1_start_tag(&data,ASN1_CONTEXT(3));
 376                 asn1_read_OctetString(&data, chal2);
 377                 asn1_end_tag(&data);
 378         }
 379
 380         asn1_end_tag(&data);
 381         asn1_end_tag(&data);
 382
 383         ret = !data.has_error;
 384         asn1_free(&data);
 385         return ret;
 386 }
 387
 388
 389 /*
 390  generate a SPNEGO NTLMSSP auth packet. This will contain the encrypted passwords
 391 */
 392 DATA_BLOB spnego_gen_auth(DATA_BLOB blob)
 393 {
 394         ASN1_DATA data;
 395         DATA_BLOB ret;
 396
 397         memset(&data, 0, sizeof(data));
 398
 399         asn1_push_tag(&data, ASN1_CONTEXT(1));
 400         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 401         asn1_push_tag(&data, ASN1_CONTEXT(2));
 402         asn1_write_OctetString(&data,blob.data,blob.length);
 403         asn1_pop_tag(&data);
 404         asn1_pop_tag(&data);
 405         asn1_pop_tag(&data);
 406
 407         ret = data_blob(data.data, data.length);
 408
 409         asn1_free(&data);
 410
 411         return ret;
 412 }
 413
 414 /*
 415  parse a SPNEGO NTLMSSP auth packet. This contains the encrypted passwords
 416 */
 417 BOOL spnego_parse_auth(DATA_BLOB blob, DATA_BLOB *auth)
 418 {
 419         ASN1_DATA data;
 420
 421         asn1_load(&data, blob);
 422         asn1_start_tag(&data, ASN1_CONTEXT(1));
 423         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 424         asn1_start_tag(&data, ASN1_CONTEXT(2));
 425         asn1_read_OctetString(&data,auth);
 426         asn1_end_tag(&data);
 427         asn1_end_tag(&data);
 428         asn1_end_tag(&data);
 429
 430         if (data.has_error) {
 431                 DEBUG(3,("spnego_parse_auth failed at %d\n", (int)data.ofs));
 432                 asn1_free(&data);
 433                 return False;
 434         }
 435
 436         asn1_free(&data);
 437         return True;
 438 }
 439
 440 /*
 441   generate a minimal SPNEGO NTLMSSP response packet.  Doesn't contain much.
 442 */
 443 DATA_BLOB spnego_gen_auth_response(DATA_BLOB *ntlmssp_reply, NTSTATUS nt_status)
 444 {
 445         ASN1_DATA data;
 446         DATA_BLOB ret;
 447         uint8 negResult;
 448
 449         if (NT_STATUS_IS_OK(nt_status)) {
 450                 negResult = SPNEGO_NEG_RESULT_ACCEPT;
 451         } else if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 452                 negResult = SPNEGO_NEG_RESULT_INCOMPLETE;
 453         } else {
 454                 negResult = SPNEGO_NEG_RESULT_REJECT;
 455         }
 456
 457         ZERO_STRUCT(data);
 458
 459         asn1_push_tag(&data, ASN1_CONTEXT(1));
 460         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 461         asn1_push_tag(&data, ASN1_CONTEXT(0));
 462         asn1_write_enumerated(&data, negResult);
 463         asn1_pop_tag(&data);
 464         if (negResult == SPNEGO_NEG_RESULT_INCOMPLETE) {
 465                 asn1_push_tag(&data,ASN1_CONTEXT(1));
 466                 asn1_write_OID(&data, OID_NTLMSSP);
 467                 asn1_pop_tag(&data);
 468
 469                 asn1_push_tag(&data,ASN1_CONTEXT(2));
 470                 asn1_write_OctetString(&data, ntlmssp_reply->data, ntlmssp_reply->length);
 471                 asn1_pop_tag(&data);
 472         }
 473
 474         asn1_pop_tag(&data);
 475         asn1_pop_tag(&data);
 476
 477         ret = data_blob(data.data, data.length);
 478         asn1_free(&data);
 479         return ret;
 480 }
 481
 482 /*
 483   this is a tiny msrpc packet generator. I am only using this to
 484   avoid tying this code to a particular varient of our rpc code. This
 485   generator is not general enough for all our rpc needs, its just
 486   enough for the spnego/ntlmssp code
 487
 488   format specifiers are:
 489
 490   U = unicode string (input is unix string)
 491   a = address (input is BOOL unicode, char *unix_string)
 492       (1 byte type, 1 byte length, unicode/ASCII string, all inline)
 493   A = ASCII string (input is unix string)
 494   B = data blob (pointer + length)
 495   b = data blob in header (pointer + length)
 496   D
 497   d = word (4 bytes)
 498   C = constant ascii string
 499  */
 500 BOOL msrpc_gen(DATA_BLOB *blob,
 501                const char *format, ...)
 502 {
 503         int i, n;
 504         va_list ap;
 505         char *s;
 506         uint8 *b;
 507         int head_size=0, data_size=0;
 508         int head_ofs, data_ofs;
 509         BOOL unicode;
 510
 511         /* first scan the format to work out the header and body size */
 512         va_start(ap, format);
 513         for (i=0; format[i]; i++) {
 514                 switch (format[i]) {
 515                 case 'U':
 516                         s = va_arg(ap, char *);
 517                         head_size += 8;
 518                         data_size += str_charnum(s) * 2;
 519                         break;
 520                 case 'A':
 521                         s = va_arg(ap, char *);
 522                         head_size += 8;
 523                         data_size += str_ascii_charnum(s);
 524                         break;
 525                 case 'a':
 526                         unicode = va_arg(ap, BOOL);
 527                         n = va_arg(ap, int);
 528                         s = va_arg(ap, char *);
 529                         if (unicode) {
 530                                 data_size += (str_charnum(s) * 2) + 4;
 531                         } else {
 532                                 data_size += (str_ascii_charnum(s)) + 4;
 533                         }
 534                         break;
 535                 case 'B':
 536                         b = va_arg(ap, uint8 *);
 537                         head_size += 8;
 538                         data_size += va_arg(ap, int);
 539                         break;
 540                 case 'b':
 541                         b = va_arg(ap, uint8 *);
 542                         head_size += va_arg(ap, int);
 543                         break;
 544                 case 'd':
 545                         n = va_arg(ap, int);
 546                         head_size += 4;
 547                         break;
 548                 case 'C':
 549                         s = va_arg(ap, char *);
 550                         head_size += str_charnum(s) + 1;
 551                         break;
 552                 }
 553         }
 554         va_end(ap);
 555
 556         /* allocate the space, then scan the format again to fill in the values */
 557         *blob = data_blob(NULL, head_size + data_size);
 558
 559         head_ofs = 0;
 560         data_ofs = head_size;
 561
 562         va_start(ap, format);
 563         for (i=0; format[i]; i++) {
 564                 switch (format[i]) {
 565                 case 'U':
 566                         s = va_arg(ap, char *);
 567                         n = str_charnum(s);
 568                         SSVAL(blob->data, head_ofs, n*2); head_ofs += 2;
 569                         SSVAL(blob->data, head_ofs, n*2); head_ofs += 2;
 570                         SIVAL(blob->data, head_ofs, data_ofs); head_ofs += 4;
 571                         push_string(NULL, blob->data+data_ofs, s, n*2, STR_UNICODE|STR_NOALIGN);
 572                         data_ofs += n*2;
 573                         break;
 574                 case 'A':
 575                         s = va_arg(ap, char *);
 576                         n = str_ascii_charnum(s);
 577                         SSVAL(blob->data, head_ofs, n); head_ofs += 2;
 578                         SSVAL(blob->data, head_ofs, n); head_ofs += 2;
 579                         SIVAL(blob->data, head_ofs, data_ofs); head_ofs += 4;
 580                         push_string(NULL, blob->data+data_ofs, s, n, STR_ASCII|STR_NOALIGN);
 581                         data_ofs += n;
 582                         break;
 583                 case 'a':
 584                         unicode = va_arg(ap, BOOL);
 585                         n = va_arg(ap, int);
 586                         SSVAL(blob->data, data_ofs, n); data_ofs += 2;
 587                         s = va_arg(ap, char *);
 588                         if (unicode) {
 589                                 n = str_charnum(s);
 590                                 SSVAL(blob->data, data_ofs, n*2); data_ofs += 2;
 591                                 if (0 < n) {
 592                                         push_string(NULL, blob->data+data_ofs, s, n*2,
 593                                                     STR_UNICODE|STR_NOALIGN);
 594                                 }
 595                                 data_ofs += n*2;
 596                         } else {
 597                                 n = str_ascii_charnum(s);
 598                                 SSVAL(blob->data, data_ofs, n); data_ofs += 2;
 599                                 if (0 < n) {
 600                                         push_string(NULL, blob->data+data_ofs, s, n,
 601                                                     STR_ASCII|STR_NOALIGN);
 602                                 }
 603                                 data_ofs += n;
 604                         }
 605                         break;
 606
 607                 case 'B':
 608                         b = va_arg(ap, uint8 *);
 609                         n = va_arg(ap, int);
 610                         SSVAL(blob->data, head_ofs, n); head_ofs += 2;
 611                         SSVAL(blob->data, head_ofs, n); head_ofs += 2;
 612                         SIVAL(blob->data, head_ofs, data_ofs); head_ofs += 4;
 613                         memcpy(blob->data+data_ofs, b, n);
 614                         data_ofs += n;
 615                         break;
 616                 case 'd':
 617                         n = va_arg(ap, int);
 618                         SIVAL(blob->data, head_ofs, n); head_ofs += 4;
 619                         break;
 620                 case 'b':
 621                         b = va_arg(ap, uint8 *);
 622                         n = va_arg(ap, int);
 623                         memcpy(blob->data + head_ofs, b, n);
 624                         head_ofs += n;
 625                         break;
 626                 case 'C':
 627                         s = va_arg(ap, char *);
 628                         head_ofs += push_string(NULL, blob->data+head_ofs, s, -1,
 629                                                 STR_ASCII|STR_TERMINATE);
 630                         break;
 631                 }
 632         }
 633         va_end(ap);
 634
 635         return True;
 636 }
 637
 638
 639 /* a helpful macro to avoid running over the end of our blob */
 640 #define NEED_DATA(amount) \
 641 if (head_ofs + amount > blob->length) { \
 642         return False; \
 643 }
 644
 645 /*
 646   this is a tiny msrpc packet parser. This the the partner of msrpc_gen
 647
 648   format specifiers are:
 649
 650   U = unicode string (output is unix string)
 651   A = ascii string
 652   B = data blob
 653   b = data blob in header
 654   d = word (4 bytes)
 655   C = constant ascii string
 656  */
 657
 658 BOOL msrpc_parse(DATA_BLOB *blob,
 659                  const char *format, ...)
 660 {
 661         int i;
 662         va_list ap;
 663         char **ps, *s;
 664         DATA_BLOB *b;
 665         int head_ofs = 0;
 666         uint16 len1, len2;
 667         uint32 ptr;
 668         uint32 *v;
 669         pstring p;
 670
 671         va_start(ap, format);
 672         for (i=0; format[i]; i++) {
 673                 switch (format[i]) {
 674                 case 'U':
 675                         NEED_DATA(8);
 676                         len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
 677                         len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
 678                         ptr =  IVAL(blob->data, head_ofs); head_ofs += 4;
 679
 680                         /* make sure its in the right format - be strict */
 681                         if (len1 != len2 || ptr + len1 > blob->length) {
 682                                 return False;
 683                         }
 684                         if (len1 & 1) {
 685                                 /* if odd length and unicode */
 686                                 return False;
 687                         }
 688
 689                         ps = va_arg(ap, char **);
 690                         if (0 < len1) {
 691                                 pull_string(NULL, p, blob->data + ptr, sizeof(p),
 692                                             len1,
 693                                             STR_UNICODE|STR_NOALIGN);
 694                                 (*ps) = strdup(p);
 695                         } else {
 696                                 (*ps) = NULL;
 697                         }
 698                         break;
 699                 case 'A':
 700                         NEED_DATA(8);
 701                         len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
 702                         len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
 703                         ptr =  IVAL(blob->data, head_ofs); head_ofs += 4;
 704
 705                         /* make sure its in the right format - be strict */
 706                         if (len1 != len2 || ptr + len1 > blob->length) {
 707                                 return False;
 708                         }
 709
 710                         ps = va_arg(ap, char **);
 711                         if (0 < len1) {
 712                                 pull_string(NULL, p, blob->data + ptr, sizeof(p),
 713                                             len1,
 714                                             STR_ASCII|STR_NOALIGN);
 715                                 (*ps) = strdup(p);
 716                         } else {
 717                                 (*ps) = NULL;
 718                         }
 719                         break;
 720                 case 'B':
 721                         NEED_DATA(8);
 722                         len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
 723                         len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
 724                         ptr =  IVAL(blob->data, head_ofs); head_ofs += 4;
 725                         /* make sure its in the right format - be strict */
 726                         if (len1 != len2 || ptr + len1 > blob->length) {
 727                                 return False;
 728                         }
 729                         b = (DATA_BLOB *)va_arg(ap, void *);
 730                         *b = data_blob(blob->data + ptr, len1);
 731                         break;
 732                 case 'b':
 733                         b = (DATA_BLOB *)va_arg(ap, void *);
 734                         len1 = va_arg(ap, unsigned);
 735                         /* make sure its in the right format - be strict */
 736                         NEED_DATA(len1);
 737                         *b = data_blob(blob->data + head_ofs, len1);
 738                         head_ofs += len1;
 739                         break;
 740                 case 'd':
 741                         v = va_arg(ap, uint32 *);
 742                         NEED_DATA(4);
 743                         *v = IVAL(blob->data, head_ofs); head_ofs += 4;
 744                         break;
 745                 case 'C':
 746                         s = va_arg(ap, char *);
 747                         head_ofs += pull_string(NULL, p, blob->data+head_ofs, sizeof(p),
 748                                                 blob->length - head_ofs,
 749                                                 STR_ASCII|STR_TERMINATE);
 750                         if (strcmp(s, p) != 0) {
 751                                 return False;
 752                         }
 753                         break;
 754                 }
 755         }
 756         va_end(ap);
 757
 758         return True;
 759 }
 760
 761 /**
 762  * Print out the NTLMSSP flags for debugging
 763  */
 764
 765 void debug_ntlmssp_flags(uint32 neg_flags)
 766 {
 767         DEBUG(3,("Got NTLMSSP neg_flags=0x%08x\n", neg_flags));
 768
 769         if (neg_flags & NTLMSSP_NEGOTIATE_UNICODE)
 770                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_UNICODE\n"));
 771         if (neg_flags & NTLMSSP_NEGOTIATE_OEM)
 772                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_OEM\n"));
 773         if (neg_flags & NTLMSSP_REQUEST_TARGET)
 774                 DEBUGADD(4, ("  NTLMSSP_REQUEST_TARGET\n"));
 775         if (neg_flags & NTLMSSP_NEGOTIATE_SIGN)
 776                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_SIGN\n"));
 777         if (neg_flags & NTLMSSP_NEGOTIATE_SEAL)
 778                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_SEAL\n"));
 779         if (neg_flags & NTLMSSP_NEGOTIATE_LM_KEY)
 780                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_LM_KEY\n"));
 781         if (neg_flags & NTLMSSP_NEGOTIATE_NETWARE)
 782                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NETWARE\n"));
 783         if (neg_flags & NTLMSSP_NEGOTIATE_NTLM)
 784                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NTLM\n"));
 785         if (neg_flags & NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED)
 786                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED\n"));
 787         if (neg_flags & NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED)
 788                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED\n"));
 789         if (neg_flags & NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL)
 790                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL\n"));
 791         if (neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN)
 792                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_ALWAYS_SIGN\n"));
 793         if (neg_flags & NTLMSSP_NEGOTIATE_NTLM2)
 794                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NTLM2\n"));
 795         if (neg_flags & NTLMSSP_CHAL_TARGET_INFO)
 796                 DEBUGADD(4, ("  NTLMSSP_CHAL_TARGET_INFO\n"));
 797         if (neg_flags & NTLMSSP_NEGOTIATE_128)
 798                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_128\n"));
 799         if (neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH)
 800                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_KEY_EXCH\n"));
 801 }
 802