path: root/source3/rpc_client/cli_login.c

/* 
   Unix SMB/Netbios implementation.
   Version 1.9.
   NT Domain Authentication SMB / MSRPC client
   Copyright (C) Andrew Tridgell 1994-1997
   Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"
#include "nterr.h"

extern int DEBUGLEVEL;

/****************************************************************************
Initialize domain session.
****************************************************************************/

BOOL do_nt_session_open(struct cli_state *cli, uint16 fnum,
                        char *dest_host, char *myhostname,
                        char *mach_acct,
                        uchar sess_key[16], DOM_CRED *clnt_cred)
{
  DOM_CHAL clnt_chal;
  DOM_CHAL srv_chal;

  DOM_CHAL auth2_srv_chal;

  UTIME zerotime;

  char nt_owf_mach_pwd[16];

  RPC_IFACE abstract;
  RPC_IFACE transfer;

  fstring mach_pwd;
  fstring dest_srv;

  /******************** initialise ********************************/

  zerotime.time = 0;

  DEBUG(10,("do_nt_session_open: %d\n", __LINE__));

  /**************** Set Named Pipe State ***************/
  if (!rpc_pipe_set_hnd_state(cli, PIPE_NETLOGON, fnum, 0x4300))
  {
    DEBUG(0,("do_nt_session_open: pipe hnd state failed\n"));
    return False;
  }

  /******************* bind request on \PIPE\NETLOGON *****************/

  if (!rpc_pipe_bind(cli, PIPE_NETLOGON, fnum, &abstract, &transfer,
                     False, NULL, NULL))
  {
    DEBUG(0,("do_nt_session_open: rpc bind failed\n"));
    return False;
  }

  /************ Check workstation trust account *******************/

FIXME !!
	/* default machine password is lower-case machine name (really secure) */
	fstrcpy(mach_pwd, myhostname);
	strlower(mach_pwd);

	/* default machine password is lower-case machine name (really secure) */
	fstrcpy(prev_mpd, myhostname);
	strlower(prev_mpd);

  /******************* Request Challenge ********************/

  generate_random_buffer( clnt_chal.data, 8, False);
	
  strcpy(dest_srv, "\\\\");
  strcat(dest_srv, dest_host);
  strupper(dest_srv);

  /* send a client challenge; receive a server challenge */
  if (!do_net_req_chal(cli, fnum, dest_srv, myhostname, &clnt_chal, &srv_chal))
  {
    DEBUG(0,("do_nt_session_open: request challenge failed\n"));
    return False;
  }

  /**************** Long-term Session key **************/

#ifdef DEBUG_PASSWORD
  DEBUG(100,("generating nt owf from initial machine pwd: %s\n", mach_pwd));
#endif
  nt_owf_gen( mach_pwd, nt_owf_mach_pwd);

#ifdef DEBUG_PASSWORD
  dump_data(6, nt_owf_mach_pwd, 16);
#endif

  /* calculate the session key */
  cred_session_key(&clnt_chal, &srv_chal, nt_owf_mach_pwd, sess_key);
  bzero(sess_key+8, 8);

  /******************* Authenticate 2 ********************/

  /* calculate auth-2 credentials */
  cred_create(sess_key, &clnt_chal, zerotime, &(clnt_cred->challenge));

  /* send client auth-2 challenge; receive an auth-2 challenge */
  if (!do_net_auth2(cli, fnum, dest_srv, mach_acct,
                    SEC_CHAN_WKSTA, myhostname,
                    &(clnt_cred->challenge), 0x000001ff, &auth2_srv_chal))
  {
    DEBUG(0,("do_nt_session_open: request challenge failed\n"));
    return False;
  }

  return True;
}

/****************************************************************************
 server password set
 ****************************************************************************/

BOOL do_nt_srv_pwset(struct cli_state *cli, int t_idx, uint16 fnum,
                     uint8 sess_key[16], DOM_CRED *clnt_cred, DOM_CRED *rtn_cred,
                     char *new_mach_pwd,
                     char *dest_host, char *mach_acct, char *myhostname)
{
  DOM_CRED cred;
  char nt_cypher[16];
  uint8 mode = 1;
  char nt_owf_new_mach_pwd[16];

#ifdef DEBUG_PASSWORD
  DEBUG(100,("generating nt owf from new machine pwd: %s\n", new_mach_pwd));
#endif
  nt_owf_gen(new_mach_pwd, nt_owf_new_mach_pwd);

#ifdef DEBUG_PASSWORD
  dump_data(6, nt_owf_new_mach_pwd, 16);
#endif

  if (!obfuscate_pwd(nt_cypher, nt_owf_new_mach_pwd, mode))
  {
    DEBUG(5,("do_nt_srv_pwset: encrypt mach pwd failed\n"));
    return False;
  }
	
  clnt_cred->timestamp.time = time(NULL);

  memcpy(&cred, clnt_cred, sizeof(cred));

  /* calculate credentials */
  cred_create(sess_key, &(clnt_cred->challenge),
              cred.timestamp, &(cred.challenge));

  /* send client srv_pwset challenge */
  return do_net_srv_pwset(cli, fnum, sess_key, clnt_cred,
                          dest_host, mach_acct, 2, myhostname,
                          &cred, rtn_cred, nt_cypher);
}

