#include "includes.h"
#include "system/filesys.h"
#include "lib/cmdline/popt_common.h"
-#include "lib/ldb/include/ldb.h"
+#include <ldb.h>
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
+#include "auth/gensec/gensec_internal.h" /* TODO: remove this */
#include "auth/auth.h"
#include "librpc/gen_ndr/ndr_netlogon.h"
#include "auth/auth_sam.h"
#include "lib/messaging/irpc.h"
#include "auth/ntlmssp/ntlmssp.h"
#include "param/param.h"
+#include "lib/util/base64.h"
+#include "lib/util/xfile.h"
#define INITIAL_BUFFER_SIZE 300
#define MAX_BUFFER_SIZE 63000
static const char *opt_password;
static int opt_multiplex;
static int use_cached_creds;
+static int opt_allow_mschapv2;
static void mux_printf(unsigned int mux_id, const char *format, ...) PRINTF_ATTRIBUTE(2, 3);
return true;
}
-/**
- * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
- **/
-static DATA_BLOB base64_decode_data_blob(TALLOC_CTX *mem_ctx, const char *s)
-{
- DATA_BLOB ret = data_blob_talloc(mem_ctx, s, strlen(s)+1);
- ret.length = ldb_base64_decode((char *)ret.data);
- return ret;
-}
-
-/**
- * Encode a base64 string into a talloc()ed string caller to free.
- **/
-static char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data)
-{
- return ldb_base64_encode(mem_ctx, (const char *)data.data, data.length);
-}
-
-/**
- * Decode a base64 string in-place - wrapper for the above
- **/
-static void base64_decode_inplace(char *s)
-{
- ldb_base64_decode(s);
-}
-
-
/* Authenticate a user with a plaintext password */
if (!mem_ctx) {
nt_status = NT_STATUS_NO_MEMORY;
} else {
+ uint32_t logon_parameters = 0;
E_md4hash(opt_password, nt_pw.hash);
if (E_deshash(opt_password, lm_pw.hash)) {
}
nt_pwd = &nt_pw;
+ if (opt_allow_mschapv2) {
+ logon_parameters |= MSV1_0_ALLOW_MSVCHAPV2;
+ }
nt_status = ntlm_password_check(mem_ctx,
- lp_lanman_auth(lp_ctx),
- lp_ntlm_auth(lp_ctx),
+ lpcfg_lanman_auth(lp_ctx),
+ lpcfg_ntlm_auth(lp_ctx),
+ logon_parameters |
MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT |
MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT,
challenge,
if (NT_STATUS_IS_OK(nt_status)) {
if (unix_name) {
- asprintf(unix_name,
- "%s%c%s", domain,
- *lp_winbind_separator(lp_ctx),
- username);
+ if (asprintf(unix_name, "%s%c%s", domain,
+ *lpcfg_winbind_separator(lp_ctx),
+ username) < 0) {
+ nt_status = NT_STATUS_NO_MEMORY;
+ }
}
} else {
DEBUG(3, ("Login for user [%s]\\[%s]@[%s] failed due to [%s]\n",
}
if (strlen(buf) > 3) {
- in = base64_decode_data_blob(NULL, buf + 3);
+ in = base64_decode_data_blob(buf + 3);
} else {
in = data_blob(NULL, 0);
}
static const char *get_password(struct cli_credentials *credentials)
{
char *password = NULL;
-
+ void *cb = cli_credentials_callback_data_void(credentials);
+
/* Ask for a password */
- mux_printf((unsigned int)(uintptr_t)credentials->priv_data, "PW\n");
- credentials->priv_data = NULL;
+ mux_printf((unsigned int)(uintptr_t)cb, "PW\n");
+ cli_credentials_set_callback_data(credentials, NULL);
manage_squid_request(cmdline_lp_ctx, NUM_HELPER_MODES /* bogus */, manage_gensec_get_pw_request, (void **)&password);
return password;
};
struct gensec_ntlm_state *state;
struct tevent_context *ev;
- struct messaging_context *msg;
+ struct imessaging_context *msg;
NTSTATUS nt_status;
bool first = false;
mux_printf(mux_id, "OK\n");
return;
}
- in = base64_decode_data_blob(NULL, buf + 3);
+ in = base64_decode_data_blob(buf + 3);
} else {
in = data_blob(NULL, 0);
}
case NTLMSSP_CLIENT_1:
/* setup the client side */
- nt_status = gensec_client_start(NULL, &state->gensec_state, ev,
- lp_gensec_settings(NULL, lp_ctx));
+ nt_status = gensec_client_start(NULL, &state->gensec_state,
+ lpcfg_gensec_settings(NULL, lp_ctx));
if (!NT_STATUS_IS_OK(nt_status)) {
talloc_free(mem_ctx);
exit(1);
case SQUID_2_5_NTLMSSP:
{
const char *winbind_method[] = { "winbind", NULL };
- struct auth_context *auth_context;
+ struct auth4_context *auth_context;
- msg = messaging_client_init(state, lp_messaging_path(state, lp_ctx),
- lp_iconv_convenience(lp_ctx), ev);
+ msg = imessaging_client_init(state, lp_ctx, ev);
if (!msg) {
talloc_free(mem_ctx);
exit(1);
ev,
msg,
lp_ctx,
+ NULL,
&auth_context);
if (!NT_STATUS_IS_OK(nt_status)) {
exit(1);
}
- if (!NT_STATUS_IS_OK(gensec_server_start(state, ev,
- lp_gensec_settings(state, lp_ctx),
+ if (!NT_STATUS_IS_OK(gensec_server_start(state,
+ lpcfg_gensec_settings(state, lp_ctx),
auth_context, &state->gensec_state))) {
talloc_free(mem_ctx);
exit(1);
if (state->set_password) {
cli_credentials_set_password(creds, state->set_password, CRED_SPECIFIED);
} else {
+ void *cb = (void*)(uintptr_t)mux_id;
+ cli_credentials_set_callback_data(creds, cb);
cli_credentials_set_password_callback(creds, get_password);
- creds->priv_data = (void*)(uintptr_t)mux_id;
}
if (opt_workstation) {
cli_credentials_set_workstation(creds, opt_workstation, CRED_SPECIFIED);
char *grouplist = NULL;
struct auth_session_info *session_info;
- nt_status = gensec_session_info(state->gensec_state, &session_info);
+ nt_status = gensec_session_info(state->gensec_state, mem_ctx, &session_info);
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(1, ("gensec_session_info failed: %s\n", nt_errstr(nt_status)));
mux_printf(mux_id, "BH %s\n", nt_errstr(nt_status));
for (i=0; i<session_info->security_token->num_sids; i++) {
struct security_token *token = session_info->security_token;
const char *sidstr = dom_sid_string(session_info,
- token->sids[i]);
+ &token->sids[i]);
grouplist = talloc_asprintf_append_buffer(grouplist, "%s,", sidstr);
}
if (strncmp(buf, "GK", 2) == 0) {
char *base64_key;
DEBUG(10, ("Requested session key\n"));
- nt_status = gensec_session_key(state->gensec_state, &session_key);
+ nt_status = gensec_session_key(state->gensec_state, mem_ctx, &session_key);
if(!NT_STATUS_IS_OK(nt_status)) {
DEBUG(1, ("gensec_session_key failed: %s\n", nt_errstr(nt_status)));
mux_printf(mux_id, "BH No session key\n");
return;
} else {
base64_key = base64_encode_data_blob(state, session_key);
+ SMB_ASSERT(base64_key != NULL);
mux_printf(mux_id, "GK %s\n", base64_key);
talloc_free(base64_key);
}
}
if (strncmp(buf, "GF", 2) == 0) {
- struct gensec_ntlmssp_state *gensec_ntlmssp_state;
+ struct ntlmssp_state *ntlmssp_state;
uint32_t neg_flags;
- gensec_ntlmssp_state = talloc_get_type(state->gensec_state->private_data,
- struct gensec_ntlmssp_state);
- neg_flags = gensec_ntlmssp_state->neg_flags;
+ ntlmssp_state = talloc_get_type(state->gensec_state->private_data,
+ struct ntlmssp_state);
+ neg_flags = ntlmssp_state->neg_flags;
DEBUG(10, ("Requested negotiated feature flags\n"));
mux_printf(mux_id, "GF 0x%08x\n", neg_flags);
return;
}
- nt_status = gensec_update(state->gensec_state, mem_ctx, in, &out);
+ nt_status = gensec_update_ev(state->gensec_state, mem_ctx, ev, in, &out);
/* don't leak 'bad password'/'no such user' info to the network client */
- nt_status = auth_nt_status_squash(nt_status);
+ nt_status = nt_status_squash(nt_status);
if (out.length) {
out_base64 = base64_encode_data_blob(mem_ctx, out);
+ SMB_ASSERT(out_base64 != NULL);
} else {
out_base64 = NULL;
}
} else if /* OK */ (state->gensec_state->gensec_role == GENSEC_SERVER) {
struct auth_session_info *session_info;
- nt_status = gensec_session_info(state->gensec_state, &session_info);
+ nt_status = gensec_session_info(state->gensec_state, mem_ctx, &session_info);
if (!NT_STATUS_IS_OK(nt_status)) {
reply_code = "BH Failed to retrive session info";
reply_arg = nt_errstr(nt_status);
reply_code = "AF";
reply_arg = talloc_asprintf(state->gensec_state,
- "%s%s%s", session_info->server_info->domain_name,
- lp_winbind_separator(lp_ctx), session_info->server_info->account_name);
+ "%s%s%s", session_info->info->domain_name,
+ lpcfg_winbind_separator(lp_ctx), session_info->info->account_name);
talloc_free(session_info);
}
} else if (state->gensec_state->gensec_role == GENSEC_CLIENT) {
} else if (plaintext_password) {
/* handle this request as plaintext */
if (!full_username) {
- if (asprintf(&full_username, "%s%c%s", domain, *lp_winbind_separator(lp_ctx), username) == -1) {
+ if (asprintf(&full_username, "%s%c%s", domain, *lpcfg_winbind_separator(lp_ctx), username) < 0) {
mux_printf(mux_id, "Error: Out of memory in asprintf!\n.\n");
return;
}
SAFE_FREE(domain);
if (!parse_ntlm_auth_domain_user(full_username, &username,
&domain,
- *lp_winbind_separator(lp_ctx))) {
+ *lpcfg_winbind_separator(lp_ctx))) {
/* username might be 'tainted', don't print into our new-line deleimianted stream */
mux_printf(mux_id, "Error: Could not parse into domain and username\n");
}
}
if (!domain) {
- domain = smb_xstrdup(lp_workgroup(lp_ctx));
+ domain = smb_xstrdup(lpcfg_workgroup(lp_ctx));
}
if (ntlm_server_1_lm_session_key)
local_pw_check_specified(lp_ctx,
username,
domain,
- lp_netbios_name(lp_ctx),
+ lpcfg_netbios_name(lp_ctx),
&challenge,
&lm_response,
&nt_response,
SAFE_FREE(error_string);
} else {
static char zeros[16];
- char *hex_lm_key;
- char *hex_user_session_key;
mux_printf(mux_id, "Authenticated: Yes\n");
&& lm_key.length
&& (memcmp(zeros, lm_key.data,
lm_key.length) != 0)) {
- hex_encode(lm_key.data,
- lm_key.length,
- &hex_lm_key);
+ char hex_lm_key[lm_key.length*2+1];
+ hex_encode_buf(hex_lm_key, lm_key.data,
+ lm_key.length);
mux_printf(mux_id, "LANMAN-Session-Key: %s\n", hex_lm_key);
- SAFE_FREE(hex_lm_key);
}
if (ntlm_server_1_user_session_key
&& user_session_key.length
&& (memcmp(zeros, user_session_key.data,
user_session_key.length) != 0)) {
- hex_encode(user_session_key.data,
- user_session_key.length,
- &hex_user_session_key);
+ char hex_user_session_key[
+ user_session_key.length*2+1];
+ hex_encode_buf(hex_user_session_key,
+ user_session_key.data,
+ user_session_key.length);
mux_printf(mux_id, "User-Session-Key: %s\n", hex_user_session_key);
- SAFE_FREE(hex_user_session_key);
}
}
}
}
}
-static void manage_squid_request(struct loadparm_context *lp_ctx, enum stdio_helper_mode helper_mode,
+static void manage_squid_request(struct loadparm_context *lp_ctx, enum stdio_helper_mode helper_mode,
stdio_helper_function fn, void **private2)
{
char *buf;
talloc_free(buf);
}
-static void squid_stream(struct loadparm_context *lp_ctx,
+static void squid_stream(struct loadparm_context *lp_ctx,
enum stdio_helper_mode stdio_mode,
stdio_helper_function fn) {
/* initialize FDescs */
OPT_REQUIRE_MEMBERSHIP,
OPT_MULTIPLEX,
OPT_USE_CACHED_CREDS,
+ OPT_ALLOW_MSCHAPV2,
};
int main(int argc, const char **argv)
{ "password", 0, POPT_ARG_STRING, &opt_password, OPT_PASSWORD, "User's plaintext password"},
{ "multiplex", 0, POPT_ARG_NONE, &opt_multiplex, OPT_MULTIPLEX, "Multiplex Mode"},
{ "use-cached-creds", 0, POPT_ARG_NONE, &use_cached_creds, OPT_USE_CACHED_CREDS, "silently ignored for compatibility reasons"},
+ { "allow-mschapv2", 0, POPT_ARG_NONE, &opt_allow_mschapv2, OPT_ALLOW_MSCHAPV2, "Explicitly allow MSCHAPv2" },
POPT_COMMON_SAMBA
POPT_COMMON_VERSION
{ NULL }
return 1;
}
- gensec_init(cmdline_lp_ctx);
+ gensec_init();
if (opt_domain == NULL) {
- opt_domain = lp_workgroup(cmdline_lp_ctx);
+ opt_domain = lpcfg_workgroup(cmdline_lp_ctx);
}
if (helper_protocol) {
}
if (opt_workstation == NULL) {
- opt_workstation = lp_netbios_name(cmdline_lp_ctx);
+ opt_workstation = lpcfg_netbios_name(cmdline_lp_ctx);
}
if (!opt_password) {
- opt_password = getpass("password: ");
+ char pwd[256] = {0};
+ int rc;
+
+ rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
+ if (rc == 0) {
+ opt_password = smb_xstrdup(pwd);
+ }
}
{
char *user;
- asprintf(&user, "%s%c%s", opt_domain, *lp_winbind_separator(cmdline_lp_ctx), opt_username);
+ if (asprintf(&user, "%s%c%s", opt_domain,
+ *lpcfg_winbind_separator(cmdline_lp_ctx),
+ opt_username) < 0) {
+ return 1;
+ }
if (!check_plaintext_auth(user, opt_password, true)) {
return 1;
}