src/libsystemd-network/dhcp-identifier.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <linux/if_infiniband.h>
   4 #include <net/if_arp.h>
   5
   6 #include "sd-device.h"
   7 #include "sd-id128.h"
   8
   9 #include "dhcp-identifier.h"
  10 #include "dhcp6-protocol.h"
  11 #include "network-internal.h"
  12 #include "siphash24.h"
  13 #include "sparse-endian.h"
  14 #include "virt.h"
  15
  16 #define SYSTEMD_PEN    43793
  17 #define HASH_KEY       SD_ID128_MAKE(80,11,8c,c2,fe,4a,03,ee,3e,d6,0c,6f,36,39,14,09)
  18 #define APPLICATION_ID SD_ID128_MAKE(a5,0a,d1,12,bf,60,45,77,a2,fb,74,1a,b1,95,5b,03)
  19 #define USEC_2000       ((usec_t) 946684800000000) /* 2000-01-01 00:00:00 UTC */
  20
  21 int dhcp_validate_duid_len(uint16_t duid_type, size_t duid_len) {
  22         struct duid d;
  23
  24         assert_cc(sizeof(d.raw) >= MAX_DUID_LEN);
  25         if (duid_len > MAX_DUID_LEN)
  26                 return -EINVAL;
  27
  28         switch (duid_type) {
  29         case DUID_TYPE_LLT:
  30                 if (duid_len <= sizeof(d.llt))
  31                         return -EINVAL;
  32                 break;
  33         case DUID_TYPE_EN:
  34                 if (duid_len != sizeof(d.en))
  35                         return -EINVAL;
  36                 break;
  37         case DUID_TYPE_LL:
  38                 if (duid_len <= sizeof(d.ll))
  39                         return -EINVAL;
  40                 break;
  41         case DUID_TYPE_UUID:
  42                 if (duid_len != sizeof(d.uuid))
  43                         return -EINVAL;
  44                 break;
  45         default:
  46                 /* accept unknown type in order to be forward compatible */
  47                 break;
  48         }
  49         return 0;
  50 }
  51
  52 int dhcp_identifier_set_duid_llt(struct duid *duid, usec_t t, const uint8_t *addr, size_t addr_len, uint16_t arp_type, size_t *len) {
  53         uint16_t time_from_2000y;
  54
  55         assert(duid);
  56         assert(len);
  57         assert(addr);
  58
  59         if (arp_type == ARPHRD_ETHER)
  60                 assert_return(addr_len == ETH_ALEN, -EINVAL);
  61         else if (arp_type == ARPHRD_INFINIBAND)
  62                 assert_return(addr_len == INFINIBAND_ALEN, -EINVAL);
  63         else
  64                 return -EINVAL;
  65
  66         if (t < USEC_2000)
  67                 time_from_2000y = 0;
  68         else
  69                 time_from_2000y = (uint16_t) (((t - USEC_2000) / USEC_PER_SEC) & 0xffffffff);
  70
  71         unaligned_write_be16(&duid->type, DUID_TYPE_LLT);
  72         unaligned_write_be16(&duid->llt.htype, arp_type);
  73         unaligned_write_be32(&duid->llt.time, time_from_2000y);
  74         memcpy(duid->llt.haddr, addr, addr_len);
  75
  76         *len = sizeof(duid->type) + sizeof(duid->llt.htype) + sizeof(duid->llt.time) + addr_len;
  77
  78         return 0;
  79 }
  80
  81 int dhcp_identifier_set_duid_ll(struct duid *duid, const uint8_t *addr, size_t addr_len, uint16_t arp_type, size_t *len) {
  82         assert(duid);
  83         assert(len);
  84         assert(addr);
  85
  86         if (arp_type == ARPHRD_ETHER)
  87                 assert_return(addr_len == ETH_ALEN, -EINVAL);
  88         else if (arp_type == ARPHRD_INFINIBAND)
  89                 assert_return(addr_len == INFINIBAND_ALEN, -EINVAL);
  90         else
  91                 return -EINVAL;
  92
  93         unaligned_write_be16(&duid->type, DUID_TYPE_LL);
  94         unaligned_write_be16(&duid->ll.htype, arp_type);
  95         memcpy(duid->ll.haddr, addr, addr_len);
  96
  97         *len = sizeof(duid->type) + sizeof(duid->ll.htype) + addr_len;
  98
  99         return 0;
 100 }
 101
 102 int dhcp_identifier_set_duid_en(struct duid *duid, size_t *len) {
 103         sd_id128_t machine_id;
 104         uint64_t hash;
 105         int r;
 106
 107         assert(duid);
 108         assert(len);
 109
 110         r = sd_id128_get_machine(&machine_id);
 111         if (r < 0) {
 112 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 113                 machine_id = SD_ID128_MAKE(01, 02, 03, 04, 05, 06, 07, 08, 09, 0a, 0b, 0c, 0d, 0e, 0f, 10);
 114 #else
 115                 return r;
 116 #endif
 117         }
 118
 119         unaligned_write_be16(&duid->type, DUID_TYPE_EN);
 120         unaligned_write_be32(&duid->en.pen, SYSTEMD_PEN);
 121
 122         *len = sizeof(duid->type) + sizeof(duid->en);
 123
 124         /* a bit of snake-oil perhaps, but no need to expose the machine-id
 125          * directly; duid->en.id might not be aligned, so we need to copy */
 126         hash = htole64(siphash24(&machine_id, sizeof(machine_id), HASH_KEY.bytes));
 127         memcpy(duid->en.id, &hash, sizeof(duid->en.id));
 128
 129         return 0;
 130 }
 131
 132 int dhcp_identifier_set_duid_uuid(struct duid *duid, size_t *len) {
 133         sd_id128_t machine_id;
 134         int r;
 135
 136         assert(duid);
 137         assert(len);
 138
 139         r = sd_id128_get_machine_app_specific(APPLICATION_ID, &machine_id);
 140         if (r < 0)
 141                 return r;
 142
 143         unaligned_write_be16(&duid->type, DUID_TYPE_UUID);
 144         memcpy(&duid->raw.data, &machine_id, sizeof(machine_id));
 145
 146         *len = sizeof(duid->type) + sizeof(machine_id);
 147
 148         return 0;
 149 }
 150
 151 int dhcp_identifier_set_iaid(
 152                 int ifindex,
 153                 const uint8_t *mac,
 154                 size_t mac_len,
 155                 bool legacy_unstable_byteorder,
 156                 void *_id) {
 157         /* name is a pointer to memory in the sd_device struct, so must
 158          * have the same scope */
 159         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
 160         const char *name = NULL;
 161         uint64_t id;
 162         uint32_t id32;
 163
 164         if (detect_container() <= 0) {
 165                 /* not in a container, udev will be around */
 166                 char ifindex_str[2 + DECIMAL_STR_MAX(int)];
 167                 int r;
 168
 169                 sprintf(ifindex_str, "n%d", ifindex);
 170                 if (sd_device_new_from_device_id(&device, ifindex_str) >= 0) {
 171                         r = sd_device_get_is_initialized(device);
 172                         if (r < 0)
 173                                 return r;
 174                         if (r == 0)
 175                                 /* not yet ready */
 176                                 return -EBUSY;
 177
 178                         name = net_get_name(device);
 179                 }
 180         }
 181
 182         if (name)
 183                 id = siphash24(name, strlen(name), HASH_KEY.bytes);
 184         else
 185                 /* fall back to MAC address if no predictable name available */
 186                 id = siphash24(mac, mac_len, HASH_KEY.bytes);
 187
 188         id32 = (id & 0xffffffff) ^ (id >> 32);
 189
 190         if (legacy_unstable_byteorder)
 191                 /* for historical reasons (a bug), the bits were swapped and thus
 192                  * the result was endianness dependant. Preserve that behavior. */
 193                 id32 = __bswap_32(id32);
 194         else
 195                 /* the fixed behavior returns a stable byte order. Since LE is expected
 196                  * to be more common, swap the bytes on LE to give the same as legacy
 197                  * behavior. */
 198                 id32 = be32toh(id32);
 199
 200         unaligned_write_ne32(_id, id32);
 201         return 0;
 202 }