size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
{
size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
*dest = NULL;
return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
}
static bool test_plaintext(enum ntlm_break break_which)
{
NTSTATUS nt_status;
uint32 flags = 0;
DATA_BLOB nt_response = data_blob_null;
DATA_BLOB lm_response = data_blob_null;
char *password;
smb_ucs2_t *nt_response_ucs2;
size_t converted_size;
uchar user_session_key[16];
uchar lm_key[16];
static const uchar zeros[8] = { 0, };
DATA_BLOB chall = data_blob(zeros, sizeof(zeros));
char *error_string;
ZERO_STRUCT(user_session_key);
flags |= WBFLAG_PAM_LMKEY;
flags |= WBFLAG_PAM_USER_SESSION_KEY;
if (!push_ucs2_talloc(talloc_tos(), &nt_response_ucs2, opt_password,
&converted_size))
{
DEBUG(0, ("push_ucs2_talloc failed!\n"));
exit(1);
}
nt_response.data = (unsigned char *)nt_response_ucs2;
nt_response.length = strlen_w(nt_response_ucs2)*sizeof(smb_ucs2_t);
if ((password = strupper_talloc(talloc_tos(), opt_password)) == NULL) {
DEBUG(0, ("strupper_talloc() failed!\n"));
exit(1);
}
if (!convert_string_talloc(talloc_tos(), CH_UNIX,
CH_DOS, password,
strlen(password)+1,
&lm_response.data,
&lm_response.length, True)) {
DEBUG(0, ("convert_string_talloc failed!\n"));
exit(1);
}
TALLOC_FREE(password);
switch (break_which) {
case BREAK_NONE:
break;
case BREAK_LM:
lm_response.data[0]++;
break;
case BREAK_NT:
nt_response.data[0]++;
break;
case NO_LM:
TALLOC_FREE(lm_response.data);
lm_response.length = 0;
break;
case NO_NT:
TALLOC_FREE(nt_response.data);
nt_response.length = 0;
break;
}
nt_status = contact_winbind_auth_crap(opt_username, opt_domain,
opt_workstation,
&chall,
&lm_response,
&nt_response,
flags,
lm_key,
user_session_key,
&error_string, NULL);
TALLOC_FREE(nt_response.data);
TALLOC_FREE(lm_response.data);
data_blob_free(&chall);
if (!NT_STATUS_IS_OK(nt_status)) {
d_printf("%s (0x%x)\n",
error_string,
NT_STATUS_V(nt_status));
SAFE_FREE(error_string);
return break_which == BREAK_NT;
}
return break_which != BREAK_NT;
}
size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
{
size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
*dest = NULL;
return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
}
static NTSTATUS is_valid_name(const smb_ucs2_t *fname, bool allow_wildcards, bool only_8_3)
{
smb_ucs2_t *str, *p;
size_t num_ucs2_chars;
NTSTATUS ret = NT_STATUS_OK;
if (!fname || !*fname)
return NT_STATUS_INVALID_PARAMETER;
/* . and .. are valid names. */
if (strcmp_wa(fname, ".")==0 || strcmp_wa(fname, "..")==0)
return NT_STATUS_OK;
if (only_8_3) {
ret = has_valid_83_chars(fname, allow_wildcards);
if (!NT_STATUS_IS_OK(ret))
return ret;
}
ret = has_illegal_chars(fname, allow_wildcards);
if (!NT_STATUS_IS_OK(ret))
return ret;
/* Name can't end in '.' or ' ' */
num_ucs2_chars = strlen_w(fname);
if (fname[num_ucs2_chars-1] == UCS2_CHAR('.') || fname[num_ucs2_chars-1] == UCS2_CHAR(' ')) {
return NT_STATUS_UNSUCCESSFUL;
}
str = strdup_w(fname);
/* Truncate copy after the first dot. */
p = strchr_w(str, UCS2_CHAR('.'));
if (p) {
*p = 0;
}
strupper_w(str);
p = &str[1];
switch(str[0])
{
case UCS2_CHAR('A'):
if(strcmp_wa(p, "UX") == 0)
ret = NT_STATUS_UNSUCCESSFUL;
break;
case UCS2_CHAR('C'):
if((strcmp_wa(p, "LOCK$") == 0)
|| (strcmp_wa(p, "ON") == 0)
|| (strcmp_wa(p, "OM1") == 0)
|| (strcmp_wa(p, "OM2") == 0)
|| (strcmp_wa(p, "OM3") == 0)
|| (strcmp_wa(p, "OM4") == 0)
)
ret = NT_STATUS_UNSUCCESSFUL;
break;
case UCS2_CHAR('L'):
if((strcmp_wa(p, "PT1") == 0)
|| (strcmp_wa(p, "PT2") == 0)
|| (strcmp_wa(p, "PT3") == 0)
)
ret = NT_STATUS_UNSUCCESSFUL;
break;
case UCS2_CHAR('N'):
if(strcmp_wa(p, "UL") == 0)
ret = NT_STATUS_UNSUCCESSFUL;
break;
case UCS2_CHAR('P'):
if(strcmp_wa(p, "RN") == 0)
ret = NT_STATUS_UNSUCCESSFUL;
break;
default:
break;
}
SAFE_FREE(str);
return ret;
}
int pe_find_version_info_cb(
PIMAGE_RESOURCE_DATA_ENTRY rsrc_data,
int rsrc_type,
int rsrc_id,
int rsrc_language,
PE* pe)
{
PVERSION_INFO version_info;
PVERSION_INFO string_file_info;
char key[64];
char value[256];
size_t version_info_offset;
if (rsrc_type == RESOURCE_TYPE_VERSION)
{
version_info_offset = pe_rva_to_offset(pe, rsrc_data->OffsetToData);
if (version_info_offset == 0)
return RESOURCE_CALLBACK_CONTINUE;
version_info = (PVERSION_INFO) (pe->data + version_info_offset);
if (strcmp_w(version_info->Key, "VS_VERSION_INFO") != 0)
return RESOURCE_CALLBACK_CONTINUE;
string_file_info = ADD_OFFSET(version_info, sizeof(VERSION_INFO) + 86);
while(strcmp_w(string_file_info->Key, "StringFileInfo") == 0)
{
PVERSION_INFO string_table = ADD_OFFSET(
string_file_info,
sizeof(VERSION_INFO) + 30);
string_file_info = ADD_OFFSET(
string_file_info,
string_file_info->Length);
string_file_info = ALIGN_NEXT_DWORD(string_file_info);
while (string_table < string_file_info)
{
PVERSION_INFO string = ADD_OFFSET(
string_table,
sizeof(VERSION_INFO) + 2 * (strlen_w(string_table->Key) + 1));
string_table = ADD_OFFSET(
string_table,
string_table->Length);
string_table = ALIGN_NEXT_DWORD(string_table);
while (string < string_table)
{
char* string_value = (char*) ADD_OFFSET(
string,
sizeof(VERSION_INFO) + 2 * (strlen_w(string->Key) + 1));
string_value = ALIGN_NEXT_DWORD(string_value);
strlcpy_w(key, string->Key, sizeof(key));
strlcpy_w(value, string_value, sizeof(value));
set_string(value, pe->object, "version_info[%s]", key);
string = ADD_OFFSET(string, string->Length);
string = ALIGN_NEXT_DWORD(string);
}
}
}
return RESOURCE_CALLBACK_ABORT;
}
return RESOURCE_CALLBACK_CONTINUE;
}
/* --------------------------------- */
size_t ucs2_to_charset_allocate(charset_t ch, char **dest, const ucs2_t *src)
{
size_t src_len = (strlen_w(src)) * sizeof(ucs2_t);
*dest = NULL;
return convert_string_allocate(CH_UCS2, ch, src, src_len, dest);
}
size_t ucs2_to_charset(charset_t ch, const ucs2_t *src, char *dest, size_t destlen)
{
size_t src_len = (strlen_w(src)) * sizeof(ucs2_t);
return convert_string(CH_UCS2, ch, src, src_len, dest, destlen);
}
static BOOL test_plaintext(enum ntlm_break break_which)
{
NTSTATUS nt_status;
uint32 flags = 0;
DATA_BLOB nt_response = data_blob(NULL, 0);
DATA_BLOB lm_response = data_blob(NULL, 0);
char *password;
uchar user_session_key[16];
uchar lm_key[16];
static const uchar zeros[8];
DATA_BLOB chall = data_blob(zeros, sizeof(zeros));
char *error_string;
ZERO_STRUCT(user_session_key);
flags |= WBFLAG_PAM_LMKEY;
flags |= WBFLAG_PAM_USER_SESSION_KEY;
if ((push_ucs2_allocate((smb_ucs2_t **)&nt_response.data, opt_password)) == -1) {
DEBUG(0, ("push_ucs2_allocate failed!\n"));
exit(1);
}
nt_response.length = strlen_w(((void *)nt_response.data))*sizeof(smb_ucs2_t);
password = strdup_upper(opt_password);
if ((convert_string_allocate(NULL, CH_UNIX,
CH_DOS, password,
strlen(password)+1,
(void**)&lm_response.data,True)) == -1) {
DEBUG(0, ("push_ascii_allocate failed!\n"));
exit(1);
}
SAFE_FREE(password);
lm_response.length = strlen(lm_response.data);
switch (break_which) {
case BREAK_NONE:
break;
case BREAK_LM:
lm_response.data[0]++;
break;
case BREAK_NT:
nt_response.data[0]++;
break;
case NO_LM:
SAFE_FREE(lm_response.data);
lm_response.length = 0;
break;
case NO_NT:
SAFE_FREE(nt_response.data);
nt_response.length = 0;
break;
}
nt_status = contact_winbind_auth_crap(opt_username, opt_domain,
opt_workstation,
&chall,
&lm_response,
&nt_response,
flags,
lm_key,
user_session_key,
&error_string, NULL);
SAFE_FREE(nt_response.data);
SAFE_FREE(lm_response.data);
data_blob_free(&chall);
if (!NT_STATUS_IS_OK(nt_status)) {
d_printf("%s (0x%x)\n",
error_string,
NT_STATUS_V(nt_status));
SAFE_FREE(error_string);
return break_which == BREAK_NT;
}
return break_which != BREAK_NT;
}
