source3/rpc_server/srv_pipe.c

   1 #define OLD_NTDOMAIN 1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1998
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
   8  *  Copyright (C) Paul Ashton                  1997-1998.
   9  *  Copyright (C) Jeremy Allison                    1999.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 /*  this module apparently provides an implementation of DCE/RPC over a
  27  *  named pipe (IPC$ connection using SMBtrans).  details of DCE/RPC
  28  *  documentation are available (in on-line form) from the X-Open group.
  29  *
  30  *  this module should provide a level of abstraction between SMB
  31  *  and DCE/RPC, while minimising the amount of mallocs, unnecessary
  32  *  data copies, and network traffic.
  33  *
  34  *  in this version, which takes a "let's learn what's going on and
  35  *  get something running" approach, there is additional network
  36  *  traffic generated, but the code should be easier to understand...
  37  *
  38  *  ... if you read the docs.  or stare at packets for weeks on end.
  39  *
  40  */
  41
  42 #include "includes.h"
  43
  44 extern int DEBUGLEVEL;
  45
  46 static void NTLMSSPcalc_p( pipes_struct *p, unsigned char *data, int len)
  47 {
  48     unsigned char *hash = p->ntlmssp_hash;
  49     unsigned char index_i = hash[256];
  50     unsigned char index_j = hash[257];
  51     int ind;
  52
  53     for( ind = 0; ind < len; ind++) {
  54         unsigned char tc;
  55         unsigned char t;
  56
  57         index_i++;
  58         index_j += hash[index_i];
  59
  60         tc = hash[index_i];
  61         hash[index_i] = hash[index_j];
  62         hash[index_j] = tc;
  63
  64         t = hash[index_i] + hash[index_j];
  65         data[ind] = data[ind] ^ hash[t];
  66     }
  67
  68     hash[256] = index_i;
  69     hash[257] = index_j;
  70 }
  71
  72 /*******************************************************************
  73  Generate the next PDU to be returned from the data in p->rdata.
  74  We cheat here as this function doesn't handle the special auth
  75  footers of the authenticated bind response reply.
  76  ********************************************************************/
  77
  78 BOOL create_next_pdu(pipes_struct *p)
  79 {
  80         RPC_HDR_RESP hdr_resp;
  81         BOOL auth_verify = IS_BITS_SET_ALL(p->ntlmssp_chal_flags, NTLMSSP_NEGOTIATE_SIGN);
  82         BOOL auth_seal   = IS_BITS_SET_ALL(p->ntlmssp_chal_flags, NTLMSSP_NEGOTIATE_SEAL);
  83         uint32 data_len;
  84         uint32 data_space_available;
  85         uint32 data_len_left;
  86         prs_struct outgoing_pdu;
  87         char *data;
  88         char *data_from;
  89         uint32 data_pos;
  90
  91         /*
  92          * If we're in the fault state, keep returning fault PDU's until
  93          * the pipe gets closed. JRA.
  94          */
  95
  96         if(p->fault_state) {
  97                 setup_fault_pdu(p);
  98                 return True;
  99         }
 100
 101         memset((char *)&hdr_resp, '\0', sizeof(hdr_resp));
 102
 103         /* Change the incoming request header to a response. */
 104         p->hdr.pkt_type = RPC_RESPONSE;
 105
 106         /* Set up rpc header flags. */
 107         if (p->out_data.data_sent_length == 0)
 108                 p->hdr.flags = RPC_FLG_FIRST;
 109         else
 110                 p->hdr.flags = 0;
 111
 112         /*
 113          * Work out how much we can fit in a sigle PDU.
 114          */
 115
 116         data_space_available = sizeof(p->out_data.current_pdu) - RPC_HEADER_LEN - RPC_HDR_RESP_LEN;
 117         if(p->ntlmssp_auth_validated)
 118                 data_space_available -= (RPC_HDR_AUTH_LEN + RPC_AUTH_NTLMSSP_CHK_LEN);
 119
 120         /*
 121          * The amount we send is the minimum of the available
 122          * space and the amount left to send.
 123          */
 124
 125         data_len_left = prs_offset(&p->out_data.rdata) - p->out_data.data_sent_length;
 126
 127         /*
 128          * Ensure there really is data left to send.
 129          */
 130
 131         if(!data_len_left) {
 132                 DEBUG(0,("create_next_pdu: no data left to send !\n"));
 133                 return False;
 134         }
 135
 136         data_len = MIN(data_len_left, data_space_available);
 137
 138         /*
 139          * Set up the alloc hint. This should be the data left to
 140          * send.
 141          */
 142
 143         hdr_resp.alloc_hint = data_len_left;
 144
 145         /*
 146          * Set up the header lengths.
 147          */
 148
 149         if (p->ntlmssp_auth_validated) {
 150                 p->hdr.frag_len = RPC_HEADER_LEN + RPC_HDR_RESP_LEN + data_len +
 151                                         RPC_HDR_AUTH_LEN + RPC_AUTH_NTLMSSP_CHK_LEN;
 152                 p->hdr.auth_len = RPC_AUTH_NTLMSSP_CHK_LEN;
 153         } else {
 154                 p->hdr.frag_len = RPC_HEADER_LEN + RPC_HDR_RESP_LEN + data_len;
 155                 p->hdr.auth_len = 0;
 156         }
 157
 158         /*
 159          * Work out if this PDU will be the last.
 160          */
 161
 162         if(p->out_data.data_sent_length + data_len >= prs_offset(&p->out_data.rdata))
 163                 p->hdr.flags |= RPC_FLG_LAST;
 164
 165         /*
 166          * Init the parse struct to point at the outgoing
 167          * data.
 168          */
 169
 170         prs_init( &outgoing_pdu, 0, 4, MARSHALL);
 171         prs_give_memory( &outgoing_pdu, (char *)p->out_data.current_pdu, sizeof(p->out_data.current_pdu), False);
 172
 173         /* Store the header in the data stream. */
 174         if(!smb_io_rpc_hdr("hdr", &p->hdr, &outgoing_pdu, 0)) {
 175                 DEBUG(0,("create_next_pdu: failed to marshall RPC_HDR.\n"));
 176                 return False;
 177         }
 178
 179         if(!smb_io_rpc_hdr_resp("resp", &hdr_resp, &outgoing_pdu, 0)) {
 180                 DEBUG(0,("create_next_pdu: failed to marshall RPC_HDR_RESP.\n"));
 181                 return False;
 182         }
 183
 184         /* Store the current offset. */
 185         data_pos = prs_offset(&outgoing_pdu);
 186
 187         /* Copy the data into the PDU. */
 188         data_from = prs_data_p(&p->out_data.rdata) + p->out_data.data_sent_length;
 189
 190         if(!prs_append_data(&outgoing_pdu, data_from, data_len)) {
 191                 DEBUG(0,("create_next_pdu: failed to copy %u bytes of data.\n", (unsigned int)data_len));
 192                 return False;
 193         }
 194
 195         /*
 196          * Set data to point to where we copied the data into.
 197          */
 198
 199         data = prs_data_p(&outgoing_pdu) + data_pos;
 200
 201         if (p->hdr.auth_len > 0) {
 202                 uint32 crc32 = 0;
 203
 204                 DEBUG(5,("create_next_pdu: sign: %s seal: %s data %d auth %d\n",
 205                          BOOLSTR(auth_verify), BOOLSTR(auth_seal), data_len, p->hdr.auth_len));
 206
 207                 if (auth_seal) {
 208                         crc32 = crc32_calc_buffer(data, data_len);
 209                         NTLMSSPcalc_p(p, (uchar*)data, data_len);
 210                 }
 211
 212                 if (auth_seal || auth_verify) {
 213                         RPC_HDR_AUTH auth_info;
 214
 215                         init_rpc_hdr_auth(&auth_info, NTLMSSP_AUTH_TYPE, NTLMSSP_AUTH_LEVEL,
 216                                         (auth_verify ? RPC_HDR_AUTH_LEN : 0), (auth_verify ? 1 : 0));
 217                         if(!smb_io_rpc_hdr_auth("hdr_auth", &auth_info, &outgoing_pdu, 0)) {
 218                                 DEBUG(0,("create_next_pdu: failed to marshall RPC_HDR_AUTH.\n"));
 219                                 return False;
 220                         }
 221                 }
 222
 223                 if (auth_verify) {
 224                         RPC_AUTH_NTLMSSP_CHK ntlmssp_chk;
 225                         char *auth_data = prs_data_p(&outgoing_pdu);
 226
 227                         p->ntlmssp_seq_num++;
 228                         init_rpc_auth_ntlmssp_chk(&ntlmssp_chk, NTLMSSP_SIGN_VERSION,
 229                                         crc32, p->ntlmssp_seq_num++);
 230                         auth_data = prs_data_p(&outgoing_pdu) + prs_offset(&outgoing_pdu) + 4;
 231                         if(!smb_io_rpc_auth_ntlmssp_chk("auth_sign", &ntlmssp_chk, &outgoing_pdu, 0)) {
 232                                 DEBUG(0,("create_next_pdu: failed to marshall RPC_AUTH_NTLMSSP_CHK.\n"));
 233                                 return False;
 234                         }
 235                         NTLMSSPcalc_p(p, (uchar*)auth_data, RPC_AUTH_NTLMSSP_CHK_LEN - 4);
 236                 }
 237         }
 238
 239         /*
 240          * Setup the counts for this PDU.
 241          */
 242
 243         p->out_data.data_sent_length += data_len;
 244         p->out_data.current_pdu_len = p->hdr.frag_len;
 245         p->out_data.current_pdu_sent = 0;
 246
 247         return True;
 248 }
 249
 250 /*******************************************************************
 251  Process an NTLMSSP authentication response.
 252  If this function succeeds, the user has been authenticated
 253  and their domain, name and calling workstation stored in
 254  the pipe struct.
 255  The initial challenge is stored in p->challenge.
 256  *******************************************************************/
 257
 258 static BOOL api_pipe_ntlmssp_verify(pipes_struct *p, RPC_AUTH_NTLMSSP_RESP *ntlmssp_resp)
 259 {
 260         uchar lm_owf[24];
 261         uchar nt_owf[24];
 262         fstring user_name;
 263         fstring unix_user_name;
 264         fstring domain;
 265         fstring wks;
 266         BOOL guest_user = False;
 267         struct smb_passwd *smb_pass = NULL;
 268         struct passwd *pass = NULL;
 269         uchar null_smb_passwd[16];
 270         uchar *smb_passwd_ptr = NULL;
 271
 272         DEBUG(5,("api_pipe_ntlmssp_verify: checking user details\n"));
 273
 274         memset(p->user_name, '\0', sizeof(p->user_name));
 275         memset(p->unix_user_name, '\0', sizeof(p->unix_user_name));
 276         memset(p->domain, '\0', sizeof(p->domain));
 277         memset(p->wks, '\0', sizeof(p->wks));
 278
 279         /*
 280          * Setup an empty password for a guest user.
 281          */
 282
 283         memset(null_smb_passwd,0,16);
 284
 285         /*
 286          * We always negotiate UNICODE.
 287          */
 288
 289         if (IS_BITS_SET_ALL(p->ntlmssp_chal_flags, NTLMSSP_NEGOTIATE_UNICODE)) {
 290                 fstrcpy(user_name, dos_unistrn2((uint16*)ntlmssp_resp->user, ntlmssp_resp->hdr_usr.str_str_len/2));
 291                 fstrcpy(domain, dos_unistrn2((uint16*)ntlmssp_resp->domain, ntlmssp_resp->hdr_domain.str_str_len/2));
 292                 fstrcpy(wks, dos_unistrn2((uint16*)ntlmssp_resp->wks, ntlmssp_resp->hdr_wks.str_str_len/2));
 293         } else {
 294                 fstrcpy(user_name, ntlmssp_resp->user);
 295                 fstrcpy(domain, ntlmssp_resp->domain);
 296                 fstrcpy(wks, ntlmssp_resp->wks);
 297         }
 298
 299         DEBUG(5,("user: %s domain: %s wks: %s\n", user_name, domain, wks));
 300
 301         memcpy(lm_owf, ntlmssp_resp->lm_resp, sizeof(lm_owf));
 302         memcpy(nt_owf, ntlmssp_resp->nt_resp, sizeof(nt_owf));
 303
 304 #ifdef DEBUG_PASSWORD
 305         DEBUG(100,("lm, nt owfs, chal\n"));
 306         dump_data(100, (char *)lm_owf, sizeof(lm_owf));
 307         dump_data(100, (char *)nt_owf, sizeof(nt_owf));
 308         dump_data(100, (char *)p->challenge, 8);
 309 #endif
 310
 311         /*
 312          * Allow guest access. Patch from Shirish Kalele <kalele@veritas.com>.
 313          */
 314
 315         if((strlen(user_name) == 0) &&
 316            (ntlmssp_resp->hdr_nt_resp.str_str_len==0))
 317           {
 318                 guest_user = True;
 319
 320         fstrcpy(unix_user_name, lp_guestaccount(-1));
 321                 DEBUG(100,("Null user in NTLMSSP verification. Using guest = %s\n", unix_user_name));
 322
 323                 smb_passwd_ptr = null_smb_passwd;
 324
 325         } else {
 326
 327                 /*
 328                  * Pass the user through the NT -> unix user mapping
 329                  * function.
 330                  */
 331
 332                 fstrcpy(unix_user_name, user_name);
 333                 (void)map_username(unix_user_name);
 334
 335                 /*
 336                  * Do the length checking only if user is not NULL.
 337                  */
 338
 339                 if (ntlmssp_resp->hdr_lm_resp.str_str_len == 0)
 340                         return False;
 341                 if (ntlmssp_resp->hdr_nt_resp.str_str_len == 0)
 342                         return False;
 343                 if (ntlmssp_resp->hdr_usr.str_str_len == 0)
 344                         return False;
 345                 if (ntlmssp_resp->hdr_domain.str_str_len == 0)
 346                         return False;
 347                 if (ntlmssp_resp->hdr_wks.str_str_len == 0)
 348                         return False;
 349
 350         }
 351
 352         /*
 353          * Find the user in the unix password db.
 354          */
 355
 356         if(!(pass = Get_Pwnam(unix_user_name,True))) {
 357                 DEBUG(1,("Couldn't find user '%s' in UNIX password database.\n",unix_user_name));
 358                 return(False);
 359         }
 360
 361         if(!guest_user) {
 362
 363                 become_root(True);
 364
 365                 if(!(p->ntlmssp_auth_validated = pass_check_smb(unix_user_name, domain,
 366                                       (uchar*)p->challenge, lm_owf, nt_owf, NULL))) {
 367                         DEBUG(1,("api_pipe_ntlmssp_verify: User %s\\%s from machine %s \
 368 failed authentication on named pipe %s.\n", domain, unix_user_name, wks, p->name ));
 369                         unbecome_root(True);
 370                         return False;
 371                 }
 372
 373                 if(!(smb_pass = getsmbpwnam(unix_user_name))) {
 374                         DEBUG(1,("api_pipe_ntlmssp_verify: Cannot find user %s in smb passwd database.\n",
 375                                 unix_user_name));
 376                         unbecome_root(True);
 377                         return False;
 378                 }
 379
 380                 unbecome_root(True);
 381
 382                 if (smb_pass == NULL) {
 383                         DEBUG(1,("api_pipe_ntlmssp_verify: Couldn't find user '%s' in smb_passwd file.\n",
 384                                 unix_user_name));
 385                         return(False);
 386                 }
 387
 388                 /* Quit if the account was disabled. */
 389                 if((smb_pass->acct_ctrl & ACB_DISABLED) || !smb_pass->smb_passwd) {
 390                         DEBUG(1,("Account for user '%s' was disabled.\n", unix_user_name));
 391                         return(False);
 392                 }
 393
 394                 if(!smb_pass->smb_nt_passwd) {
 395                         DEBUG(1,("Account for user '%s' has no NT password hash.\n", unix_user_name));
 396                         return(False);
 397                 }
 398
 399                 smb_passwd_ptr = smb_pass->smb_passwd;
 400         }
 401
 402         /*
 403          * Set up the sign/seal data.
 404          */
 405
 406         {
 407                 uchar p24[24];
 408                 NTLMSSPOWFencrypt(smb_passwd_ptr, lm_owf, p24);
 409                 {
 410                         unsigned char j = 0;
 411                         int ind;
 412
 413                         unsigned char k2[8];
 414
 415                         memcpy(k2, p24, 5);
 416                         k2[5] = 0xe5;
 417                         k2[6] = 0x38;
 418                         k2[7] = 0xb0;
 419
 420                         for (ind = 0; ind < 256; ind++)
 421                                 p->ntlmssp_hash[ind] = (unsigned char)ind;
 422
 423                         for( ind = 0; ind < 256; ind++) {
 424                                 unsigned char tc;
 425
 426                                 j += (p->ntlmssp_hash[ind] + k2[ind%8]);
 427
 428                                 tc = p->ntlmssp_hash[ind];
 429                                 p->ntlmssp_hash[ind] = p->ntlmssp_hash[j];
 430                                 p->ntlmssp_hash[j] = tc;
 431                         }
 432
 433                         p->ntlmssp_hash[256] = 0;
 434                         p->ntlmssp_hash[257] = 0;
 435                 }
 436 /*              NTLMSSPhash(p->ntlmssp_hash, p24); */
 437                 p->ntlmssp_seq_num = 0;
 438
 439         }
 440
 441         fstrcpy(p->user_name, user_name);
 442         fstrcpy(p->unix_user_name, unix_user_name);
 443         fstrcpy(p->domain, domain);
 444         fstrcpy(p->wks, wks);
 445
 446         /*
 447          * Store the UNIX credential data (uid/gid pair) in the pipe structure.
 448          */
 449
 450         p->uid = pass->pw_uid;
 451         p->gid = pass->pw_gid;
 452
 453         p->ntlmssp_auth_validated = True;
 454         return True;
 455 }
 456
 457 /*******************************************************************
 458  The switch table for the pipe names and the functions to handle them.
 459  *******************************************************************/
 460
 461 struct api_cmd
 462 {
 463   char * pipe_clnt_name;
 464   char * pipe_srv_name;
 465   BOOL (*fn) (pipes_struct *, prs_struct *);
 466 };
 467
 468 static struct api_cmd api_fd_commands[] =
 469 {
 470     { "lsarpc",   "lsass",   api_ntlsa_rpc },
 471     { "samr",     "lsass",   api_samr_rpc },
 472     { "srvsvc",   "ntsvcs",  api_srvsvc_rpc },
 473     { "wkssvc",   "ntsvcs",  api_wkssvc_rpc },
 474     { "NETLOGON", "lsass",   api_netlog_rpc },
 475 #if 1 /* DISABLED_IN_2_0 JRATEST */
 476     { "winreg",   "winreg",  api_reg_rpc },
 477 #endif
 478     { "spoolss",  "spoolss", api_spoolss_rpc },
 479     { NULL,       NULL,      NULL }
 480 };
 481
 482 /*******************************************************************
 483  This is the client reply to our challenge for an authenticated
 484  bind request. The challenge we sent is in p->challenge.
 485 *******************************************************************/
 486
 487 BOOL api_pipe_bind_auth_resp(pipes_struct *p, prs_struct *rpc_in_p)
 488 {
 489         RPC_HDR_AUTHA autha_info;
 490         RPC_AUTH_VERIFIER auth_verifier;
 491         RPC_AUTH_NTLMSSP_RESP ntlmssp_resp;
 492
 493         DEBUG(5,("api_pipe_bind_auth_resp: decode request. %d\n", __LINE__));
 494
 495         if (p->hdr.auth_len == 0) {
 496                 DEBUG(0,("api_pipe_bind_auth_resp: No auth field sent !\n"));
 497                 return False;
 498         }
 499
 500         /*
 501          * Decode the authentication verifier response.
 502          */
 503
 504         if(!smb_io_rpc_hdr_autha("", &autha_info, rpc_in_p, 0)) {
 505                 DEBUG(0,("api_pipe_bind_auth_resp: unmarshall of RPC_HDR_AUTHA failed.\n"));
 506                 return False;
 507         }
 508
 509         if (autha_info.auth_type != NTLMSSP_AUTH_TYPE || autha_info.auth_level != NTLMSSP_AUTH_LEVEL) {
 510                 DEBUG(0,("api_pipe_bind_auth_resp: incorrect auth type (%d) or level (%d).\n",
 511                         (int)autha_info.auth_type, (int)autha_info.auth_level ));
 512                 return False;
 513         }
 514
 515         if(!smb_io_rpc_auth_verifier("", &auth_verifier, rpc_in_p, 0)) {
 516                 DEBUG(0,("api_pipe_bind_auth_resp: unmarshall of RPC_AUTH_VERIFIER failed.\n"));
 517                 return False;
 518         }
 519
 520         /*
 521          * Ensure this is a NTLMSSP_AUTH packet type.
 522          */
 523
 524         if (!rpc_auth_verifier_chk(&auth_verifier, "NTLMSSP", NTLMSSP_AUTH)) {
 525                 DEBUG(0,("api_pipe_bind_auth_resp: rpc_auth_verifier_chk failed.\n"));
 526                 return False;
 527         }
 528
 529         if(!smb_io_rpc_auth_ntlmssp_resp("", &ntlmssp_resp, rpc_in_p, 0)) {
 530                 DEBUG(0,("api_pipe_bind_auth_resp: Failed to unmarshall RPC_AUTH_NTLMSSP_RESP.\n"));
 531                 return False;
 532         }
 533
 534         /*
 535          * The following call actually checks the challenge/response data.
 536          * for correctness against the given DOMAIN\user name.
 537          */
 538
 539         if (!api_pipe_ntlmssp_verify(p, &ntlmssp_resp))
 540                 return False;
 541
 542         p->pipe_bound = True
 543 ;
 544         return True;
 545 }
 546
 547 /*******************************************************************
 548  Marshall a bind_nak pdu.
 549 *******************************************************************/
 550
 551 static BOOL setup_bind_nak(pipes_struct *p)
 552 {
 553         prs_struct outgoing_rpc;
 554         RPC_HDR nak_hdr;
 555         uint16 zero = 0;
 556
 557         /* Free any memory in the current return data buffer. */
 558         prs_mem_free(&p->out_data.rdata);
 559
 560         /*
 561          * Marshall directly into the outgoing PDU space. We
 562          * must do this as we need to set to the bind response
 563          * header and are never sending more than one PDU here.
 564          */
 565
 566         prs_init( &outgoing_rpc, 0, 4, MARSHALL);
 567         prs_give_memory( &outgoing_rpc, (char *)p->out_data.current_pdu, sizeof(p->out_data.current_pdu), False);
 568
 569
 570         /*
 571          * Initialize a bind_nak header.
 572          */
 573
 574         init_rpc_hdr(&nak_hdr, RPC_BINDNACK, RPC_FLG_FIRST | RPC_FLG_LAST,
 575             p->hdr.call_id, RPC_HEADER_LEN + sizeof(uint16), 0);
 576
 577         /*
 578          * Marshall the header into the outgoing PDU.
 579          */
 580
 581         if(!smb_io_rpc_hdr("", &nak_hdr, &outgoing_rpc, 0)) {
 582                 DEBUG(0,("setup_bind_nak: marshalling of RPC_HDR failed.\n"));
 583                 return False;
 584         }
 585
 586         /*
 587          * Now add the reject reason.
 588          */
 589
 590         if(!prs_uint16("reject code", &outgoing_rpc, 0, &zero))
 591         return False;
 592
 593         p->out_data.data_sent_length = 0;
 594         p->out_data.current_pdu_len = prs_offset(&outgoing_rpc);
 595         p->out_data.current_pdu_sent = 0;
 596
 597         p->pipe_bound = False;
 598
 599         return True;
 600 }
 601
 602 /*******************************************************************
 603  Marshall a fault pdu.
 604 *******************************************************************/
 605
 606 BOOL setup_fault_pdu(pipes_struct *p)
 607 {
 608         prs_struct outgoing_pdu;
 609         RPC_HDR fault_hdr;
 610         RPC_HDR_RESP hdr_resp;
 611         RPC_HDR_FAULT fault_resp;
 612
 613         /* Free any memory in the current return data buffer. */
 614         prs_mem_free(&p->out_data.rdata);
 615
 616         /*
 617          * Marshall directly into the outgoing PDU space. We
 618          * must do this as we need to set to the bind response
 619          * header and are never sending more than one PDU here.
 620          */
 621
 622         prs_init( &outgoing_pdu, 0, 4, MARSHALL);
 623         prs_give_memory( &outgoing_pdu, (char *)p->out_data.current_pdu, sizeof(p->out_data.current_pdu), False);
 624
 625         /*
 626          * Initialize a fault header.
 627          */
 628
 629         init_rpc_hdr(&fault_hdr, RPC_FAULT, RPC_FLG_FIRST | RPC_FLG_LAST | RPC_FLG_NOCALL,
 630             p->hdr.call_id, RPC_HEADER_LEN + RPC_HDR_RESP_LEN + RPC_HDR_FAULT_LEN, 0);
 631
 632         /*
 633          * Initialize the HDR_RESP and FAULT parts of the PDU.
 634          */
 635
 636         memset((char *)&hdr_resp, '\0', sizeof(hdr_resp));
 637
 638         fault_resp.status = 0x1c010002;
 639         fault_resp.reserved = 0;
 640
 641         /*
 642          * Marshall the header into the outgoing PDU.
 643          */
 644
 645         if(!smb_io_rpc_hdr("", &fault_hdr, &outgoing_pdu, 0)) {
 646                 DEBUG(0,("setup_fault_pdu: marshalling of RPC_HDR failed.\n"));
 647                 return False;
 648         }
 649
 650         if(!smb_io_rpc_hdr_resp("resp", &hdr_resp, &outgoing_pdu, 0)) {
 651                 DEBUG(0,("setup_fault_pdu: failed to marshall RPC_HDR_RESP.\n"));
 652                 return False;
 653         }
 654
 655         if(!smb_io_rpc_hdr_fault("fault", &fault_resp, &outgoing_pdu, 0)) {
 656                 DEBUG(0,("setup_fault_pdu: failed to marshall RPC_HDR_FAULT.\n"));
 657                 return False;
 658         }
 659
 660         p->out_data.data_sent_length = 0;
 661         p->out_data.current_pdu_len = prs_offset(&outgoing_pdu);
 662         p->out_data.current_pdu_sent = 0;
 663
 664         return True;
 665 }
 666
 667 /*******************************************************************
 668  Respond to a pipe bind request.
 669 *******************************************************************/
 670
 671 BOOL api_pipe_bind_req(pipes_struct *p, prs_struct *rpc_in_p)
 672 {
 673         RPC_HDR_BA hdr_ba;
 674         RPC_HDR_RB hdr_rb;
 675         RPC_HDR_AUTH auth_info;
 676         uint16 assoc_gid;
 677         fstring ack_pipe_name;
 678         prs_struct out_hdr_ba;
 679         prs_struct out_auth;
 680         prs_struct outgoing_rpc;
 681         int i = 0;
 682         int auth_len = 0;
 683         enum RPC_PKT_TYPE reply_pkt_type;
 684
 685         p->ntlmssp_auth_requested = False;
 686
 687         DEBUG(5,("api_pipe_bind_req: decode request. %d\n", __LINE__));
 688
 689         /*
 690          * Try and find the correct pipe name to ensure
 691          * that this is a pipe name we support.
 692          */
 693
 694         for (i = 0; api_fd_commands[i].pipe_clnt_name; i++) {
 695                 if (strequal(api_fd_commands[i].pipe_clnt_name, p->name) &&
 696                     api_fd_commands[i].fn != NULL) {
 697                         DEBUG(3,("api_pipe_bind_req: \\PIPE\\%s -> \\PIPE\\%s\n",
 698                                    api_fd_commands[i].pipe_clnt_name,
 699                                    api_fd_commands[i].pipe_srv_name));
 700                         fstrcpy(p->pipe_srv_name, api_fd_commands[i].pipe_srv_name);
 701                         break;
 702                 }
 703         }
 704
 705         if (api_fd_commands[i].fn == NULL) {
 706                 DEBUG(3,("api_pipe_bind_req: Unknown pipe name %s in bind request.\n",
 707                         p->name ));
 708                 if(!setup_bind_nak(p))
 709                         return False;
 710                 return True;
 711         }
 712
 713         /* decode the bind request */
 714         if(!smb_io_rpc_hdr_rb("", &hdr_rb, rpc_in_p, 0))  {
 715                 DEBUG(0,("api_pipe_bind_req: unable to unmarshall RPC_HDR_RB struct.\n"));
 716                 return False;
 717         }
 718
 719         /*
 720          * Check if this is an authenticated request.
 721          */
 722
 723         if (p->hdr.auth_len != 0) {
 724                 RPC_AUTH_VERIFIER auth_verifier;
 725                 RPC_AUTH_NTLMSSP_NEG ntlmssp_neg;
 726
 727                 /*
 728                  * Decode the authentication verifier.
 729                  */
 730
 731                 if(!smb_io_rpc_hdr_auth("", &auth_info, rpc_in_p, 0)) {
 732                         DEBUG(0,("api_pipe_bind_req: unable to unmarshall RPC_HDR_AUTH struct.\n"));
 733                         return False;
 734                 }
 735
 736                 /*
 737                  * We only support NTLMSSP_AUTH_TYPE requests.
 738                  */
 739
 740                 if(auth_info.auth_type != NTLMSSP_AUTH_TYPE) {
 741                         DEBUG(0,("api_pipe_bind_req: unknown auth type %x requested.\n",
 742                                 auth_info.auth_type ));
 743                         return False;
 744                 }
 745
 746                 if(!smb_io_rpc_auth_verifier("", &auth_verifier, rpc_in_p, 0)) {
 747                         DEBUG(0,("api_pipe_bind_req: unable to unmarshall RPC_HDR_AUTH struct.\n"));
 748                         return False;
 749                 }
 750
 751                 if(!strequal(auth_verifier.signature, "NTLMSSP")) {
 752                         DEBUG(0,("api_pipe_bind_req: auth_verifier.signature != NTLMSSP\n"));
 753                         return False;
 754                 }
 755
 756                 if(auth_verifier.msg_type != NTLMSSP_NEGOTIATE) {
 757                         DEBUG(0,("api_pipe_bind_req: auth_verifier.msg_type (%d) != NTLMSSP_NEGOTIATE\n",
 758                                 auth_verifier.msg_type));
 759                         return False;
 760                 }
 761
 762                 if(!smb_io_rpc_auth_ntlmssp_neg("", &ntlmssp_neg, rpc_in_p, 0)) {
 763                         DEBUG(0,("api_pipe_bind_req: Failed to unmarshall RPC_AUTH_NTLMSSP_NEG.\n"));
 764                         return False;
 765                 }
 766
 767                 p->ntlmssp_chal_flags = SMBD_NTLMSSP_NEG_FLAGS;
 768                 p->ntlmssp_auth_requested = True;
 769         }
 770
 771         switch(p->hdr.pkt_type) {
 772                 case RPC_BIND:
 773                         /* name has to be \PIPE\xxxxx */
 774                         fstrcpy(ack_pipe_name, "\\PIPE\\");
 775                         fstrcat(ack_pipe_name, p->pipe_srv_name);
 776                         reply_pkt_type = RPC_BINDACK;
 777                         break;
 778                 case RPC_ALTCONT:
 779                         /* secondary address CAN be NULL
 780                          * as the specs say it's ignored.
 781                          * It MUST NULL to have the spoolss working.
 782                          */
 783                         fstrcpy(ack_pipe_name,"");
 784                         reply_pkt_type = RPC_ALTCONTRESP;
 785                         break;
 786                 default:
 787                         return False;
 788         }
 789
 790         DEBUG(5,("api_pipe_bind_req: make response. %d\n", __LINE__));
 791
 792         /*
 793          * Marshall directly into the outgoing PDU space. We
 794          * must do this as we need to set to the bind response
 795          * header and are never sending more than one PDU here.
 796          */
 797
 798         prs_init( &outgoing_rpc, 0, 4, MARSHALL);
 799         prs_give_memory( &outgoing_rpc, (char *)p->out_data.current_pdu, sizeof(p->out_data.current_pdu), False);
 800
 801         /*
 802          * Setup the memory to marshall the ba header, and the
 803          * auth footers.
 804          */
 805
 806         if(!prs_init(&out_hdr_ba, 1024, 4, MARSHALL)) {
 807                 DEBUG(0,("api_pipe_bind_req: malloc out_hdr_ba failed.\n"));
 808                 return False;
 809         }
 810
 811         if(!prs_init(&out_auth, 1024, 4, MARSHALL)) {
 812                 DEBUG(0,("pi_pipe_bind_req: malloc out_auth failed.\n"));
 813                 prs_mem_free(&out_hdr_ba);
 814                 return False;
 815         }
 816
 817         if (p->ntlmssp_auth_requested)
 818                 assoc_gid = 0x7a77;
 819         else
 820                 assoc_gid = hdr_rb.bba.assoc_gid;
 821
 822         /*
 823          * Create the bind response struct.
 824          */
 825
 826         init_rpc_hdr_ba(&hdr_ba,
 827                         MAX_PDU_FRAG_LEN,
 828                         MAX_PDU_FRAG_LEN,
 829                         assoc_gid,
 830                         ack_pipe_name,
 831                         0x1, 0x0, 0x0,
 832                         &hdr_rb.transfer);
 833
 834         /*
 835          * and marshall it.
 836          */
 837
 838         if(!smb_io_rpc_hdr_ba("", &hdr_ba, &out_hdr_ba, 0)) {
 839                 DEBUG(0,("api_pipe_bind_req: marshalling of RPC_HDR_BA failed.\n"));
 840                 goto err_exit;
 841         }
 842
 843         /*
 844          * Now the authentication.
 845          */
 846
 847         if (p->ntlmssp_auth_requested) {
 848                 RPC_AUTH_VERIFIER auth_verifier;
 849                 RPC_AUTH_NTLMSSP_CHAL ntlmssp_chal;
 850
 851                 generate_random_buffer(p->challenge, 8, False);
 852
 853                 /*** Authentication info ***/
 854
 855                 init_rpc_hdr_auth(&auth_info, NTLMSSP_AUTH_TYPE, NTLMSSP_AUTH_LEVEL, RPC_HDR_AUTH_LEN, 1);
 856                 if(!smb_io_rpc_hdr_auth("", &auth_info, &out_auth, 0)) {
 857                         DEBUG(0,("api_pipe_bind_req: marshalling of RPC_HDR_AUTH failed.\n"));
 858                         goto err_exit;
 859                 }
 860
 861                 /*** NTLMSSP verifier ***/
 862
 863                 init_rpc_auth_verifier(&auth_verifier, "NTLMSSP", NTLMSSP_CHALLENGE);
 864                 if(!smb_io_rpc_auth_verifier("", &auth_verifier, &out_auth, 0)) {
 865                         DEBUG(0,("api_pipe_bind_req: marshalling of RPC_AUTH_VERIFIER failed.\n"));
 866                         goto err_exit;
 867                 }
 868
 869                 /* NTLMSSP challenge ***/
 870
 871                 init_rpc_auth_ntlmssp_chal(&ntlmssp_chal, p->ntlmssp_chal_flags, p->challenge);
 872                 if(!smb_io_rpc_auth_ntlmssp_chal("", &ntlmssp_chal, &out_auth, 0)) {
 873                         DEBUG(0,("api_pipe_bind_req: marshalling of RPC_AUTH_NTLMSSP_CHAL failed.\n"));
 874                         goto err_exit;
 875                 }
 876
 877                 /* Auth len in the rpc header doesn't include auth_header. */
 878                 auth_len = prs_offset(&out_auth) - RPC_HDR_AUTH_LEN;
 879         }
 880
 881         /*
 882          * Create the header, now we know the length.
 883          */
 884
 885         init_rpc_hdr(&p->hdr, reply_pkt_type, RPC_FLG_FIRST | RPC_FLG_LAST,
 886                         p->hdr.call_id,
 887                         RPC_HEADER_LEN + prs_offset(&out_hdr_ba) + prs_offset(&out_auth),
 888                         auth_len);
 889
 890         /*
 891          * Marshall the header into the outgoing PDU.
 892          */
 893
 894         if(!smb_io_rpc_hdr("", &p->hdr, &outgoing_rpc, 0)) {
 895                 DEBUG(0,("pi_pipe_bind_req: marshalling of RPC_HDR failed.\n"));
 896                 goto err_exit;
 897         }
 898
 899         /*
 900          * Now add the RPC_HDR_BA and any auth needed.
 901          */
 902
 903         if(!prs_append_prs_data( &outgoing_rpc, &out_hdr_ba)) {
 904                 DEBUG(0,("api_pipe_bind_req: append of RPC_HDR_BA failed.\n"));
 905                 goto err_exit;
 906         }
 907
 908         if(p->ntlmssp_auth_requested && !prs_append_prs_data( &outgoing_rpc, &out_auth)) {
 909                 DEBUG(0,("api_pipe_bind_req: append of auth info failed.\n"));
 910                 goto err_exit;
 911         }
 912
 913         if(!p->ntlmssp_auth_requested)
 914                 p->pipe_bound = True;
 915
 916         /*
 917          * Setup the lengths for the initial reply.
 918          */
 919
 920         p->out_data.data_sent_length = 0;
 921         p->out_data.current_pdu_len = prs_offset(&outgoing_rpc);
 922         p->out_data.current_pdu_sent = 0;
 923
 924         prs_mem_free(&out_hdr_ba);
 925         prs_mem_free(&out_auth);
 926
 927         return True;
 928
 929   err_exit:
 930
 931         prs_mem_free(&out_hdr_ba);
 932         prs_mem_free(&out_auth);
 933         return False;
 934 }
 935
 936 /****************************************************************************
 937  Deal with sign & seal processing on an RPC request.
 938 ****************************************************************************/
 939
 940 BOOL api_pipe_auth_process(pipes_struct *p, prs_struct *rpc_in)
 941 {
 942         /*
 943          * We always negotiate the following two bits....
 944          */
 945         BOOL auth_verify = IS_BITS_SET_ALL(p->ntlmssp_chal_flags, NTLMSSP_NEGOTIATE_SIGN);
 946         BOOL auth_seal   = IS_BITS_SET_ALL(p->ntlmssp_chal_flags, NTLMSSP_NEGOTIATE_SEAL);
 947         int data_len;
 948         int auth_len;
 949         uint32 old_offset;
 950         uint32 crc32 = 0;
 951
 952         auth_len = p->hdr.auth_len;
 953
 954         if ((auth_len != RPC_AUTH_NTLMSSP_CHK_LEN) && auth_verify) {
 955                 DEBUG(0,("api_pipe_auth_process: Incorrect auth_len %d.\n", auth_len ));
 956                 return False;
 957         }
 958
 959         /*
 960          * The following is that length of the data we must verify or unseal.
 961          * This doesn't include the RPC headers or the auth_len or the RPC_HDR_AUTH_LEN
 962          * preceeding the auth_data.
 963          */
 964
 965         data_len = p->hdr.frag_len - RPC_HEADER_LEN - RPC_HDR_REQ_LEN -
 966                         (auth_verify ? RPC_HDR_AUTH_LEN : 0) - auth_len;
 967
 968         DEBUG(5,("api_pipe_auth_process: sign: %s seal: %s data %d auth %d\n",
 969                  BOOLSTR(auth_verify), BOOLSTR(auth_seal), data_len, auth_len));
 970
 971         if (auth_seal) {
 972                 /*
 973                  * The data in rpc_in doesn't contain the RPC_HEADER as this
 974                  * has already been consumed.
 975                  */
 976                 char *data = prs_data_p(rpc_in) + RPC_HDR_REQ_LEN;
 977                 NTLMSSPcalc_p(p, (uchar*)data, data_len);
 978                 crc32 = crc32_calc_buffer(data, data_len);
 979         }
 980
 981         old_offset = prs_offset(rpc_in);
 982
 983         if (auth_seal || auth_verify) {
 984                 RPC_HDR_AUTH auth_info;
 985
 986                 if(!prs_set_offset(rpc_in, old_offset + data_len)) {
 987                         DEBUG(0,("api_pipe_auth_process: cannot move offset to %u.\n",
 988                                 (unsigned int)old_offset + data_len ));
 989                         return False;
 990                 }
 991
 992                 if(!smb_io_rpc_hdr_auth("hdr_auth", &auth_info, rpc_in, 0)) {
 993                         DEBUG(0,("api_pipe_auth_process: failed to unmarshall RPC_HDR_AUTH.\n"));
 994                         return False;
 995                 }
 996         }
 997
 998         if (auth_verify) {
 999                 RPC_AUTH_NTLMSSP_CHK ntlmssp_chk;
1000                 char *req_data = prs_data_p(rpc_in) + prs_offset(rpc_in) + 4;
1001
1002                 DEBUG(5,("api_pipe_auth_process: auth %d\n", prs_offset(rpc_in) + 4));
1003
1004                 /*
1005                  * Ensure we have RPC_AUTH_NTLMSSP_CHK_LEN - 4 more bytes in the
1006                  * incoming buffer.
1007                  */
1008                 if(prs_mem_get(rpc_in, RPC_AUTH_NTLMSSP_CHK_LEN - 4) == NULL) {
1009                         DEBUG(0,("api_pipe_auth_process: missing %d bytes in buffer.\n",
1010                                 RPC_AUTH_NTLMSSP_CHK_LEN - 4 ));
1011                         return False;
1012                 }
1013
1014                 NTLMSSPcalc_p(p, (uchar*)req_data, RPC_AUTH_NTLMSSP_CHK_LEN - 4);
1015                 if(!smb_io_rpc_auth_ntlmssp_chk("auth_sign", &ntlmssp_chk, rpc_in, 0)) {
1016                         DEBUG(0,("api_pipe_auth_process: failed to unmarshall RPC_AUTH_NTLMSSP_CHK.\n"));
1017                         return False;
1018                 }
1019
1020                 if (!rpc_auth_ntlmssp_chk(&ntlmssp_chk, crc32, p->ntlmssp_seq_num)) {
1021                         DEBUG(0,("api_pipe_auth_process: NTLMSSP check failed.\n"));
1022                         return False;
1023                 }
1024         }
1025
1026         /*
1027          * Return the current pointer to the data offset.
1028          */
1029
1030         if(!prs_set_offset(rpc_in, old_offset)) {
1031                 DEBUG(0,("api_pipe_auth_process: failed to set offset back to %u\n",
1032                         (unsigned int)old_offset ));
1033                 return False;
1034         }
1035
1036         return True;
1037 }
1038
1039 /****************************************************************************
1040  Find the correct RPC function to call for this request.
1041  If the pipe is authenticated then become the correct UNIX user
1042  before doing the call.
1043 ****************************************************************************/
1044
1045 BOOL api_pipe_request(pipes_struct *p)
1046 {
1047         int i = 0;
1048         BOOL ret = False;
1049         BOOL changed_user_id = False;
1050
1051         if (p->ntlmssp_auth_validated) {
1052
1053                 if(!become_authenticated_pipe_user(p)) {
1054                         prs_mem_free(&p->out_data.rdata);
1055                         return False;
1056                 }
1057
1058                 changed_user_id = True;
1059         }
1060
1061         for (i = 0; api_fd_commands[i].pipe_clnt_name; i++) {
1062                 if (strequal(api_fd_commands[i].pipe_clnt_name, p->name) &&
1063                     api_fd_commands[i].fn != NULL) {
1064                         DEBUG(3,("Doing \\PIPE\\%s\n", api_fd_commands[i].pipe_clnt_name));
1065                         ret = api_fd_commands[i].fn(p, &p->in_data.data);
1066                 }
1067         }
1068
1069         if(changed_user_id)
1070                 unbecome_authenticated_pipe_user(p);
1071
1072         return ret;
1073 }
1074
1075 /*******************************************************************
1076  Calls the underlying RPC function for a named pipe.
1077  ********************************************************************/
1078
1079 BOOL api_rpcTNP(pipes_struct *p, char *rpc_name, struct api_struct *api_rpc_cmds,
1080                                 prs_struct *rpc_in)
1081 {
1082         int fn_num;
1083
1084         /* interpret the command */
1085         DEBUG(4,("api_rpcTNP: %s op 0x%x - ", rpc_name, p->hdr_req.opnum));
1086
1087         prs_dump(rpc_name, p->hdr_req.opnum, rpc_in);
1088
1089         for (fn_num = 0; api_rpc_cmds[fn_num].name; fn_num++) {
1090                 if (api_rpc_cmds[fn_num].opnum == p->hdr_req.opnum && api_rpc_cmds[fn_num].fn != NULL) {
1091                         DEBUG(3,("api_rpcTNP: rpc command: %s\n", api_rpc_cmds[fn_num].name));
1092                         break;
1093                 }
1094         }
1095
1096         if (api_rpc_cmds[fn_num].name == NULL) {
1097                 /*
1098                  * For an unknown RPC just return a fault PDU but
1099                  * return True to allow RPC's on the pipe to continue
1100                  * and not put the pipe into fault state. JRA.
1101                  */
1102                 DEBUG(4, ("unknown\n"));
1103                 setup_fault_pdu(p);
1104                 return True;
1105         }
1106
1107         /* do the actual command */
1108         if(!api_rpc_cmds[fn_num].fn(rpc_in, &p->out_data.rdata)) {
1109                 DEBUG(0,("api_rpcTNP: %s: failed.\n", rpc_name));
1110                 prs_mem_free(&p->out_data.rdata);
1111                 return False;
1112         }
1113
1114         DEBUG(5,("api_rpcTNP: called %s successfully\n", rpc_name));
1115
1116         return True;
1117 }
1118
1119 #undef OLD_NTDOMAIN