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)
 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);
 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 challenge packet given two security blobs
 391   The second challenge is optional
 392 */
 393 BOOL spnego_gen_challenge(DATA_BLOB *blob,
 394                           DATA_BLOB *chal1, DATA_BLOB *chal2)
 395 {
 396         ASN1_DATA data;
 397
 398         ZERO_STRUCT(data);
 399
 400         asn1_push_tag(&data,ASN1_CONTEXT(1));
 401         asn1_push_tag(&data,ASN1_SEQUENCE(0));
 402
 403         asn1_push_tag(&data,ASN1_CONTEXT(0));
 404         asn1_write_enumerated(&data,1);
 405         asn1_pop_tag(&data);
 406
 407         asn1_push_tag(&data,ASN1_CONTEXT(1));
 408         asn1_write_OID(&data, OID_NTLMSSP);
 409         asn1_pop_tag(&data);
 410
 411         asn1_push_tag(&data,ASN1_CONTEXT(2));
 412         asn1_write_OctetString(&data, chal1->data, chal1->length);
 413         asn1_pop_tag(&data);
 414
 415         /* the second challenge is optional (XP doesn't send it) */
 416         if (chal2) {
 417                 asn1_push_tag(&data,ASN1_CONTEXT(3));
 418                 asn1_write_OctetString(&data, chal2->data, chal2->length);
 419                 asn1_pop_tag(&data);
 420         }
 421
 422         asn1_pop_tag(&data);
 423         asn1_pop_tag(&data);
 424
 425         if (data.has_error) {
 426                 return False;
 427         }
 428
 429         *blob = data_blob(data.data, data.length);
 430         asn1_free(&data);
 431         return True;
 432 }
 433
 434 /*
 435  generate a SPNEGO NTLMSSP auth packet. This will contain the encrypted passwords
 436 */
 437 DATA_BLOB spnego_gen_auth(DATA_BLOB blob)
 438 {
 439         ASN1_DATA data;
 440         DATA_BLOB ret;
 441
 442         memset(&data, 0, sizeof(data));
 443
 444         asn1_push_tag(&data, ASN1_CONTEXT(1));
 445         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 446         asn1_push_tag(&data, ASN1_CONTEXT(2));
 447         asn1_write_OctetString(&data,blob.data,blob.length);
 448         asn1_pop_tag(&data);
 449         asn1_pop_tag(&data);
 450         asn1_pop_tag(&data);
 451
 452         ret = data_blob(data.data, data.length);
 453
 454         asn1_free(&data);
 455
 456         return ret;
 457 }
 458
 459 /*
 460  parse a SPNEGO NTLMSSP auth packet. This contains the encrypted passwords
 461 */
 462 BOOL spnego_parse_auth(DATA_BLOB blob, DATA_BLOB *auth)
 463 {
 464         ASN1_DATA data;
 465
 466         asn1_load(&data, blob);
 467         asn1_start_tag(&data, ASN1_CONTEXT(1));
 468         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 469         asn1_start_tag(&data, ASN1_CONTEXT(2));
 470         asn1_read_OctetString(&data,auth);
 471         asn1_end_tag(&data);
 472         asn1_end_tag(&data);
 473         asn1_end_tag(&data);
 474
 475         if (data.has_error) {
 476                 DEBUG(3,("spnego_parse_auth failed at %d\n", (int)data.ofs));
 477                 asn1_free(&data);
 478                 return False;
 479         }
 480
 481         asn1_free(&data);
 482         return True;
 483 }
 484
 485 /*
 486   generate a minimal SPNEGO NTLMSSP response packet.  Doesn't contain much.
 487 */
 488 DATA_BLOB spnego_gen_auth_response(void)
 489 {
 490         ASN1_DATA data;
 491         DATA_BLOB ret;
 492
 493         memset(&data, 0, sizeof(data));
 494
 495         asn1_push_tag(&data, ASN1_CONTEXT(1));
 496         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 497         asn1_push_tag(&data, ASN1_CONTEXT(0));
 498         asn1_write_enumerated(&data, 0);
 499         asn1_pop_tag(&data);
 500         asn1_pop_tag(&data);
 501         asn1_pop_tag(&data);
 502
 503         ret = data_blob(data.data, data.length);
 504         asn1_free(&data);
 505         return ret;
 506 }
 507
 508 /*
 509   this is a tiny msrpc packet generator. I am only using this to
 510   avoid tying this code to a particular varient of our rpc code. This
 511   generator is not general enough for all our rpc needs, its just
 512   enough for the spnego/ntlmssp code
 513
 514   format specifiers are:
 515
 516   U = unicode string (input is unix string)
 517   a = address (1 byte type, 1 byte length, unicode string, all inline)
 518   A = ASCII string (pointer + length) Actually same as B
 519   B = data blob (pointer + length)
 520   b = data blob in header (pointer + length)
 521   D
 522   d = word (4 bytes)
 523   C = constant ascii string
 524  */
 525 BOOL msrpc_gen(DATA_BLOB *blob,
 526                const char *format, ...)
 527 {
 528         int i, n;
 529         va_list ap;
 530         char *s;
 531         uint8 *b;
 532         int head_size=0, data_size=0;
 533         int head_ofs, data_ofs;
 534
 535         /* first scan the format to work out the header and body size */
 536         va_start(ap, format);
 537         for (i=0; format[i]; i++) {
 538                 switch (format[i]) {
 539                 case 'U':
 540                         s = va_arg(ap, char *);
 541                         head_size += 8;
 542                         data_size += str_charnum(s) * 2;
 543                         break;
 544                 case 'a':
 545                         n = va_arg(ap, int);
 546                         s = va_arg(ap, char *);
 547                         data_size += (str_charnum(s) * 2) + 4;
 548                         break;
 549                 case 'A':
 550                 case 'B':
 551                         b = va_arg(ap, uint8 *);
 552                         head_size += 8;
 553                         data_size += va_arg(ap, int);
 554                         break;
 555                 case 'b':
 556                         b = va_arg(ap, uint8 *);
 557                         head_size += va_arg(ap, int);
 558                         break;
 559                 case 'd':
 560                         n = va_arg(ap, int);
 561                         head_size += 4;
 562                         break;
 563                 case 'C':
 564                         s = va_arg(ap, char *);
 565                         head_size += str_charnum(s) + 1;
 566                         break;
 567                 }
 568         }
 569         va_end(ap);
 570
 571         /* allocate the space, then scan the format again to fill in the values */
 572         *blob = data_blob(NULL, head_size + data_size);
 573
 574         head_ofs = 0;
 575         data_ofs = head_size;
 576
 577         va_start(ap, format);
 578         for (i=0; format[i]; i++) {
 579                 switch (format[i]) {
 580                 case 'U':
 581                         s = va_arg(ap, char *);
 582                         n = str_charnum(s);
 583                         SSVAL(blob->data, head_ofs, n*2); head_ofs += 2;
 584                         SSVAL(blob->data, head_ofs, n*2); head_ofs += 2;
 585                         SIVAL(blob->data, head_ofs, data_ofs); head_ofs += 4;
 586                         push_string(NULL, blob->data+data_ofs, s, n*2, STR_UNICODE|STR_NOALIGN);
 587                         data_ofs += n*2;
 588                         break;
 589                 case 'a':
 590                         n = va_arg(ap, int);
 591                         SSVAL(blob->data, data_ofs, n); data_ofs += 2;
 592                         s = va_arg(ap, char *);
 593                         n = str_charnum(s);
 594                         SSVAL(blob->data, data_ofs, n*2); data_ofs += 2;
 595                         if (0 < n) {
 596                                 push_string(NULL, blob->data+data_ofs, s, n*2,
 597                                             STR_UNICODE|STR_NOALIGN);
 598                         }
 599                         data_ofs += n*2;
 600                         break;
 601
 602                 case 'A':
 603                 case 'B':
 604                         b = va_arg(ap, uint8 *);
 605                         n = va_arg(ap, int);
 606                         SSVAL(blob->data, head_ofs, n); head_ofs += 2;
 607                         SSVAL(blob->data, head_ofs, n); head_ofs += 2;
 608                         SIVAL(blob->data, head_ofs, data_ofs); head_ofs += 4;
 609                         memcpy(blob->data+data_ofs, b, n);
 610                         data_ofs += n;
 611                         break;
 612                 case 'd':
 613                         n = va_arg(ap, int);
 614                         SIVAL(blob->data, head_ofs, n); head_ofs += 4;
 615                         break;
 616                 case 'b':
 617                         b = va_arg(ap, uint8 *);
 618                         n = va_arg(ap, int);
 619                         memcpy(blob->data + head_ofs, b, n);
 620                         head_ofs += n;
 621                         break;
 622                 case 'C':
 623                         s = va_arg(ap, char *);
 624                         head_ofs += push_string(NULL, blob->data+head_ofs, s, -1,
 625                                                 STR_ASCII|STR_TERMINATE);
 626                         break;
 627                 }
 628         }
 629         va_end(ap);
 630
 631         return True;
 632 }
 633
 634
 635 /*
 636   this is a tiny msrpc packet parser. This the the partner of msrpc_gen
 637
 638   format specifiers are:
 639
 640   U = unicode string (output is unix string)
 641   A = ascii string
 642   B = data blob
 643   b = data blob in header
 644   d = word (4 bytes)
 645   C = constant ascii string
 646  */
 647 BOOL msrpc_parse(DATA_BLOB *blob,
 648                  const char *format, ...)
 649 {
 650         int i;
 651         va_list ap;
 652         char **ps, *s;
 653         DATA_BLOB *b;
 654         int head_ofs = 0;
 655         uint16 len1, len2;
 656         uint32 ptr;
 657         uint32 *v;
 658         pstring p;
 659
 660         va_start(ap, format);
 661         for (i=0; format[i]; i++) {
 662                 switch (format[i]) {
 663                 case 'U':
 664                         len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
 665                         len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
 666                         ptr =  IVAL(blob->data, head_ofs); head_ofs += 4;
 667                         /* make sure its in the right format - be strict */
 668                         if (len1 != len2 || (len1&1) || ptr + len1 > blob->length) {
 669                                 return False;
 670                         }
 671                         ps = va_arg(ap, char **);
 672                         pull_string(NULL, p, blob->data + ptr, -1, len1,
 673                                     STR_UNICODE|STR_NOALIGN);
 674                         (*ps) = strdup(p);
 675                         break;
 676                 case 'A':
 677                         len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
 678                         len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
 679                         ptr =  IVAL(blob->data, head_ofs); head_ofs += 4;
 680
 681                         /* make sure its in the right format - be strict */
 682                         if (len1 != len2 || ptr + len1 > blob->length) {
 683                                 return False;
 684                         }
 685                         ps = va_arg(ap, char **);
 686                         if (0 < len1) {
 687                                 pull_string(NULL, p, blob->data + ptr, -1,
 688                                             len1, STR_ASCII|STR_NOALIGN);
 689                                 (*ps) = strdup(p);
 690                         } else {
 691                                 (*ps) = NULL;
 692                         }
 693                         break;
 694                 case 'B':
 695                         len1 = SVAL(blob->data, head_ofs); head_ofs += 2;
 696                         len2 = SVAL(blob->data, head_ofs); head_ofs += 2;
 697                         ptr =  IVAL(blob->data, head_ofs); head_ofs += 4;
 698                         /* make sure its in the right format - be strict */
 699                         if (len1 != len2 || ptr + len1 > blob->length) {
 700                                 return False;
 701                         }
 702                         b = (DATA_BLOB *)va_arg(ap, void *);
 703                         *b = data_blob(blob->data + ptr, len1);
 704                         break;
 705                 case 'b':
 706                         b = (DATA_BLOB *)va_arg(ap, void *);
 707                         len1 = va_arg(ap, unsigned);
 708                         *b = data_blob(blob->data + head_ofs, len1);
 709                         head_ofs += len1;
 710                         break;
 711                 case 'd':
 712                         v = va_arg(ap, uint32 *);
 713                         *v = IVAL(blob->data, head_ofs); head_ofs += 4;
 714                         break;
 715                 case 'C':
 716                         s = va_arg(ap, char *);
 717                         head_ofs += pull_string(NULL, p, blob->data+head_ofs, -1,
 718                                                 blob->length - head_ofs,
 719                                                 STR_ASCII|STR_TERMINATE);
 720                         if (strcmp(s, p) != 0) {
 721                                 return False;
 722                         }
 723                         break;
 724                 }
 725         }
 726         va_end(ap);
 727
 728         return True;
 729 }
 730
 731 /**
 732  * Print out the NTLMSSP flags for debugging
 733  */
 734
 735 void debug_ntlmssp_flags(uint32 neg_flags)
 736 {
 737         DEBUG(3,("Got NTLMSSP neg_flags=0x%08x\n", neg_flags));
 738
 739         if (neg_flags & NTLMSSP_NEGOTIATE_UNICODE)
 740                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_UNICODE\n"));
 741         if (neg_flags & NTLMSSP_NEGOTIATE_OEM)
 742                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_OEM\n"));
 743         if (neg_flags & NTLMSSP_REQUEST_TARGET)
 744                 DEBUGADD(4, ("  NTLMSSP_REQUEST_TARGET\n"));
 745         if (neg_flags & NTLMSSP_NEGOTIATE_SIGN)
 746                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_SIGN\n"));
 747         if (neg_flags & NTLMSSP_NEGOTIATE_SEAL)
 748                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_SEAL\n"));
 749         if (neg_flags & NTLMSSP_NEGOTIATE_LM_KEY)
 750                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_LM_KEY\n"));
 751         if (neg_flags & NTLMSSP_NEGOTIATE_NETWARE)
 752                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NETWARE\n"));
 753         if (neg_flags & NTLMSSP_NEGOTIATE_NTLM)
 754                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NTLM\n"));
 755         if (neg_flags & NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED)
 756                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_DOMAIN_SUPPLIED\n"));
 757         if (neg_flags & NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED)
 758                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED\n"));
 759         if (neg_flags & NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL)
 760                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL\n"));
 761         if (neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN)
 762                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_ALWAYS_SIGN\n"));
 763         if (neg_flags & NTLMSSP_NEGOTIATE_NTLM2)
 764                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NTLM2\n"));
 765         if (neg_flags & NTLMSSP_CHAL_TARGET_INFO)
 766                 DEBUGADD(4, ("  NTLMSSP_CHAL_TARGET_INFO\n"));
 767         if (neg_flags & NTLMSSP_NEGOTIATE_128)
 768                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_128\n"));
 769         if (neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH)
 770                 DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_KEY_EXCH\n"));
 771 }
 772