From 0a549e62fbf11a3ff1f1de663176e30006553e08 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Sun, 26 Oct 1997 18:42:47 +0000 Subject: hooray. hooray some more. hooray a lot. got the client-side working. Q/R LSA_REQ_CHAL; Q/R LSA_AUTH2; Q/R LSA_SAMLOGON; Q/R LSA_SAMLOGOFF. the last (non-essential right now) bit is the LSA_SRV_PWSET. the next stage is to do LSA_OPENPOLICY; add the pipe binds (missing right now); then we can test against an NT Server. --- source/client/ntclient.c | 230 ++++++++++++++++++++++++++++++++++---------- source/include/proto.h | 9 +- source/libsmb/credentials.c | 98 ++++++++----------- source/pipenetlog.c | 22 +++-- 4 files changed, 238 insertions(+), 121 deletions(-) diff --git a/source/client/ntclient.c b/source/client/ntclient.c index f92fab9032a..93793cfccb1 100644 --- a/source/client/ntclient.c +++ b/source/client/ntclient.c @@ -293,13 +293,14 @@ static BOOL do_lsa_auth2(uint16 fnum, return valid_chal; } -/**************************************************************************** +/*************************************************************************** do a LSA SAM Logon ****************************************************************************/ -static BOOL do_lsa_sam_logon(uint16 fnum, uint32 sess_key[2], DOM_CHAL *clnt_chal, +static BOOL do_lsa_sam_logon(uint16 fnum, uint32 sess_key[2], DOM_CRED *sto_clnt_cred, char *logon_srv, char *comp_name, DOM_CRED *clnt_cred, DOM_CRED *rtn_cred, uint16 logon_level, uint16 switch_value, DOM_ID_INFO_1 *id1, + LSA_USER_INFO *user_info, DOM_CRED *srv_cred) { char *rparam = NULL; @@ -312,7 +313,7 @@ static BOOL do_lsa_sam_logon(uint16 fnum, uint32 sess_key[2], DOM_CHAL *clnt_cha int call_id = 0x1; BOOL valid_cred = False; - if (srv_cred == NULL || clnt_cred == NULL || rtn_cred == NULL) return False; + if (srv_cred == NULL || clnt_cred == NULL || rtn_cred == NULL || user_info == NULL) return False; /* create and send a MSRPC command with api LSA_SAMLOGON */ @@ -343,32 +344,135 @@ static BOOL do_lsa_sam_logon(uint16 fnum, uint32 sess_key[2], DOM_CHAL *clnt_cha NULL, data, setup, &rparam,&rdata)) { - DOM_CRED clnt_cred1; + LSA_R_SAM_LOGON r_s; + RPC_HDR hdr; + int hdr_len; + int pkt_len; + + r_s.user = user_info; DEBUG(5, ("cli_call_api: return OK\n")); - clnt_cred1.timestamp.time = clnt_cred->timestamp.time + 1; + p = rdata; - /* calculate sam logon credentials at time+1, just like server does */ - cred_create(sess_key, clnt_chal, clnt_cred1.timestamp, - &(clnt_cred1.challenge)); + if (p) p = smb_io_rpc_hdr (True, &hdr, p, rdata, 4, 0); + if (p) p = align_offset(p, rdata, 4); /* oh, what a surprise */ -#if 0 - LSA_R_AUTH_2 r_a; - RPC_HDR hdr; - int hdr_len; - int pkt_len; + hdr_len = PTR_DIFF(p, rdata); - /* check sam logon credentials at time+1, just like server does */ - if (cred_assert(r_s....creds, sess_key, clnt_chal, clnt_cred->timestamp + 1)) + if (p && hdr_len != hdr.frag_len - hdr.alloc_hint) { - DEBUG(5, ("do_lsa_sam_logon: server credential check OK\n")); + /* header length not same as calculated header length */ + DEBUG(2,("do_lsa_sam_logon: hdr_len %x != frag_len-alloc_hint\n", + hdr_len, hdr.frag_len - hdr.alloc_hint)); + p = NULL; + } + + if (p) p = lsa_io_r_sam_logon(True, &r_s, p, rdata, 4, 0); + + pkt_len = PTR_DIFF(p, rdata); + + if (p && pkt_len != hdr.frag_len) + { + /* packet data size not same as reported fragment length */ + DEBUG(2,("do_lsa_sam_logon: pkt_len %x != frag_len \n", + pkt_len, hdr.frag_len)); + p = NULL; } - else + + if (p && r_s.status != 0) { - DEBUG(5, ("do_lsa_sam_logon: server credential check failed\n")); + /* report error code */ + DEBUG(0,("LSA_SAMLOGON: nt_status error %lx\n", r_s.status)); + p = NULL; } + if (p && r_s.switch_value != 3) + { + /* report different switch_value */ + DEBUG(0,("LSA_SAMLOGON: switch_value of 3 expected %x\n", + r_s.switch_value)); + p = NULL; + } + + if (p) + { + if (clnt_deal_with_creds(sess_key, sto_clnt_cred, &(r_s.srv_creds))) + { + DEBUG(5, ("do_lsa_sam_logon: server credential check OK\n")); + /* ok, at last: we're happy. return the challenge */ + memcpy(srv_cred, &(r_s.srv_creds), sizeof(r_s.srv_creds)); + valid_cred = True; + } + else + { + DEBUG(5, ("do_lsa_sam_logon: server credential check failed\n")); + } + } +#endif + } + + if (rparam) free(rparam); + if (rdata) free(rdata); + + return valid_cred; +} + +/*************************************************************************** +do a LSA SAM Logoff +****************************************************************************/ +static BOOL do_lsa_sam_logoff(uint16 fnum, uint32 sess_key[2], DOM_CRED *sto_clnt_cred, + char *logon_srv, char *comp_name, + DOM_CRED *clnt_cred, DOM_CRED *rtn_cred, + uint16 logon_level, uint16 switch_value, DOM_ID_INFO_1 *id1, + DOM_CRED *srv_cred) +{ + char *rparam = NULL; + char *rdata = NULL; + char *p; + int rdrcnt,rprcnt; + pstring data; /* only 1024 bytes */ + uint16 setup[2]; /* only need 2 uint16 setup parameters */ + LSA_Q_SAM_LOGOFF q_s; + int call_id = 0x1; + BOOL valid_cred = False; + + if (srv_cred == NULL || clnt_cred == NULL || rtn_cred == NULL) return False; + + /* create and send a MSRPC command with api LSA_SAMLOGON */ + + DEBUG(4,("LSA SAM Logoff: srv:%s mc:%s clnt %lx %lx %lx rtn: %lx %lx %lx ll: %d\n", + logon_srv, comp_name, + clnt_cred->challenge.data[0], clnt_cred->challenge.data[1], clnt_cred->timestamp.time, + rtn_cred ->challenge.data[0], rtn_cred ->challenge.data[1], rtn_cred ->timestamp.time, + logon_level)); + + /* store the parameters */ + make_sam_info(&(q_s.sam_id), logon_srv, comp_name, + clnt_cred, rtn_cred, logon_level, switch_value, id1); + + /* turn parameters into data stream */ + p = lsa_io_q_sam_logoff(False, &q_s, data + 0x18, data, 4, 0); + + /* create the request RPC_HDR _after_ the main data: length is now known */ + create_rpc_request(call_id, LSA_SAMLOGOFF, data, PTR_DIFF(p, data)); + + /* create setup parameters. */ + SIVAL(setup, 0, 0x0026); /* 0x26 indicates "transact named pipe" */ + SIVAL(setup, 2, fnum); /* file handle, from the SMBcreateX pipe, earlier */ + + /* send the data on \PIPE\ */ + if (cli_call_api("\\PIPE\\", 0, PTR_DIFF(p, data), 2, 1024, + BUFFER_SIZE, + &rprcnt,&rdrcnt, + NULL, data, setup, + &rparam,&rdata)) + { + LSA_R_SAM_LOGOFF r_s; + RPC_HDR hdr; + int hdr_len; + int pkt_len; + DEBUG(5, ("cli_call_api: return OK\n")); p = rdata; @@ -381,45 +485,44 @@ static BOOL do_lsa_sam_logon(uint16 fnum, uint32 sess_key[2], DOM_CHAL *clnt_cha if (p && hdr_len != hdr.frag_len - hdr.alloc_hint) { /* header length not same as calculated header length */ - DEBUG(2,("do_lsa_auth2: hdr_len %x != frag_len-alloc_hint\n", + DEBUG(2,("do_lsa_sam_logoff: hdr_len %x != frag_len-alloc_hint\n", hdr_len, hdr.frag_len - hdr.alloc_hint)); p = NULL; } - if (p) p = lsa_io_r_auth_2(True, &r_a, p, rdata, 4, 0); + if (p) p = lsa_io_r_sam_logoff(True, &r_s, p, rdata, 4, 0); pkt_len = PTR_DIFF(p, rdata); if (p && pkt_len != hdr.frag_len) { /* packet data size not same as reported fragment length */ - DEBUG(2,("do_lsa_auth2: pkt_len %x != frag_len \n", + DEBUG(2,("do_lsa_sam_logoff: pkt_len %x != frag_len \n", pkt_len, hdr.frag_len)); p = NULL; } - if (p && r_a.status != 0) + if (p && r_s.status != 0) { /* report error code */ - DEBUG(0,("LSA_AUTH2: nt_status error %lx\n", r_a.status)); - p = NULL; - } - - if (p && r_a.srv_flgs.neg_flags != q_a.clnt_flgs.neg_flags) - { - /* report different neg_flags */ - DEBUG(0,("LSA_AUTH2: error neg_flags (q,r) differ - (%lx,%lx)\n", - q_a.clnt_flgs.neg_flags, r_a.srv_flgs.neg_flags)); + DEBUG(0,("LSA_SAMLOGOFF: nt_status error %lx\n", r_s.status)); p = NULL; } if (p) { - /* ok, at last: we're happy. return the challenge */ - memcpy(srv_chal, r_a.srv_chal.data, sizeof(srv_chal->data)); - valid_chal = True; + if (clnt_deal_with_creds(sess_key, sto_clnt_cred, &(r_s.srv_creds))) + { + DEBUG(5, ("do_lsa_sam_logoff: server credential check OK\n")); + /* ok, at last: we're happy. return the challenge */ + memcpy(srv_cred, &(r_s.srv_creds), sizeof(r_s.srv_creds)); + valid_cred = True; + } + else + { + DEBUG(5, ("do_lsa_sam_logoff: server credential check failed\n")); + } } -#endif } if (rparam) free(rparam); @@ -437,14 +540,20 @@ BOOL do_nt_login(char *desthost, char *myhostname, DOM_CHAL clnt_chal; DOM_CHAL srv_chal; - DOM_CHAL auth2_clnt_chal; + DOM_CRED clnt_cred; + DOM_CHAL auth2_srv_chal; - DOM_CRED sam_log_clnt_cred; - DOM_CRED sam_log_rtn_cred; - DOM_CRED sam_log_srv_cred; + DOM_CRED sam_logon_clnt_cred; + DOM_CRED sam_logon_rtn_cred; + DOM_CRED sam_logon_srv_cred; + + DOM_CRED sam_logoff_clnt_cred; + DOM_CRED sam_logoff_rtn_cred; + DOM_CRED sam_logoff_srv_cred; DOM_ID_INFO_1 id1; + LSA_USER_INFO user_info1; UTIME zerotime; @@ -526,11 +635,11 @@ BOOL do_nt_login(char *desthost, char *myhostname, /******************* Authenticate 2 ********************/ /* calculate auth-2 credentials */ - cred_create(sess_key, &clnt_chal, zerotime, &auth2_clnt_chal); + cred_create(sess_key, &clnt_chal, zerotime, &(clnt_cred.challenge)); /* send client auth-2 challenge; receive an auth-2 challenge */ if (!do_lsa_auth2(fnum, desthost, mach_acct, 2, myhostname, - &auth2_clnt_chal, 0x000001ff, &auth2_srv_chal)) + &(clnt_cred.challenge), 0x000001ff, &auth2_srv_chal)) { cli_smb_close(inbuf, outbuf, Client, cnum, fnum); free(inbuf); free(outbuf); @@ -548,32 +657,47 @@ BOOL do_nt_login(char *desthost, char *myhostname, /*********************** SAM Logon **********************/ - sam_log_clnt_cred.timestamp.time = time(NULL); + clnt_cred.timestamp.time = sam_logon_clnt_cred.timestamp.time = time(NULL); /* calculate sam logon credentials, using the auth2 client challenge */ - cred_create(sess_key, &auth2_clnt_chal, sam_log_clnt_cred.timestamp, - &(sam_log_clnt_cred.challenge)); + cred_create(sess_key, &(clnt_cred.challenge), sam_logon_clnt_cred.timestamp, + &(sam_logon_clnt_cred.challenge)); /* send client sam-logon challenge; receive a sam-logon challenge */ - if (!do_lsa_sam_logon(fnum, sess_key, &auth2_clnt_chal, + if (!do_lsa_sam_logon(fnum, sess_key, &clnt_cred, desthost, mach_acct, - &sam_log_clnt_cred, &sam_log_rtn_cred, - 1, 1, &id1, - &sam_log_srv_cred)) + &sam_logon_clnt_cred, &sam_logon_rtn_cred, + 1, 1, &id1, &user_info1, + &sam_logon_srv_cred)) { cli_smb_close(inbuf, outbuf, Client, cnum, fnum); free(inbuf); free(outbuf); return False; } -#if 0 - cli_lsa_sam_logoff(); -#endif + /*********************** SAM Logoff *********************/ + + clnt_cred.timestamp.time = sam_logoff_clnt_cred.timestamp.time = time(NULL); + + /* calculate sam logoff credentials, using the sam logon return challenge */ + cred_create(sess_key, &(clnt_cred.challenge), + sam_logoff_clnt_cred.timestamp, + &(sam_logoff_clnt_cred.challenge)); + + /* send client sam-logoff challenge; receive a sam-logoff challenge */ + if (!do_lsa_sam_logoff(fnum, sess_key, &clnt_cred, + desthost, mach_acct, + &sam_logoff_clnt_cred, &sam_logoff_rtn_cred, + 1, 1, &id1, + &sam_logoff_srv_cred)) + { + cli_smb_close(inbuf, outbuf, Client, cnum, fnum); + free(inbuf); free(outbuf); + return False; + } cli_smb_close(inbuf, outbuf, Client, cnum, fnum); free(inbuf); free(outbuf); return True; } - -#endif diff --git a/source/include/proto.h b/source/include/proto.h index 6489e875614..f0c855c689a 100644 --- a/source/include/proto.h +++ b/source/include/proto.h @@ -102,8 +102,11 @@ void cred_create(uint32 session_key[2], DOM_CHAL *stor_cred, UTIME timestamp, DOM_CHAL *cred); int cred_assert(DOM_CHAL *cred, uint32 session_key[2], DOM_CHAL *stored_cred, UTIME timestamp); -BOOL srv_deal_with_creds(struct dcinfo *dc, DOM_CRED *clnt_cred, DOM_CRED *srv_cred); -BOOL clnt_deal_with_creds(struct dcinfo *dc, DOM_CRED *srv_cred, DOM_CRED *clnt_cred); +BOOL clnt_deal_with_creds(uint32 sess_key[2], + DOM_CRED *sto_clnt_cred, DOM_CRED *rcv_srv_cred); +BOOL deal_with_creds(uint32 sess_key[2], + DOM_CRED *sto_clnt_cred, + DOM_CRED *rcv_clnt_cred, DOM_CRED *rtn_srv_cred); /*The following definitions come from dir.c */ @@ -891,7 +894,7 @@ void cred_hash2(unsigned char *out,unsigned char *in,unsigned char *key); void SMBencrypt(uchar *passwd, uchar *c8, uchar *p24); void E_md4hash(uchar *passwd, uchar *p16); void SMBNTencrypt(uchar *passwd, uchar *c8, uchar *p24); -void nt_lm_owf_gen(char *pwd, char nt_p16[16], char p16[16]); +void nt_lm_owf_gen(char *pwd, char *nt_p16, char *p16); /*The following definitions come from smbparse.c */ diff --git a/source/libsmb/credentials.c b/source/libsmb/credentials.c index 109a5a1b901..6711604f6d9 100644 --- a/source/libsmb/credentials.c +++ b/source/libsmb/credentials.c @@ -72,6 +72,7 @@ Output: void cred_create(uint32 session_key[2], DOM_CHAL *stor_cred, UTIME timestamp, DOM_CHAL *cred) { + DOM_CHAL time_cred; unsigned char calc_cred[8]; unsigned char timecred[8]; unsigned char netsesskey[8]; @@ -87,12 +88,16 @@ void cred_create(uint32 session_key[2], DOM_CHAL *stor_cred, UTIME timestamp, cred->data[0] = IVAL(calc_cred, 0); cred->data[1] = IVAL(calc_cred, 4); + time_cred.data[0] = IVAL(timecred, 0); + time_cred.data[1] = IVAL(timecred, 4); + /* debug output*/ DEBUG(4,("cred_create\n")); DEBUG(5,(" sess_key : %lx %lx\n", session_key [0], session_key [1])); DEBUG(5,(" stor_cred: %lx %lx\n", stor_cred->data[0], stor_cred->data[1])); - DEBUG(5,(" timecred : %lx %lx\n", IVAL(timecred, 0) , IVAL(timecred, 4) )); + DEBUG(5,(" timestamp: %lx\n" , timestamp.time)); + DEBUG(5,(" timecred : %lx %lx\n", time_cred .data[0], time_cred .data[1])); DEBUG(5,(" calc_cred: %lx %lx\n", cred ->data[0], cred ->data[1])); } @@ -139,106 +144,81 @@ int cred_assert(DOM_CHAL *cred, uint32 session_key[2], DOM_CHAL *stored_cred, /**************************************************************************** checks credentials; generates next step in the credential chain ****************************************************************************/ -BOOL srv_deal_with_creds(struct dcinfo *dc, DOM_CRED *clnt_cred, DOM_CRED *srv_cred) +BOOL clnt_deal_with_creds(uint32 sess_key[2], + DOM_CRED *sto_clnt_cred, DOM_CRED *rcv_srv_cred) { UTIME new_clnt_time; uint32 new_cred; - DEBUG(5,("deal_with_creds: %d\n", __LINE__)); + DEBUG(5,("clnt_deal_with_creds: %d\n", __LINE__)); + + /* increment client time by one second */ + new_clnt_time.time = sto_clnt_cred->timestamp.time + 1; - /* check that the client credentials are valid */ - if (!cred_assert(&(clnt_cred->challenge), dc->sess_key, - &(dc->clnt_cred.challenge), clnt_cred->timestamp)) + /* check that the received server credentials are valid */ + if (!cred_assert(&(rcv_srv_cred->challenge), sess_key, + &(sto_clnt_cred->challenge), new_clnt_time)) { return False; } - /* increment client time by one second */ - new_clnt_time.time = clnt_cred->timestamp.time + 1; - /* first 4 bytes of the new seed is old client 4 bytes + clnt time + 1 */ - new_cred = IVAL(dc->clnt_cred.challenge.data, 0); + new_cred = IVAL(sto_clnt_cred->challenge.data, 0); new_cred += new_clnt_time.time; - DEBUG(5,("deal_with_creds: new_cred[0]=%lx\n", new_cred)); - - /* doesn't matter that server time is 0 */ - srv_cred->timestamp.time = 0; - - DEBUG(5,("deal_with_creds: new_clnt_time=%lx\n", new_clnt_time.time)); - - /* create return credentials for inclusion in the reply */ - cred_create(dc->sess_key, &(dc->clnt_cred.challenge), new_clnt_time, - &(srv_cred->challenge)); - - DEBUG(5,("deal_with_creds: clnt_cred[0]=%lx\n", - dc->clnt_cred.challenge.data[0])); - - /* store new seed in client and server credentials */ - SIVAL(dc->clnt_cred.challenge.data, 0, new_cred); - SIVAL(dc->srv_cred .challenge.data, 0, new_cred); + /* store new seed in client credentials */ + SIVAL(sto_clnt_cred->challenge.data, 0, new_cred); + DEBUG(5,(" new clnt cred: %lx %lx\n", sto_clnt_cred->challenge.data[0], + sto_clnt_cred->challenge.data[1])); return True; } -#if 0 /**************************************************************************** checks credentials; generates next step in the credential chain ****************************************************************************/ -BOOL clnt_deal_with_creds(struct dcinfo *dc, DOM_CRED *srv_cred, DOM_CRED *clnt_cred) +BOOL deal_with_creds(uint32 sess_key[2], + DOM_CRED *sto_clnt_cred, + DOM_CRED *rcv_clnt_cred, DOM_CRED *rtn_srv_cred) { UTIME new_clnt_time; uint32 new_cred; DEBUG(5,("deal_with_creds: %d\n", __LINE__)); - /* setup new client time */ - dc->clnt_cred.timestamp.time = time(NULL); - - /* create sent credentials for inclusion in the reply */ - cred_create(dc->sess_key, srv_cred, dc->clnt_cred.timestamp.time, clnt_cred); - - /* increment client time by one second */ - (dc->clnt_cred.timestamp.time)++; - - /* create expected return credentials to be received from server */ - cred_create(dc->sess_key, srv_cred, dc->clnt_cred.timestamp.time, clnt_cred); - - - - /* check that the server credentials are valid */ - if (!cred_assert(&(srv_cred->challenge), dc->sess_key, - &(dc->clnt_cred), clnt_cred->timestamp)) + /* check that the received client credentials are valid */ + if (!cred_assert(&(rcv_clnt_cred->challenge), sess_key, + &(sto_clnt_cred->challenge), rcv_clnt_cred->timestamp)) { return False; } + /* increment client time by one second */ - new_clnt_time = (dc->clnt_cred.timestamp.time += 1); + new_clnt_time.time = rcv_clnt_cred->timestamp.time + 1; /* first 4 bytes of the new seed is old client 4 bytes + clnt time + 1 */ - new_cred = IVAL(dc->clnt_cred.data, 0); + new_cred = IVAL(sto_clnt_cred->challenge.data, 0); new_cred += new_clnt_time.time; DEBUG(5,("deal_with_creds: new_cred[0]=%lx\n", new_cred)); - /* create new client credentials */ - cred_create(dc->sess_key, new_cred, new_clnt_time, clnt_cred); + /* doesn't matter that server time is 0 */ + rtn_srv_cred->timestamp.time = 0; DEBUG(5,("deal_with_creds: new_clnt_time=%lx\n", new_clnt_time.time)); - /* create return credentials for inclusion in the reply - cred_create(dc->sess_key, srv_cred, new_clnt_time, - clnt_cred); - */ + /* create return credentials for inclusion in the reply */ + cred_create(sess_key, &(sto_clnt_cred->challenge), new_clnt_time, + &(rtn_srv_cred->challenge)); + DEBUG(5,("deal_with_creds: clnt_cred[0]=%lx\n", - dc->clnt_cred.data[0])); + sto_clnt_cred->challenge.data[0])); - /* store new seed in client and server credentials */ - SIVAL(dc->clnt_cred.data, 0, new_cred); - SIVAL(dc->srv_cred .data, 0, new_cred); + /* store new seed in client credentials */ + SIVAL(sto_clnt_cred->challenge.data, 0, new_cred); return True; } -#endif + diff --git a/source/pipenetlog.c b/source/pipenetlog.c index f2eb1c7f4ff..664488b16da 100644 --- a/source/pipenetlog.c +++ b/source/pipenetlog.c @@ -399,7 +399,9 @@ static void api_lsa_srv_pwset( user_struct *vuser, lsa_io_q_srv_pwset(True, &q_a, data + 0x18, data, 4, 0); /* checks and updates credentials. creates reply credentials */ - srv_deal_with_creds(&(vuser->dc), &(q_a.clnt_id.cred), &srv_cred); + deal_with_creds(vuser->dc.sess_key, &(vuser->dc.clnt_cred), + &(q_a.clnt_id.cred), &srv_cred); + memcpy(&(vuser->dc.srv_cred), &(vuser->dc.clnt_cred), sizeof(vuser->dc.clnt_cred)); DEBUG(5,("api_lsa_srv_pwset: %d\n", __LINE__)); @@ -415,14 +417,21 @@ static void api_lsa_sam_logoff( user_struct *vuser, char **rdata, int *rdata_len ) { LSA_Q_SAM_LOGOFF q_l; + DOM_ID_INFO_1 id1; DOM_CRED srv_cred; + /* the DOM_ID_INFO_1 structure is a bit big. plus we might want to + dynamically allocate it inside lsa_io_q_sam_logon, at some point */ + q_l.sam_id.auth.id1 = &id1; + /* grab the challenge... */ lsa_io_q_sam_logoff(True, &q_l, data + 0x18, data, 4, 0); /* checks and updates credentials. creates reply credentials */ - srv_deal_with_creds(&(vuser->dc), &(q_l.sam_id.client.cred), &srv_cred); + deal_with_creds(vuser->dc.sess_key, &(vuser->dc.clnt_cred), + &(q_l.sam_id.client.cred), &srv_cred); + memcpy(&(vuser->dc.srv_cred), &(vuser->dc.clnt_cred), sizeof(vuser->dc.clnt_cred)); /* construct reply. always indicate success */ *rdata_len = lsa_reply_sam_logoff(&q_l, *rdata + 0x18, *rdata, @@ -437,10 +446,9 @@ static void api_lsa_sam_logon( user_struct *vuser, { LSA_Q_SAM_LOGON q_l; DOM_ID_INFO_1 id1; - LSA_USER_INFO usr_info; - DOM_CRED srv_creds; + DOM_CRED srv_cred; /* the DOM_ID_INFO_1 structure is a bit big. plus we might want to dynamically allocate it inside lsa_io_q_sam_logon, at some point */ @@ -449,7 +457,9 @@ static void api_lsa_sam_logon( user_struct *vuser, lsa_io_q_sam_logon(True, &q_l, data + 0x18, data, 4, 0); /* checks and updates credentials. creates reply credentials */ - srv_deal_with_creds(&(vuser->dc), &(q_l.sam_id.client.cred), &srv_creds); + deal_with_creds(vuser->dc.sess_key, &(vuser->dc.clnt_cred), + &(q_l.sam_id.client.cred), &srv_cred); + memcpy(&(vuser->dc.srv_cred), &(vuser->dc.clnt_cred), sizeof(vuser->dc.clnt_cred)); usr_info.ptr_user_info = 0; @@ -568,7 +578,7 @@ static void api_lsa_sam_logon( user_struct *vuser, } *rdata_len = lsa_reply_sam_logon(&q_l, *rdata + 0x18, *rdata, - &srv_creds, &usr_info); + &srv_cred, &usr_info); } -- cgit v1.2.1