/****************************************************************************
 make interactive sam login info
 ****************************************************************************/

void make_nt_login_interactive(NET_ID_INFO_CTR *ctr,
                               uchar sess_key[16],
                               char *workgroup, char *myhostname,
                               uint32 smb_userid, char *username)
{
  /****************** SAM Info Preparation *******************/

  char *smb_user_passwd = getpass("Enter NT Login Password:");

  char lm_owf_user_pwd[16];
  char nt_owf_user_pwd[16];

  nt_lm_owf_gen(smb_user_passwd, nt_owf_user_pwd, lm_owf_user_pwd);

#ifdef DEBUG_PASSWORD

  DEBUG(100,("nt owf of user password: "));
  dump_data(100, lm_owf_user_pwd, 16);

  DEBUG(100,("nt owf of user password: "));
  dump_data(100, nt_owf_user_pwd, 16);

#endif

  /* indicate an "interactive" login */
  ctr->switch_value = 1;

  /* this is used in both the SAM Logon and the SAM Logoff */
  make_id_info1(&ctr->auth.id1, workgroup, 0,
                smb_userid, 0, username, myhostname,
                sess_key, lm_owf_user_pwd, nt_owf_user_pwd);
}

/****************************************************************************
 make network sam login info
 ****************************************************************************/

void make_nt_login_network(NET_ID_INFO_CTR *ctr,
                           char *workgroup, char *myhostname,
                           uint32 smb_userid, char *username,
                           char lm_chal[8], char lm_chal_resp[24], 
                           char nt_chal_resp[24])
{
  /* indicate a "network" login */
  ctr->switch_value = 2;

  /* this is used in both the SAM Logon and the SAM Logoff */
  make_id_info2(&ctr->auth.id2, workgroup, 0, smb_userid, 0,
                username, myhostname,
                lm_chal, lm_chal_resp, nt_chal_resp);
}

/****************************************************************************
NT login.
****************************************************************************/

BOOL do_nt_login(struct cli_state *cli, uint16 fnum,
                 uint8 sess_key[16], DOM_CRED *clnt_cred, DOM_CRED *rtn_cred,
                 NET_ID_INFO_CTR *ctr, char *dest_host, char *myhostname,
                 NET_USER_INFO_3 *user_info3)
{
  DOM_CRED sam_logon_rtn_cred;
  DOM_CRED cred;
  fstring dest_srv;
  fstring my_host_name;

  DEBUG(5,("do_nt_login: %d\n", __LINE__));

  /*********************** SAM Logon **********************/

  clnt_cred->timestamp.time = time(NULL);

  memcpy(&cred, clnt_cred, sizeof(cred));

  /* calculate sam logon credentials */
  cred_create(sess_key, &(clnt_cred->challenge),
              cred.timestamp, &(cred.challenge));

  strcpy(dest_srv, "\\\\");
  strcat(dest_srv, dest_host);
  strupper(dest_srv);

  fstrcpy(my_host_name, myhostname);
  strupper(my_host_name);

  /* send client sam-logon challenge */
  return do_net_sam_logon(cli, fnum, sess_key, clnt_cred, 
                          dest_srv, my_host_name, 
                          &cred, &sam_logon_rtn_cred,
                          ctr->switch_value, ctr, 3, user_info3,
                          rtn_cred);
}

/****************************************************************************
nt sam logoff
****************************************************************************/

BOOL do_nt_logoff(struct cli_state *cli, uint16 fnum,
                  uint8 sess_key[16], DOM_CRED *clnt_cred, DOM_CRED *rtn_cred,
                  NET_ID_INFO_CTR *ctr, char *dest_host, char *myhostname)
{
  DOM_CRED sam_logoff_rtn_cred;
  DOM_CRED cred;
  fstring dest_srv;
  fstring my_host_name;

  DEBUG(5,("do_nt_logoff: %d\n", __LINE__));

  /*********************** SAM Logoff *********************/

  clnt_cred->timestamp.time = time(NULL);

  memcpy(&cred, clnt_cred, sizeof(cred));

  /* calculate sam logoff credentials */
  cred_create(sess_key, &(clnt_cred->challenge),
              cred.timestamp, &(cred.challenge));

  strcpy(dest_srv, "\\\\");
  strcat(dest_srv, dest_host);
  strupper(dest_srv);

  fstrcpy(my_host_name, myhostname);
  strupper(my_host_name);

  /* send client sam-logoff challenge; receive a sam-logoff challenge */
  return do_net_sam_logoff(cli, fnum, sess_key, clnt_cred,
                           dest_srv, my_host_name, 
                           &cred, &sam_logoff_rtn_cred,
                           ctr->switch_value, ctr, 3,
                           rtn_cred);
}

/****************************************************************************
Close the NT pipe.
****************************************************************************/

void do_nt_session_close(struct cli_state *cli, uint16 fnum)
{
  /******************** close the \PIPE\NETLOGON file **************/
  if (fnum != 0xffff)
  {
    cli_close(cli, fnum);
  }
}