view release on metacpan or  search on metacpan

deps/libgit2/deps/ntlmclient/ntlm.c  view on Meta::CPAN

int ntlm_client_set_version(
	ntlm_client *ntlm,
	uint8_t major,
	uint8_t minor,
	uint16_t build)
{
	NTLM_ASSERT_ARG(ntlm);

	ntlm->host_version.major = major;
	ntlm->host_version.minor = minor;
	ntlm->host_version.build = build;
	ntlm->host_version.reserved = 0x0f000000;

	ntlm->flags |= NTLM_ENABLE_HOSTVERSION;

	return 0;
}

#define reset(ptr) do { free(ptr); ptr = NULL; } while(0)

static void free_hostname(ntlm_client *ntlm)
{
	reset(ntlm->hostname);
	reset(ntlm->hostdomain);
	reset(ntlm->hostname_utf16);
	ntlm->hostname_utf16_len = 0;
}

int ntlm_client_set_hostname(
	ntlm_client *ntlm,
	const char *hostname,
	const char *domain)
{
	NTLM_ASSERT_ARG(ntlm);
	ENSURE_INITIALIZED(ntlm);

	free_hostname(ntlm);

	if (hostname && (ntlm->hostname = strdup(hostname)) == NULL) {
		ntlm_client_set_errmsg(ntlm, "out of memory");
		return -1;
	}

	if (domain && (ntlm->hostdomain = strdup(domain)) == NULL) {
		ntlm_client_set_errmsg(ntlm, "out of memory");
		return -1;
	}

	if (hostname && supports_unicode(ntlm) && !ntlm_unicode_utf8_to_16(
			&ntlm->hostname_utf16,
			&ntlm->hostname_utf16_len,
			ntlm,
			hostname,
			strlen(hostname)))
		return -1;

	return 0;
}

static void free_credentials(ntlm_client *ntlm)
{
	if (ntlm->password)
		ntlm_memzero(ntlm->password, strlen(ntlm->password));

	if (ntlm->password_utf16)
		ntlm_memzero(ntlm->password_utf16, ntlm->password_utf16_len);

	reset(ntlm->username);
	reset(ntlm->username_upper);
	reset(ntlm->userdomain);
	reset(ntlm->password);

	reset(ntlm->username_utf16);
	reset(ntlm->username_upper_utf16);
	reset(ntlm->userdomain_utf16);
	reset(ntlm->password_utf16);

	ntlm->username_utf16_len = 0;
	ntlm->username_upper_utf16_len = 0;
	ntlm->userdomain_utf16_len = 0;
	ntlm->password_utf16_len = 0;
}

int ntlm_client_set_credentials(
	ntlm_client *ntlm,
	const char *username,
	const char *domain,
	const char *password)
{
	NTLM_ASSERT_ARG(ntlm);
	ENSURE_INITIALIZED(ntlm);

	free_credentials(ntlm);

	if ((username && (ntlm->username = strdup(username)) == NULL) ||
		(domain && (ntlm->userdomain = strdup(domain)) == NULL) ||
		(password && (ntlm->password = strdup(password)) == NULL)) {
		ntlm_client_set_errmsg(ntlm, "out of memory");
		return -1;
	}

	if (username && supports_unicode(ntlm)) {
		if ((ntlm->username_upper = strdup(username)) == NULL) {
			ntlm_client_set_errmsg(ntlm, "out of memory");
			return -1;
		}
		utf8upr(ntlm->username_upper);

		if (!ntlm_unicode_utf8_to_16(
				&ntlm->username_utf16,
				&ntlm->username_utf16_len,
				ntlm,
				ntlm->username,
				strlen(ntlm->username)))
			return -1;

		if (!ntlm_unicode_utf8_to_16(
				&ntlm->username_upper_utf16,
				&ntlm->username_upper_utf16_len,
				ntlm,
				ntlm->username_upper,
				strlen(ntlm->username_upper)))
			return -1;
	}

	if (domain && supports_unicode(ntlm) && !ntlm_unicode_utf8_to_16(
			&ntlm->userdomain_utf16,
			&ntlm->userdomain_utf16_len,
			ntlm,
			ntlm->userdomain,
			strlen(ntlm->userdomain)))
		return -1;

	return 0;
}

