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 <jmcd@us.ibm.com> 2002
   6    Copyright (C) Luke Howard     2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 /*
  26   generate a negTokenInit packet given a GUID, a list of supported
  27   OIDs (the mechanisms) and a principal name string
  28 */
  29 DATA_BLOB spnego_gen_negTokenInit(uint8 guid[16],
  30                                   const char *OIDs[],
  31                                   const char *principal)
  32 {
  33         int i;
  34         ASN1_DATA data;
  35         DATA_BLOB ret;
  36
  37         memset(&data, 0, sizeof(data));
  38
  39         asn1_write(&data, guid, 16);
  40         asn1_push_tag(&data,ASN1_APPLICATION(0));
  41         asn1_write_OID(&data,OID_SPNEGO);
  42         asn1_push_tag(&data,ASN1_CONTEXT(0));
  43         asn1_push_tag(&data,ASN1_SEQUENCE(0));
  44
  45         asn1_push_tag(&data,ASN1_CONTEXT(0));
  46         asn1_push_tag(&data,ASN1_SEQUENCE(0));
  47         for (i=0; OIDs[i]; i++) {
  48                 asn1_write_OID(&data,OIDs[i]);
  49         }
  50         asn1_pop_tag(&data);
  51         asn1_pop_tag(&data);
  52
  53         asn1_push_tag(&data, ASN1_CONTEXT(3));
  54         asn1_push_tag(&data, ASN1_SEQUENCE(0));
  55         asn1_push_tag(&data, ASN1_CONTEXT(0));
  56         asn1_write_GeneralString(&data,principal);
  57         asn1_pop_tag(&data);
  58         asn1_pop_tag(&data);
  59         asn1_pop_tag(&data);
  60
  61         asn1_pop_tag(&data);
  62         asn1_pop_tag(&data);
  63
  64         asn1_pop_tag(&data);
  65
  66         if (data.has_error) {
  67                 DEBUG(1,("Failed to build negTokenInit at offset %d\n", (int)data.ofs));
  68                 asn1_free(&data);
  69         }
  70
  71         ret = data_blob(data.data, data.length);
  72         asn1_free(&data);
  73
  74         return ret;
  75 }
  76
  77 /*
  78   Generate a negTokenInit as used by the client side ... It has a mechType
  79   (OID), and a mechToken (a security blob) ...
  80
  81   Really, we need to break out the NTLMSSP stuff as well, because it could be
  82   raw in the packets!
  83 */
  84 DATA_BLOB gen_negTokenInit(const char *OID, DATA_BLOB blob)
  85 {
  86         ASN1_DATA data;
  87         DATA_BLOB ret;
  88
  89         memset(&data, 0, sizeof(data));
  90
  91         asn1_push_tag(&data, ASN1_APPLICATION(0));
  92         asn1_write_OID(&data,OID_SPNEGO);
  93         asn1_push_tag(&data, ASN1_CONTEXT(0));
  94         asn1_push_tag(&data, ASN1_SEQUENCE(0));
  95
  96         asn1_push_tag(&data, ASN1_CONTEXT(0));
  97         asn1_push_tag(&data, ASN1_SEQUENCE(0));
  98         asn1_write_OID(&data, OID);
  99         asn1_pop_tag(&data);
 100         asn1_pop_tag(&data);
 101
 102         asn1_push_tag(&data, ASN1_CONTEXT(2));
 103         asn1_write_OctetString(&data,blob.data,blob.length);
 104         asn1_pop_tag(&data);
 105
 106         asn1_pop_tag(&data);
 107         asn1_pop_tag(&data);
 108
 109         asn1_pop_tag(&data);
 110
 111         if (data.has_error) {
 112                 DEBUG(1,("Failed to build negTokenInit at offset %d\n", (int)data.ofs));
 113                 asn1_free(&data);
 114         }
 115
 116         ret = data_blob(data.data, data.length);
 117         asn1_free(&data);
 118
 119         return ret;
 120 }
 121
 122 /*
 123   parse a negTokenInit packet giving a GUID, a list of supported
 124   OIDs (the mechanisms) and a principal name string
 125 */
 126 BOOL spnego_parse_negTokenInit(DATA_BLOB blob,
 127                                char *OIDs[ASN1_MAX_OIDS],
 128                                char **principal)
 129 {
 130         int i;
 131         BOOL ret;
 132         ASN1_DATA data;
 133
 134         asn1_load(&data, blob);
 135
 136         asn1_start_tag(&data,ASN1_APPLICATION(0));
 137         asn1_check_OID(&data,OID_SPNEGO);
 138         asn1_start_tag(&data,ASN1_CONTEXT(0));
 139         asn1_start_tag(&data,ASN1_SEQUENCE(0));
 140
 141         asn1_start_tag(&data,ASN1_CONTEXT(0));
 142         asn1_start_tag(&data,ASN1_SEQUENCE(0));
 143         for (i=0; asn1_tag_remaining(&data) > 0 && i < ASN1_MAX_OIDS; i++) {
 144                 char *oid = NULL;
 145                 asn1_read_OID(&data,&oid);
 146                 OIDs[i] = oid;
 147         }
 148         OIDs[i] = NULL;
 149         asn1_end_tag(&data);
 150         asn1_end_tag(&data);
 151
 152         asn1_start_tag(&data, ASN1_CONTEXT(3));
 153         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 154         asn1_start_tag(&data, ASN1_CONTEXT(0));
 155         asn1_read_GeneralString(&data,principal);
 156         asn1_end_tag(&data);
 157         asn1_end_tag(&data);
 158         asn1_end_tag(&data);
 159
 160         asn1_end_tag(&data);
 161         asn1_end_tag(&data);
 162
 163         asn1_end_tag(&data);
 164
 165         ret = !data.has_error;
 166         asn1_free(&data);
 167         return ret;
 168 }
 169
 170
 171 /*
 172   generate a negTokenTarg packet given a list of OIDs and a security blob
 173 */
 174 DATA_BLOB gen_negTokenTarg(const char *OIDs[], DATA_BLOB blob)
 175 {
 176         int i;
 177         ASN1_DATA data;
 178         DATA_BLOB ret;
 179
 180         memset(&data, 0, sizeof(data));
 181
 182         asn1_push_tag(&data, ASN1_APPLICATION(0));
 183         asn1_write_OID(&data,OID_SPNEGO);
 184         asn1_push_tag(&data, ASN1_CONTEXT(0));
 185         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 186
 187         asn1_push_tag(&data, ASN1_CONTEXT(0));
 188         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 189         for (i=0; OIDs[i]; i++) {
 190                 asn1_write_OID(&data,OIDs[i]);
 191         }
 192         asn1_pop_tag(&data);
 193         asn1_pop_tag(&data);
 194
 195         asn1_push_tag(&data, ASN1_CONTEXT(2));
 196         asn1_write_OctetString(&data,blob.data,blob.length);
 197         asn1_pop_tag(&data);
 198
 199         asn1_pop_tag(&data);
 200         asn1_pop_tag(&data);
 201
 202         asn1_pop_tag(&data);
 203
 204         if (data.has_error) {
 205                 DEBUG(1,("Failed to build negTokenTarg at offset %d\n", (int)data.ofs));
 206                 asn1_free(&data);
 207         }
 208
 209         ret = data_blob(data.data, data.length);
 210         asn1_free(&data);
 211
 212         return ret;
 213 }
 214
 215
 216 /*
 217   parse a negTokenTarg packet giving a list of OIDs and a security blob
 218 */
 219 BOOL parse_negTokenTarg(DATA_BLOB blob, char *OIDs[ASN1_MAX_OIDS], DATA_BLOB *secblob)
 220 {
 221         int i;
 222         ASN1_DATA data;
 223
 224         asn1_load(&data, blob);
 225         asn1_start_tag(&data, ASN1_APPLICATION(0));
 226         asn1_check_OID(&data,OID_SPNEGO);
 227         asn1_start_tag(&data, ASN1_CONTEXT(0));
 228         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 229
 230         asn1_start_tag(&data, ASN1_CONTEXT(0));
 231         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 232         for (i=0; asn1_tag_remaining(&data) > 0 && i < ASN1_MAX_OIDS; i++) {
 233                 char *oid = NULL;
 234                 asn1_read_OID(&data,&oid);
 235                 OIDs[i] = oid;
 236         }
 237         OIDs[i] = NULL;
 238         asn1_end_tag(&data);
 239         asn1_end_tag(&data);
 240
 241         asn1_start_tag(&data, ASN1_CONTEXT(2));
 242         asn1_read_OctetString(&data,secblob);
 243         asn1_end_tag(&data);
 244
 245         asn1_end_tag(&data);
 246         asn1_end_tag(&data);
 247
 248         asn1_end_tag(&data);
 249
 250         if (data.has_error) {
 251                 DEBUG(1,("Failed to parse negTokenTarg at offset %d\n", (int)data.ofs));
 252                 asn1_free(&data);
 253                 return False;
 254         }
 255
 256         asn1_free(&data);
 257         return True;
 258 }
 259
 260 /*
 261   generate a krb5 GSS-API wrapper packet given a ticket
 262 */
 263 DATA_BLOB spnego_gen_krb5_wrap(DATA_BLOB ticket, const uint8 tok_id[2])
 264 {
 265         ASN1_DATA data;
 266         DATA_BLOB ret;
 267
 268         memset(&data, 0, sizeof(data));
 269
 270         asn1_push_tag(&data, ASN1_APPLICATION(0));
 271         asn1_write_OID(&data, OID_KERBEROS5);
 272
 273         asn1_write(&data, tok_id, 2);
 274         asn1_write(&data, ticket.data, ticket.length);
 275         asn1_pop_tag(&data);
 276
 277         if (data.has_error) {
 278                 DEBUG(1,("Failed to build krb5 wrapper at offset %d\n", (int)data.ofs));
 279                 asn1_free(&data);
 280         }
 281
 282         ret = data_blob(data.data, data.length);
 283         asn1_free(&data);
 284
 285         return ret;
 286 }
 287
 288 /*
 289   parse a krb5 GSS-API wrapper packet giving a ticket
 290 */
 291 BOOL spnego_parse_krb5_wrap(DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
 292 {
 293         BOOL ret;
 294         ASN1_DATA data;
 295         int data_remaining;
 296
 297         asn1_load(&data, blob);
 298         asn1_start_tag(&data, ASN1_APPLICATION(0));
 299         asn1_check_OID(&data, OID_KERBEROS5);
 300
 301         data_remaining = asn1_tag_remaining(&data);
 302
 303         if (data_remaining < 3) {
 304                 data.has_error = True;
 305         } else {
 306                 asn1_read(&data, tok_id, 2);
 307                 data_remaining -= 2;
 308                 *ticket = data_blob(NULL, data_remaining);
 309                 asn1_read(&data, ticket->data, ticket->length);
 310         }
 311
 312         asn1_end_tag(&data);
 313
 314         ret = !data.has_error;
 315
 316         asn1_free(&data);
 317
 318         return ret;
 319 }
 320
 321
 322 /*
 323    generate a SPNEGO negTokenTarg packet, ready for a EXTENDED_SECURITY
 324    kerberos session setup
 325 */
 326 int spnego_gen_negTokenTarg(const char *principal, int time_offset,
 327                             DATA_BLOB *targ,
 328                             DATA_BLOB *session_key_krb5)
 329 {
 330         int retval;
 331         DATA_BLOB tkt, tkt_wrapped;
 332         const char *krb_mechs[] = {OID_KERBEROS5_OLD, OID_NTLMSSP, NULL};
 333
 334         /* get a kerberos ticket for the service and extract the session key */
 335         retval = cli_krb5_get_ticket(principal, time_offset, &tkt, session_key_krb5);
 336
 337         if (retval)
 338                 return retval;
 339
 340         /* wrap that up in a nice GSS-API wrapping */
 341         tkt_wrapped = spnego_gen_krb5_wrap(tkt, TOK_ID_KRB_AP_REQ);
 342
 343         /* and wrap that in a shiny SPNEGO wrapper */
 344         *targ = gen_negTokenTarg(krb_mechs, tkt_wrapped);
 345
 346         data_blob_free(&tkt_wrapped);
 347         data_blob_free(&tkt);
 348
 349         return retval;
 350 }
 351
 352
 353 /*
 354   parse a spnego NTLMSSP challenge packet giving two security blobs
 355 */
 356 BOOL spnego_parse_challenge(const DATA_BLOB blob,
 357                             DATA_BLOB *chal1, DATA_BLOB *chal2)
 358 {
 359         BOOL ret;
 360         ASN1_DATA data;
 361
 362         ZERO_STRUCTP(chal1);
 363         ZERO_STRUCTP(chal2);
 364
 365         asn1_load(&data, blob);
 366         asn1_start_tag(&data,ASN1_CONTEXT(1));
 367         asn1_start_tag(&data,ASN1_SEQUENCE(0));
 368
 369         asn1_start_tag(&data,ASN1_CONTEXT(0));
 370         asn1_check_enumerated(&data,1);
 371         asn1_end_tag(&data);
 372
 373         asn1_start_tag(&data,ASN1_CONTEXT(1));
 374         asn1_check_OID(&data, OID_NTLMSSP);
 375         asn1_end_tag(&data);
 376
 377         asn1_start_tag(&data,ASN1_CONTEXT(2));
 378         asn1_read_OctetString(&data, chal1);
 379         asn1_end_tag(&data);
 380
 381         /* the second challenge is optional (XP doesn't send it) */
 382         if (asn1_tag_remaining(&data)) {
 383                 asn1_start_tag(&data,ASN1_CONTEXT(3));
 384                 asn1_read_OctetString(&data, chal2);
 385                 asn1_end_tag(&data);
 386         }
 387
 388         asn1_end_tag(&data);
 389         asn1_end_tag(&data);
 390
 391         ret = !data.has_error;
 392         asn1_free(&data);
 393         return ret;
 394 }
 395
 396
 397 /*
 398  generate a SPNEGO auth packet. This will contain the encrypted passwords
 399 */
 400 DATA_BLOB spnego_gen_auth(DATA_BLOB blob)
 401 {
 402         ASN1_DATA data;
 403         DATA_BLOB ret;
 404
 405         memset(&data, 0, sizeof(data));
 406
 407         asn1_push_tag(&data, ASN1_CONTEXT(1));
 408         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 409         asn1_push_tag(&data, ASN1_CONTEXT(2));
 410         asn1_write_OctetString(&data,blob.data,blob.length);
 411         asn1_pop_tag(&data);
 412         asn1_pop_tag(&data);
 413         asn1_pop_tag(&data);
 414
 415         ret = data_blob(data.data, data.length);
 416
 417         asn1_free(&data);
 418
 419         return ret;
 420 }
 421
 422 /*
 423  parse a SPNEGO auth packet. This contains the encrypted passwords
 424 */
 425 BOOL spnego_parse_auth(DATA_BLOB blob, DATA_BLOB *auth)
 426 {
 427         ASN1_DATA data;
 428
 429         asn1_load(&data, blob);
 430         asn1_start_tag(&data, ASN1_CONTEXT(1));
 431         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 432         asn1_start_tag(&data, ASN1_CONTEXT(2));
 433         asn1_read_OctetString(&data,auth);
 434         asn1_end_tag(&data);
 435         asn1_end_tag(&data);
 436         asn1_end_tag(&data);
 437
 438         if (data.has_error) {
 439                 DEBUG(3,("spnego_parse_auth failed at %d\n", (int)data.ofs));
 440                 asn1_free(&data);
 441                 return False;
 442         }
 443
 444         asn1_free(&data);
 445         return True;
 446 }
 447
 448 /*
 449   generate a minimal SPNEGO response packet.  Doesn't contain much.
 450 */
 451 DATA_BLOB spnego_gen_auth_response(DATA_BLOB *reply, NTSTATUS nt_status,
 452                                    const char *mechOID)
 453 {
 454         ASN1_DATA data;
 455         DATA_BLOB ret;
 456         uint8 negResult;
 457
 458         if (NT_STATUS_IS_OK(nt_status)) {
 459                 negResult = SPNEGO_NEG_RESULT_ACCEPT;
 460         } else if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 461                 negResult = SPNEGO_NEG_RESULT_INCOMPLETE;
 462         } else {
 463                 negResult = SPNEGO_NEG_RESULT_REJECT;
 464         }
 465
 466         ZERO_STRUCT(data);
 467
 468         asn1_push_tag(&data, ASN1_CONTEXT(1));
 469         asn1_push_tag(&data, ASN1_SEQUENCE(0));
 470         asn1_push_tag(&data, ASN1_CONTEXT(0));
 471         asn1_write_enumerated(&data, negResult);
 472         asn1_pop_tag(&data);
 473
 474         if (reply->data != NULL) {
 475                 asn1_push_tag(&data,ASN1_CONTEXT(1));
 476                 asn1_write_OID(&data, mechOID);
 477                 asn1_pop_tag(&data);
 478
 479                 asn1_push_tag(&data,ASN1_CONTEXT(2));
 480                 asn1_write_OctetString(&data, reply->data, reply->length);
 481                 asn1_pop_tag(&data);
 482         }
 483
 484         asn1_pop_tag(&data);
 485         asn1_pop_tag(&data);
 486
 487         ret = data_blob(data.data, data.length);
 488         asn1_free(&data);
 489         return ret;
 490 }
 491
 492 /*
 493  parse a SPNEGO NTLMSSP auth packet. This contains the encrypted passwords
 494 */
 495 BOOL spnego_parse_auth_response(DATA_BLOB blob, NTSTATUS nt_status,
 496                                 DATA_BLOB *auth)
 497 {
 498         ASN1_DATA data;
 499         uint8 negResult;
 500
 501         if (NT_STATUS_IS_OK(nt_status)) {
 502                 negResult = SPNEGO_NEG_RESULT_ACCEPT;
 503         } else if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 504                 negResult = SPNEGO_NEG_RESULT_INCOMPLETE;
 505         } else {
 506                 negResult = SPNEGO_NEG_RESULT_REJECT;
 507         }
 508
 509         asn1_load(&data, blob);
 510         asn1_start_tag(&data, ASN1_CONTEXT(1));
 511         asn1_start_tag(&data, ASN1_SEQUENCE(0));
 512         asn1_start_tag(&data, ASN1_CONTEXT(0));
 513         asn1_check_enumerated(&data, negResult);
 514         asn1_end_tag(&data);
 515
 516         if (negResult == SPNEGO_NEG_RESULT_INCOMPLETE) {
 517                 asn1_start_tag(&data,ASN1_CONTEXT(1));
 518                 asn1_check_OID(&data, OID_NTLMSSP);
 519                 asn1_end_tag(&data);
 520
 521                 asn1_start_tag(&data,ASN1_CONTEXT(2));
 522                 asn1_read_OctetString(&data, auth);
 523                 asn1_end_tag(&data);
 524         }
 525
 526         asn1_end_tag(&data);
 527         asn1_end_tag(&data);
 528
 529         if (data.has_error) {
 530                 DEBUG(3,("spnego_parse_auth_response failed at %d\n", (int)data.ofs));
 531                 asn1_free(&data);
 532                 data_blob_free(auth);
 533                 return False;
 534         }
 535
 536         asn1_free(&data);
 537         return True;
 538 }
 539