sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-22 22:04:08 +03:00
Code

Added STR_NOALIGN flags to clistr and srvstr fns. Yes, NT actually does

Browse Source 
send unaligned unicode strings sometimes!
Fixed our handling of the workgroup name tacked on the end of the
NT1 negprot response (a unaligned unicode)
fixed a couple of places where we should be using the message_end fns instead
of pre-calculated buffer lengths
This commit is contained in:
Andrew Tridgell -
parent 244aec8ea6
commit 86613493a9
8 changed files with 673 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1225
source/include/proto.h
View File

File diff suppressed because it is too large Load Diff

2
source/include/smb.h
View File

@ -57,7 +57,7 @@ typedef int BOOL;
#define STR_UPPER 4
#define STR_ASCII 8
#define STR_UNICODE 16
#define STR_NOALIGN 32
/* how long to wait for secondary SMB packets (milli-seconds) */
#define SMB_SECONDARY_WAIT (60*1000)

6
source/libsmb/cliconnect.c
View File

@ -429,6 +429,12 @@ BOOL cli_negprot(struct cli_state *cli)
cli->readbraw_supported = True;
cli->writebraw_supported = True;
}
/* work out if they sent us a workgroup */
if (smb_buflen(cli->inbuf) > 8) {
clistr_pull(cli, cli->server_domain,
smb_buf(cli->inbuf)+8, sizeof(cli->server_domain),
smb_buflen(cli->inbuf)-8, STR_CONVERT|STR_UNICODE|STR_NOALIGN);
}
} else if (cli->protocol >= PROTOCOL_LANMAN1) {
cli->sec_mode = SVAL(cli->inbuf,smb_vwv1);
cli->max_xmit = SVAL(cli->inbuf,smb_vwv2);

6
source/libsmb/clifile.c
View File

@ -243,7 +243,7 @@ int cli_nt_create_full(struct cli_state *cli, char *fname, uint32 DesiredAccess,
p = smb_buf(cli->outbuf);
/* this alignment and termination is critical for netapp filers. Don't change */
p += clistr_align(cli->outbuf, p);
p += clistr_align(cli, p, STR_CONVERT);
len = clistr_push(cli, p, fname, -1, STR_CONVERT);
p += len;
SSVAL(cli->outbuf,smb_ntcreate_NameLength, len);
@ -786,7 +786,7 @@ int cli_ctemp(struct cli_state *cli, char *path, char **tmp_path)
memset(cli->outbuf,'\0',smb_size);
memset(cli->inbuf,'\0',smb_size);
set_message(cli->outbuf,1,strlen(path)+2,True);
set_message(cli->outbuf,1,0,True);
CVAL(cli->outbuf,smb_com) = SMBctemp;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
@ -798,6 +798,8 @@ int cli_ctemp(struct cli_state *cli, char *path, char **tmp_path)
*p++ = 4;
p += clistr_push(cli, p, path, -1, STR_TERMINATE | STR_CONVERT);
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (!cli_receive_smb(cli)) {
return -1;

11
source/libsmb/climessage.c
View File

@ -71,7 +71,7 @@ BOOL cli_message_text(struct cli_state *cli, char *msg, int len, int grp)
char *p;
memset(cli->outbuf,'\0',smb_size);
set_message(cli->outbuf,1,len+3,True);
set_message(cli->outbuf,1,0,True);
CVAL(cli->outbuf,smb_com) = SMBsendtxt;
SSVAL(cli->outbuf,smb_tid,cli->cnum);
cli_setup_packet(cli);
@ -79,9 +79,12 @@ BOOL cli_message_text(struct cli_state *cli, char *msg, int len, int grp)
SSVAL(cli->outbuf,smb_vwv0,grp);
p = smb_buf(cli->outbuf);
*p = 1;
SSVAL(p,1,len);
memcpy(p+3,msg,len);
*p++ = 1;
SSVAL(p,0,len); p += 2;
memcpy(p,msg,len);
p += len;
cli_setup_bcc(cli, p);
cli_send_smb(cli);
if (!cli_receive_smb(cli)) {

21
source/libsmb/clistr.c
View File

@ -23,6 +23,10 @@
#include "includes.h"
#define UNICODE_FLAG(cli, flags) (!(flags & STR_ASCII) && \
((flags & STR_UNICODE || \
(SVAL(cli->outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS))))
/****************************************************************************
copy a string from a char* src to a unicode or ascii
dos code page destination choosing unicode or ascii based on the
@ -33,6 +37,7 @@ flags can have:
STR_CONVERT means convert from unix to dos codepage
STR_UPPER means uppercase in the destination
STR_ASCII use ascii even with unicode servers
STR_NOALIGN means don't do alignment
dest_len is the maximum length allowed in the destination. If dest_len
is -1 then no maxiumum is used
****************************************************************************/
@ -45,14 +50,14 @@ int clistr_push(struct cli_state *cli, void *dest, const char *src, int dest_len
dest_len = sizeof(pstring);
}
if (!(flags & STR_ASCII) && clistr_align(cli->outbuf, dest)) {
if (clistr_align(cli, dest, flags)) {
*(char *)dest = 0;
dest = (void *)((char *)dest + 1);
dest_len--;
len++;
}
if ((flags & STR_ASCII) || !(SVAL(cli->outbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS)) {
if (!UNICODE_FLAG(cli, flags)) {
/* the server doesn't want unicode */
safe_strcpy(dest, src, dest_len);
len = strlen(dest);
@ -83,6 +88,7 @@ flags can have:
STR_CONVERT means convert from dos to unix codepage
STR_TERMINATE means the string in src is null terminated
STR_UNICODE means to force as unicode
STR_NOALIGN means don't do alignment
if STR_TERMINATE is set then src_len is ignored
src_len is the length of the source area in bytes
return the number of bytes occupied by the string in src
@ -95,13 +101,12 @@ int clistr_pull(struct cli_state *cli, char *dest, const void *src, int dest_len
dest_len = sizeof(pstring);
}
if (!(flags & STR_ASCII) && clistr_align(cli->inbuf, src)) {
if (clistr_align(cli, src, flags)) {
src = (const void *)((const char *)src + 1);
if (src_len > 0) src_len--;
}
if ((flags & STR_ASCII) ||
(!(flags & STR_UNICODE) && !(SVAL(cli->inbuf, smb_flg2) & FLAGS2_UNICODE_STRINGS))) {
if (!UNICODE_FLAG(cli, flags)) {
/* the server doesn't want unicode */
if (flags & STR_TERMINATE) {
safe_strcpy(dest, src, dest_len);
@ -141,8 +146,8 @@ return an alignment of either 0 or 1
if unicode is not negotiated then return 0
otherwise return 1 if offset is off
****************************************************************************/
int clistr_align(const void *buf, const void *p)
int clistr_align(struct cli_state *cli, const void *p, int flags)
{
if (!(SVAL(buf, smb_flg2) & FLAGS2_UNICODE_STRINGS)) return 0;
return PTR_DIFF(p, buf) & 1;
if ((flags & STR_NOALIGN) || !UNICODE_FLAG(cli, flags)) return 0;
return PTR_DIFF(p, cli->outbuf) & 1;
}

18
source/smbd/negprot.c
View File

@ -177,6 +177,7 @@ static int reply_nt1(char *outbuf)
struct cli_state *cli = NULL;
char cryptkey[8];
char crypt_len = 0;
char *p;
if (lp_security() == SEC_SERVER) {
cli = server_cryptkey();
@ -215,18 +216,10 @@ static int reply_nt1(char *outbuf)
if (lp_security() >= SEC_USER) secword |= 1;
if (doencrypt) secword |= 2;
/* decide where (if) to put the encryption challenge, and
follow it with the OEM'd domain name
*/
data_len = crypt_len + strlen(global_myworkgroup) + 1;
set_message(outbuf,17,data_len,True);
pstrcpy(smb_buf(outbuf)+crypt_len, global_myworkgroup);
set_message(outbuf,17,0,True);
CVAL(outbuf,smb_vwv1) = secword;
SSVALS(outbuf,smb_vwv16+1,crypt_len);
if (doencrypt)
memcpy(smb_buf(outbuf), cryptkey, 8);
Protocol = PROTOCOL_NT1;
@ -240,6 +233,13 @@ static int reply_nt1(char *outbuf)
SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60);
SSVAL(outbuf,smb_vwv17,data_len); /* length of challenge+domain strings */
p = smb_buf(outbuf);
if (doencrypt) memcpy(p, cryptkey, 8);
p += 8;
p += srvstr_push(outbuf, p, global_myworkgroup, -1,
STR_UNICODE|STR_CONVERT|STR_TERMINATE|STR_NOALIGN);
set_message_end(outbuf, p);
return (smb_len(outbuf)+4);
}

38
source/smbd/srvstr.c
View File

@ -23,7 +23,20 @@
#include "includes.h"
#define UNICODE_FLAG(buf) (SVAL(buf, smb_flg2) & FLAGS2_UNICODE_STRINGS)
#define UNICODE_FLAG(buf, flags) (!(flags & STR_ASCII) && \
((flags & STR_UNICODE || \
(SVAL(buf, smb_flg2) & FLAGS2_UNICODE_STRINGS))))
/****************************************************************************
return an alignment of either 0 or 1
if unicode is not negotiated then return 0
otherwise return 1 if offset is off
****************************************************************************/
static int srvstr_align(void *inbuf, int offset, int flags)
{
if ((flags & STR_NOALIGN) || !UNICODE_FLAG(inbuf, flags)) return 0;
return offset & 1;
}
/****************************************************************************
copy a string from a char* src to a unicode or ascii
@ -35,6 +48,8 @@ flags can have:
STR_CONVERT means convert from unix to dos codepage
STR_UPPER means uppercase in the destination
STR_ASCII use ascii even with unicode servers
STR_UNICODE means to force as unicode
STR_NOALIGN means don't do alignment
dest_len is the maximum length allowed in the destination. If dest_len
is -1 then no maxiumum is used
****************************************************************************/
@ -47,14 +62,14 @@ int srvstr_push(void *outbuf, void *dest, const char *src, int dest_len, int fla
dest_len = sizeof(pstring);
}
if (!(flags & STR_ASCII) && srvstr_align(outbuf, PTR_DIFF(dest, outbuf))) {
if (srvstr_align(outbuf, PTR_DIFF(dest, outbuf), flags)) {
*(char *)dest = 0;
dest = (void *)((char *)dest + 1);
dest_len--;
len++;
}
if ((flags & STR_ASCII) || !UNICODE_FLAG(outbuf)) {
if (!UNICODE_FLAG(outbuf, flags)) {
/* the client doesn't want unicode */
safe_strcpy(dest, src, dest_len);
len = strlen(dest);
@ -85,6 +100,7 @@ flags can have:
STR_CONVERT means convert from dos to unix codepage
STR_TERMINATE means the string in src is null terminated
STR_UNICODE means to force as unicode
STR_NOALIGN means don't do alignment
if STR_TERMINATE is set then src_len is ignored
src_len is the length of the source area in bytes
return the number of bytes occupied by the string in src
@ -97,12 +113,12 @@ int srvstr_pull(void *inbuf, char *dest, const void *src, int dest_len, int src_
dest_len = sizeof(pstring);
}
if (!(flags & STR_ASCII) && srvstr_align(inbuf, PTR_DIFF(src, inbuf))) {
if (srvstr_align(inbuf, PTR_DIFF(src, inbuf), flags)) {
src = (void *)((char *)src + 1);
if (src_len > 0) src_len--;
}
if ((flags & STR_ASCII) || (!(flags & STR_UNICODE) && !UNICODE_FLAG(inbuf))) {
if (!UNICODE_FLAG(inbuf, flags)) {
/* the server doesn't want unicode */
if (flags & STR_TERMINATE) {
safe_strcpy(dest, src, dest_len);
@ -134,18 +150,6 @@ int srvstr_pull(void *inbuf, char *dest, const void *src, int dest_len, int src_
return len;
}
/****************************************************************************
return an alignment of either 0 or 1
if unicode is not negotiated then return 0
otherwise return 1 if offset is off
****************************************************************************/
int srvstr_align(void *inbuf, int offset)
{
if (!UNICODE_FLAG(inbuf)) return 0;
return offset & 1;
}
/****************************************************************************
these are useful for replacing all those StrnCpy() ops for copying data
to/from the wire