/*      $NetBSD: ntp_signd.c,v 1.5 2020/05/25 20:47:25 christos Exp $   */

/* Copyright 2008, Red Hat, Inc.
  Copyright 2008, Andrew Tridgell.
  Licenced under the same terms as NTP itself.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef HAVE_NTP_SIGND

#include "ntpd.h"
#include "ntp_io.h"
#include "ntp_stdlib.h"
#include "ntp_unixtime.h"
#include "ntp_control.h"
#include "ntp_string.h"

#include <stdio.h>
#include <stddef.h>
#ifdef HAVE_LIBSCF_H
#include <libscf.h>
#include <unistd.h>
#endif /* HAVE_LIBSCF_H */

#include <sys/un.h>

/* socket routines by tridge - from junkcode.samba.org */

/*
 connect to a unix domain socket
*/
static int
ux_socket_connect(const char *name)
{
       int fd;
       struct sockaddr_un addr;
       if (!name) {
               return -1;
       }

       ZERO(addr);
       addr.sun_family = AF_UNIX;
       strlcpy(addr.sun_path, name, sizeof(addr.sun_path));

       fd = socket(AF_UNIX, SOCK_STREAM, 0);
       if (fd == -1) {
               return -1;
       }

       if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
               close(fd);
               return -1;
       }

       return fd;
}


/*
 keep writing until its all sent
*/
static int
write_all(int fd, const void *buf, size_t len)
{
       size_t total = 0;
       while (len) {
               int n = write(fd, buf, len);
               if (n <= 0) return total;
               buf = n + (const char *)buf;
               len -= n;
               total += n;
       }
       return total;
}

/*
 keep reading until its all read
*/
static int
read_all(int fd, void *buf, size_t len)
{
       size_t total = 0;
       while (len) {
               int n = read(fd, buf, len);
               if (n <= 0) return total;
               buf = n + (char *)buf;
               len -= n;
               total += n;
       }
       return total;
}

/*
 send a packet in length prefix format
*/
static int
send_packet(int fd, const char *buf, uint32_t len)
{
       uint32_t net_len = htonl(len);
       if (write_all(fd, &net_len, sizeof(net_len)) != sizeof(net_len)) return -1;
       if (write_all(fd, buf, len) != len) return -1;
       return 0;
}

/*
 receive a packet in length prefix format
*/
static int
recv_packet(int fd, char **buf, uint32_t *len)
{
       if (read_all(fd, len, sizeof(*len)) != sizeof(*len)) return -1;
       *len = ntohl(*len);
       *buf = emalloc(*len);
       if (read_all(fd, *buf, *len) != *len) {
               free(*buf);
               *buf = NULL;
               return -1;
       }
       return 0;
}

void
send_via_ntp_signd(
       struct recvbuf *rbufp,  /* receive packet pointer */
       int     xmode,
       keyid_t xkeyid,
       int flags,
       struct pkt  *xpkt
       )
{

       /* We are here because it was detected that the client
        * sent an all-zero signature, and we therefore know
        * it's windows trying to talk to an AD server
        *
        * Because we don't want to dive into Samba's secrets
        * database just to find the long-term kerberos key
        * that is re-used as the NTP key, we instead hand the
        * packet over to Samba to sign, and return to us.
        *
        * The signing method Samba will use is described by
        * Microsoft in MS-SNTP, found here:
        * http://msdn.microsoft.com/en-us/library/cc212930.aspx
        */

       int fd, sendlen;
       struct samba_key_in {
               uint32_t version;
               uint32_t op;
               uint32_t packet_id;
               uint32_t key_id_le;
               struct pkt pkt;
       } samba_pkt;

       struct samba_key_out {
               uint32_t version;
               uint32_t op;
               uint32_t packet_id;
               struct pkt pkt;
       } samba_reply;

       char full_socket[256];

       char *reply = NULL;
       uint32_t reply_len;

       ZERO(samba_pkt);
       samba_pkt.op = 0; /* Sign message */
       /* This will be echoed into the reply - a different
        * impelementation might want multiple packets
        * awaiting signing */

       samba_pkt.packet_id = 1;

       /* Swap the byte order back - it's actually little
        * endian on the wire, but it was read above as
        * network byte order */
       samba_pkt.key_id_le = htonl(xkeyid);
       samba_pkt.pkt = *xpkt;

       snprintf(full_socket, sizeof(full_socket), "%s/socket", ntp_signd_socket);

       fd = ux_socket_connect(full_socket);
       /* Only continue with this if we can talk to Samba */
       if (fd != -1) {
               /* Send old packet to Samba, expect response */
               /* Packet to Samba is quite simple:
                  All values BIG endian except key ID as noted
                  [packet size as BE] - 4 bytes
                  [protocol version (0)] - 4 bytes
                  [packet ID] - 4 bytes
                  [operation (sign message=0)] - 4 bytes
                  [key id] - LITTLE endian (as on wire) - 4 bytes
                  [message to sign] - as marshalled, without signature
               */

               if (send_packet(fd, (char *)&samba_pkt, offsetof(struct samba_key_in, pkt) + LEN_PKT_NOMAC) != 0) {
                       /* Huh?  could not talk to Samba... */
                       close(fd);
                       return;
               }

               if (recv_packet(fd, &reply, &reply_len) != 0) {
                       if (reply) {
                               free(reply);
                       }
                       close(fd);
                       return;
               }
               /* Return packet is also simple:
                  [packet size] - network byte order - 4 bytes
                  [protocol version (0)] network byte order - - 4 bytes
                  [operation (signed success=3, failure=4)] network byte order - - 4 byte
                  (optional) [signed message] - as provided before, with signature appended
               */

               if (reply_len <= sizeof(samba_reply)) {
                       memcpy(&samba_reply, reply, reply_len);
                       if (ntohl(samba_reply.op) == 3 && reply_len >  offsetof(struct samba_key_out, pkt)) {
                               sendlen = reply_len - offsetof(struct samba_key_out, pkt);
                               xpkt = &samba_reply.pkt;
                               sendpkt(&rbufp->recv_srcadr, rbufp->dstadr, 0, xpkt, sendlen);
#ifdef DEBUG
                               if (debug)
                                       printf(
                                               "transmit ntp_signd packet: at %ld %s->%s mode %d keyid %08x len %d\n",
                                               current_time, ntoa(&rbufp->dstadr->sin),
                                               ntoa(&rbufp->recv_srcadr), xmode, xkeyid, sendlen);
#endif
                       }
               }

               if (reply) {
                       free(reply);
               }
               close(fd);

       }
}
#endif

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.