1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
samba-mirror/source4/ntp_signd/ntp_signd.c
Andrew Bartlett fc13489c91 build: Build with system md5.h on OpenIndiana
This changes (again...) our system md5 detection to cope with how
OpenIndiana does md5.  I'm becoming increasingly convinced this isn't
worth our while (we should have just done samba_md5...), but for now
this change seems to work on FreeBSD, OpenIndiana and Linux with
libbsd.

This needs us to rename struct MD5Context -> MD5_CTX, but we provide a
config.h define to rename the type bad if MD5_CTX does not exist (it does
however exist in the md5.h from libbsd).

Andrew Bartlett

Signed-off-by: Andrew Bartlett <abartlet@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>

Autobuild-User(master): Jeremy Allison <jra@samba.org>
Autobuild-Date(master): Wed Jun 19 21:32:36 CEST 2013 on sn-devel-104
2013-06-19 21:32:36 +02:00

559 lines
16 KiB
C

/*
Unix SMB/CIFS implementation.
NTP packet signing server
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
Copyright (C) Andrew Tridgell 2005
Copyright (C) Stefan Metzmacher 2005
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "smbd/service_task.h"
#include "smbd/service.h"
#include "smbd/service_stream.h"
#include "smbd/process_model.h"
#include "lib/stream/packet.h"
#include "lib/tsocket/tsocket.h"
#include "libcli/util/tstream.h"
#include "librpc/gen_ndr/ndr_ntp_signd.h"
#include "param/param.h"
#include "dsdb/samdb/samdb.h"
#include "auth/auth.h"
#include "libcli/security/security.h"
#include "libcli/ldap/ldap_ndr.h"
#include <ldb.h>
#include <ldb_errors.h>
#include "../lib/crypto/md5.h"
#include "system/network.h"
#include "system/passwd.h"
NTSTATUS server_service_ntp_signd_init(void);
/*
top level context structure for the ntp_signd server
*/
struct ntp_signd_server {
struct task_server *task;
struct ldb_context *samdb;
};
/*
state of an open connection
*/
struct ntp_signd_connection {
/* stream connection we belong to */
struct stream_connection *conn;
/* the ntp_signd_server the connection belongs to */
struct ntp_signd_server *ntp_signd;
struct tstream_context *tstream;
struct tevent_queue *send_queue;
};
static void ntp_signd_terminate_connection(struct ntp_signd_connection *ntp_signd_conn, const char *reason)
{
stream_terminate_connection(ntp_signd_conn->conn, reason);
}
static NTSTATUS signing_failure(struct ntp_signd_connection *ntp_signdconn,
TALLOC_CTX *mem_ctx,
DATA_BLOB *output,
uint32_t packet_id)
{
struct signed_reply signed_reply;
enum ndr_err_code ndr_err;
signed_reply.op = SIGNING_FAILURE;
signed_reply.packet_id = packet_id;
signed_reply.signed_packet = data_blob(NULL, 0);
ndr_err = ndr_push_struct_blob(output, mem_ctx, &signed_reply,
(ndr_push_flags_fn_t)ndr_push_signed_reply);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(1,("failed to push ntp error reply\n"));
return ndr_map_error2ntstatus(ndr_err);
}
return NT_STATUS_OK;
}
/*
receive a full packet on a NTP_SIGND connection
*/
static NTSTATUS ntp_signd_process(struct ntp_signd_connection *ntp_signd_conn,
TALLOC_CTX *mem_ctx,
DATA_BLOB *input,
DATA_BLOB *output)
{
const struct dom_sid *domain_sid;
struct dom_sid *sid;
struct sign_request sign_request;
struct signed_reply signed_reply;
enum ndr_err_code ndr_err;
struct ldb_result *res;
const char *attrs[] = { "unicodePwd", "userAccountControl", "cn", NULL };
MD5_CTX ctx;
struct samr_Password *nt_hash;
uint32_t user_account_control;
int ret;
ndr_err = ndr_pull_struct_blob_all(input, mem_ctx,
&sign_request,
(ndr_pull_flags_fn_t)ndr_pull_sign_request);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(1,("failed to parse ntp signing request\n"));
dump_data(1, input->data, input->length);
return ndr_map_error2ntstatus(ndr_err);
}
/* We need to implement 'check signature' and 'request server
* to sign' operations at some point */
if (sign_request.op != SIGN_TO_CLIENT) {
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
/* We need to implement 'check signature' and 'request server
* to sign' operations at some point */
if (sign_request.version != NTP_SIGND_PROTOCOL_VERSION_0) {
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
domain_sid = samdb_domain_sid(ntp_signd_conn->ntp_signd->samdb);
if (domain_sid == NULL) {
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
/* The top bit is a 'key selector' */
sid = dom_sid_add_rid(mem_ctx, domain_sid,
sign_request.key_id & 0x7FFFFFFF);
if (sid == NULL) {
talloc_free(mem_ctx);
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
ret = ldb_search(ntp_signd_conn->ntp_signd->samdb, mem_ctx,
&res,
ldb_get_default_basedn(ntp_signd_conn->ntp_signd->samdb),
LDB_SCOPE_SUBTREE,
attrs,
"(&(objectSid=%s)(objectClass=user))",
ldap_encode_ndr_dom_sid(mem_ctx, sid));
if (ret != LDB_SUCCESS) {
DEBUG(2, ("Failed to search for SID %s in SAM for NTP signing: "
"%s\n",
dom_sid_string(mem_ctx, sid),
ldb_errstring(ntp_signd_conn->ntp_signd->samdb)));
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
if (res->count == 0) {
DEBUG(2, ("Failed to find SID %s in SAM for NTP signing\n",
dom_sid_string(mem_ctx, sid)));
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
} else if (res->count != 1) {
DEBUG(1, ("Found SID %s %u times in SAM for NTP signing\n",
dom_sid_string(mem_ctx, sid), res->count));
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
user_account_control = ldb_msg_find_attr_as_uint(res->msgs[0],
"userAccountControl",
0);
if (user_account_control & UF_ACCOUNTDISABLE) {
DEBUG(1, ("Account %s for SID [%s] is disabled\n",
ldb_dn_get_linearized(res->msgs[0]->dn),
dom_sid_string(mem_ctx, sid)));
return NT_STATUS_ACCESS_DENIED;
}
if (!(user_account_control & (UF_INTERDOMAIN_TRUST_ACCOUNT|UF_SERVER_TRUST_ACCOUNT|UF_WORKSTATION_TRUST_ACCOUNT))) {
DEBUG(1, ("Account %s for SID [%s] is not a trust account\n",
ldb_dn_get_linearized(res->msgs[0]->dn),
dom_sid_string(mem_ctx, sid)));
return NT_STATUS_ACCESS_DENIED;
}
nt_hash = samdb_result_hash(mem_ctx, res->msgs[0], "unicodePwd");
if (!nt_hash) {
DEBUG(1, ("No unicodePwd found on record of SID %s "
"for NTP signing\n", dom_sid_string(mem_ctx, sid)));
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
/* Generate the reply packet */
signed_reply.packet_id = sign_request.packet_id;
signed_reply.op = SIGNING_SUCCESS;
signed_reply.signed_packet = data_blob_talloc(mem_ctx,
NULL,
sign_request.packet_to_sign.length + 20);
if (!signed_reply.signed_packet.data) {
return signing_failure(ntp_signd_conn,
mem_ctx,
output,
sign_request.packet_id);
}
memcpy(signed_reply.signed_packet.data, sign_request.packet_to_sign.data, sign_request.packet_to_sign.length);
SIVAL(signed_reply.signed_packet.data, sign_request.packet_to_sign.length, sign_request.key_id);
/* Sign the NTP response with the unicodePwd */
MD5Init(&ctx);
MD5Update(&ctx, nt_hash->hash, sizeof(nt_hash->hash));
MD5Update(&ctx, sign_request.packet_to_sign.data, sign_request.packet_to_sign.length);
MD5Final(signed_reply.signed_packet.data + sign_request.packet_to_sign.length + 4, &ctx);
/* Place it into the packet for the wire */
ndr_err = ndr_push_struct_blob(output, mem_ctx, &signed_reply,
(ndr_push_flags_fn_t)ndr_push_signed_reply);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(1,("failed to push ntp error reply\n"));
return ndr_map_error2ntstatus(ndr_err);
}
return NT_STATUS_OK;
}
/*
called on a tcp recv
*/
static void ntp_signd_recv(struct stream_connection *conn, uint16_t flags)
{
struct ntp_signd_connection *ntp_signd_conn = talloc_get_type(conn->private_data,
struct ntp_signd_connection);
ntp_signd_terminate_connection(ntp_signd_conn,
"ntp_signd_recv: called");
}
/*
called when we can write to a connection
*/
static void ntp_signd_send(struct stream_connection *conn, uint16_t flags)
{
struct ntp_signd_connection *ntp_signd_conn = talloc_get_type(conn->private_data,
struct ntp_signd_connection);
/* this should never be triggered! */
ntp_signd_terminate_connection(ntp_signd_conn,
"ntp_signd_send: called");
}
struct ntp_signd_call {
struct ntp_signd_connection *ntp_signd_conn;
DATA_BLOB in;
DATA_BLOB out;
uint8_t out_hdr[4];
struct iovec out_iov[2];
};
static void ntp_signd_call_writev_done(struct tevent_req *subreq);
static void ntp_signd_call_loop(struct tevent_req *subreq)
{
struct ntp_signd_connection *ntp_signd_conn = tevent_req_callback_data(subreq,
struct ntp_signd_connection);
struct ntp_signd_call *call;
NTSTATUS status;
call = talloc(ntp_signd_conn, struct ntp_signd_call);
if (call == NULL) {
ntp_signd_terminate_connection(ntp_signd_conn,
"ntp_signd_call_loop: "
"no memory for ntp_signd_call");
return;
}
call->ntp_signd_conn = ntp_signd_conn;
status = tstream_read_pdu_blob_recv(subreq,
call,
&call->in);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
const char *reason;
reason = talloc_asprintf(call, "ntp_signd_call_loop: "
"tstream_read_pdu_blob_recv() - %s",
nt_errstr(status));
if (reason == NULL) {
reason = nt_errstr(status);
}
ntp_signd_terminate_connection(ntp_signd_conn, reason);
return;
}
DEBUG(10,("Received NTP TCP packet of length %lu from %s\n",
(long) call->in.length,
tsocket_address_string(ntp_signd_conn->conn->remote_address, call)));
/* skip length header */
call->in.data +=4;
call->in.length -= 4;
status = ntp_signd_process(ntp_signd_conn,
call,
&call->in,
&call->out);
if (! NT_STATUS_IS_OK(status)) {
const char *reason;
reason = talloc_asprintf(call, "ntp_signd_process failed: %s",
nt_errstr(status));
if (reason == NULL) {
reason = nt_errstr(status);
}
ntp_signd_terminate_connection(ntp_signd_conn, reason);
return;
}
/* First add the length of the out buffer */
RSIVAL(call->out_hdr, 0, call->out.length);
call->out_iov[0].iov_base = (char *) call->out_hdr;
call->out_iov[0].iov_len = 4;
call->out_iov[1].iov_base = (char *) call->out.data;
call->out_iov[1].iov_len = call->out.length;
subreq = tstream_writev_queue_send(call,
ntp_signd_conn->conn->event.ctx,
ntp_signd_conn->tstream,
ntp_signd_conn->send_queue,
call->out_iov, 2);
if (subreq == NULL) {
ntp_signd_terminate_connection(ntp_signd_conn, "ntp_signd_call_loop: "
"no memory for tstream_writev_queue_send");
return;
}
tevent_req_set_callback(subreq, ntp_signd_call_writev_done, call);
/*
* The NTP tcp pdu's has the length as 4 byte (initial_read_size),
* packet_full_request_u32 provides the pdu length then.
*/
subreq = tstream_read_pdu_blob_send(ntp_signd_conn,
ntp_signd_conn->conn->event.ctx,
ntp_signd_conn->tstream,
4, /* initial_read_size */
packet_full_request_u32,
ntp_signd_conn);
if (subreq == NULL) {
ntp_signd_terminate_connection(ntp_signd_conn, "ntp_signd_call_loop: "
"no memory for tstream_read_pdu_blob_send");
return;
}
tevent_req_set_callback(subreq, ntp_signd_call_loop, ntp_signd_conn);
}
static void ntp_signd_call_writev_done(struct tevent_req *subreq)
{
struct ntp_signd_call *call = tevent_req_callback_data(subreq,
struct ntp_signd_call);
int sys_errno;
int rc;
rc = tstream_writev_queue_recv(subreq, &sys_errno);
TALLOC_FREE(subreq);
if (rc == -1) {
const char *reason;
reason = talloc_asprintf(call, "ntp_signd_call_writev_done: "
"tstream_writev_queue_recv() - %d:%s",
sys_errno, strerror(sys_errno));
if (!reason) {
reason = "ntp_signd_call_writev_done: "
"tstream_writev_queue_recv() failed";
}
ntp_signd_terminate_connection(call->ntp_signd_conn, reason);
return;
}
/* We don't care about errors */
talloc_free(call);
}
/*
called when we get a new connection
*/
static void ntp_signd_accept(struct stream_connection *conn)
{
struct ntp_signd_server *ntp_signd = talloc_get_type(conn->private_data,
struct ntp_signd_server);
struct ntp_signd_connection *ntp_signd_conn;
struct tevent_req *subreq;
int rc;
ntp_signd_conn = talloc_zero(conn, struct ntp_signd_connection);
if (ntp_signd_conn == NULL) {
stream_terminate_connection(conn,
"ntp_signd_accept: out of memory");
return;
}
ntp_signd_conn->send_queue = tevent_queue_create(conn,
"ntp_signd_accept");
if (ntp_signd_conn->send_queue == NULL) {
stream_terminate_connection(conn,
"ntp_signd_accept: out of memory");
return;
}
TALLOC_FREE(conn->event.fde);
rc = tstream_bsd_existing_socket(ntp_signd_conn,
socket_get_fd(conn->socket),
&ntp_signd_conn->tstream);
if (rc < 0) {
stream_terminate_connection(conn,
"ntp_signd_accept: out of memory");
return;
}
ntp_signd_conn->conn = conn;
ntp_signd_conn->ntp_signd = ntp_signd;
conn->private_data = ntp_signd_conn;
/*
* The NTP tcp pdu's has the length as 4 byte (initial_read_size),
* packet_full_request_u32 provides the pdu length then.
*/
subreq = tstream_read_pdu_blob_send(ntp_signd_conn,
ntp_signd_conn->conn->event.ctx,
ntp_signd_conn->tstream,
4, /* initial_read_size */
packet_full_request_u32,
ntp_signd_conn);
if (subreq == NULL) {
ntp_signd_terminate_connection(ntp_signd_conn,
"ntp_signd_accept: "
"no memory for tstream_read_pdu_blob_send");
return;
}
tevent_req_set_callback(subreq, ntp_signd_call_loop, ntp_signd_conn);
}
static const struct stream_server_ops ntp_signd_stream_ops = {
.name = "ntp_signd",
.accept_connection = ntp_signd_accept,
.recv_handler = ntp_signd_recv,
.send_handler = ntp_signd_send
};
/*
startup the ntp_signd task
*/
static void ntp_signd_task_init(struct task_server *task)
{
struct ntp_signd_server *ntp_signd;
NTSTATUS status;
const struct model_ops *model_ops;
const char *address;
if (!directory_create_or_exist_strict(lpcfg_ntp_signd_socket_directory(task->lp_ctx), geteuid(), 0750)) {
char *error = talloc_asprintf(task, "Cannot create NTP signd pipe directory: %s",
lpcfg_ntp_signd_socket_directory(task->lp_ctx));
task_server_terminate(task,
error, true);
return;
}
/* within the ntp_signd task we want to be a single process, so
ask for the single process model ops and pass these to the
stream_setup_socket() call. */
model_ops = process_model_startup("single");
if (!model_ops) {
DEBUG(0,("Can't find 'single' process model_ops\n"));
return;
}
task_server_set_title(task, "task[ntp_signd]");
ntp_signd = talloc(task, struct ntp_signd_server);
if (ntp_signd == NULL) {
task_server_terminate(task, "ntp_signd: out of memory", true);
return;
}
ntp_signd->task = task;
/* Must be system to get at the password hashes */
ntp_signd->samdb = samdb_connect(ntp_signd, task->event_ctx, task->lp_ctx, system_session(task->lp_ctx), 0);
if (ntp_signd->samdb == NULL) {
task_server_terminate(task, "ntp_signd failed to open samdb", true);
return;
}
address = talloc_asprintf(ntp_signd, "%s/socket", lpcfg_ntp_signd_socket_directory(task->lp_ctx));
status = stream_setup_socket(ntp_signd->task,
ntp_signd->task->event_ctx,
ntp_signd->task->lp_ctx,
model_ops,
&ntp_signd_stream_ops,
"unix", address, NULL,
lpcfg_socket_options(ntp_signd->task->lp_ctx),
ntp_signd);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to bind to %s - %s\n",
address, nt_errstr(status)));
return;
}
}
/* called at smbd startup - register ourselves as a server service */
NTSTATUS server_service_ntp_signd_init(void)
{
return register_server_service("ntp_signd", ntp_signd_task_init);
}