int ntlm_client_set_target(ntlm_client *ntlm, const char *target)
{
	NTLM_ASSERT_ARG(ntlm);
	ENSURE_INITIALIZED(ntlm);

	free(ntlm->target);
	free(ntlm->target_utf16);

	ntlm->target = NULL;
	ntlm->target_utf16 = NULL;

	if (target) {
		if ((ntlm->target = strdup(target)) == NULL) {
			ntlm_client_set_errmsg(ntlm, "out of memory");
			return -1;
		}

deps/libgit2/deps/ntlmclient/ntlm.c  view on Meta::CPAN

	increment_size(&ntlm->response.len, ntlm_rep_len);

	session = NULL;
	session_len = 0;
	session_offset = ntlm->response.len;
	increment_size(&ntlm->response.len, session_len);

	if (ntlm->response.len == (size_t)-1) {
		ntlm_client_set_errmsg(ntlm, "message too large");
		return -1;
	}

	if ((ntlm->response.buf = calloc(1, ntlm->response.len)) == NULL) {
		ntlm_client_set_errmsg(ntlm, "out of memory");
		return -1;
	}

	if (!write_buf(ntlm, &ntlm->response,
			ntlm_client_signature, sizeof(ntlm_client_signature)) ||
		!write_int32(ntlm, &ntlm->response, 3) ||
		!write_bufinfo(ntlm, &ntlm->response, lm_rep_len, lm_rep_offset) ||
		!write_bufinfo(ntlm, &ntlm->response, ntlm_rep_len, ntlm_rep_offset) ||
		!write_bufinfo(ntlm, &ntlm->response, domain_len, domain_offset) ||
		!write_bufinfo(ntlm, &ntlm->response, username_len, username_offset) ||
		!write_bufinfo(ntlm, &ntlm->response, hostname_len, hostname_offset) ||
		!write_bufinfo(ntlm, &ntlm->response, session_len, session_offset) ||
		!write_int32(ntlm, &ntlm->response, flags) ||
		!write_buf(ntlm, &ntlm->response, domain, domain_len) ||
		!write_buf(ntlm, &ntlm->response, username, username_len) ||
		!write_buf(ntlm, &ntlm->response, hostname, hostname_len) ||
		!write_buf(ntlm, &ntlm->response, ntlm->lm_response, lm_rep_len) ||
		!write_buf(ntlm, &ntlm->response, ntlm_rep, ntlm_rep_len) ||
		!write_buf(ntlm, &ntlm->response, session, session_len))
		return -1;

	NTLM_ASSERT(ntlm, ntlm->response.pos == ntlm->response.len);

	ntlm->state = NTLM_STATE_COMPLETE;

	*out = ntlm->response.buf;
	*out_len = ntlm->response.len;

	return 0;
}

void ntlm_client_reset(ntlm_client *ntlm)
{
	if (!ntlm)
		return;

	ntlm->state = NTLM_STATE_NEGOTIATE;

	free_hostname(ntlm);

	memset(&ntlm->host_version, 0, sizeof(ntlm_version));

	reset(ntlm->target);
	reset(ntlm->target_utf16);
	ntlm->target_utf16_len = 0;

	free_credentials(ntlm);

	ntlm->nonce = 0;
	ntlm->timestamp = 0;

	memset(ntlm->lm_response, 0, NTLM_LM_RESPONSE_LEN);
	ntlm->lm_response_len = 0;

	memset(ntlm->ntlm_response, 0, NTLM_NTLM_RESPONSE_LEN);
	ntlm->ntlm_response_len = 0;

	reset(ntlm->ntlm2_response);
	ntlm->ntlm2_response_len = 0;

	reset(ntlm->negotiate.buf);
	ntlm->negotiate.pos = 0;
	ntlm->negotiate.len = 0;

	reset(ntlm->response.buf);
	ntlm->response.pos = 0;
	ntlm->response.len = 0;

	free(ntlm->challenge.target_info);
	free(ntlm->challenge.target);
	free(ntlm->challenge.target_domain);
	free(ntlm->challenge.target_domain_dns);
	free(ntlm->challenge.target_server);
	free(ntlm->challenge.target_server_dns);
	memset(&ntlm->challenge, 0, sizeof(ntlm_challenge));
}

void ntlm_client_free(ntlm_client *ntlm)
{
	if (!ntlm)
		return;

	ntlm_crypt_shutdown(ntlm);
	ntlm_unicode_shutdown(ntlm);

	ntlm_client_reset(ntlm);

	free(ntlm);
}