bsd/netinet6/in6_cga.c

   1 /*
   2  * Copyright (c) 2013-2016 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/malloc.h>
  31
  32 #include <kern/locks.h>
  33
  34 #include <libkern/crypto/sha1.h>
  35
  36 #include <net/if.h>
  37
  38 #include <netinet/in.h>
  39 #include <netinet6/in6_var.h>
  40 #include <netinet/ip6.h>
  41 #include <netinet6/ip6_var.h>
  42 #include <netinet6/nd6.h>
  43
  44 #define IN6_CGA_HASH1_LENGTH    8
  45 #define IN6_CGA_HASH2_LENGTH    14
  46 #define IN6_CGA_PREPARE_ZEROES  9
  47
  48 struct in6_cga_hash1 {
  49         u_int8_t octets[IN6_CGA_HASH1_LENGTH];
  50 };
  51
  52 struct in6_cga_hash2 {
  53         u_int8_t octets[IN6_CGA_HASH2_LENGTH];
  54 };
  55
  56 struct in6_cga_singleton {
  57         boolean_t cga_initialized;
  58         decl_lck_mtx_data(, cga_mutex);
  59         struct in6_cga_prepare cga_prepare;
  60         struct iovec cga_pubkey;
  61         struct iovec cga_privkey;
  62 };
  63
  64 static struct in6_cga_singleton in6_cga = {
  65         .cga_initialized = FALSE,
  66         .cga_mutex = {},
  67         .cga_prepare = {
  68                 .cga_modifier = {},
  69                 .cga_security_level = 0,
  70         },
  71         .cga_pubkey = {
  72                 .iov_base = NULL,
  73                 .iov_len = 0,
  74         },
  75         .cga_privkey = {
  76                 .iov_base = NULL,
  77                 .iov_len = 0,
  78         },
  79 };
  80
  81 static void
  82 in6_cga_node_lock_assert(int owned)
  83 {
  84 #if !MACH_ASSERT
  85 #pragma unused(owned)
  86 #endif
  87         VERIFY(in6_cga.cga_initialized);
  88         LCK_MTX_ASSERT(&in6_cga.cga_mutex, owned);
  89 }
  90
  91 static boolean_t
  92 in6_cga_is_prepare_valid(const struct in6_cga_prepare *prepare,
  93     const struct iovec *pubkey)
  94 {
  95         static const u_int8_t zeroes[IN6_CGA_PREPARE_ZEROES] = { };
  96         SHA1_CTX ctx;
  97         u_int8_t sha1[SHA1_RESULTLEN];
  98         u_int i, n;
  99
 100         VERIFY(prepare != NULL);
 101         VERIFY(pubkey != NULL && pubkey->iov_base != NULL);
 102
 103         if (prepare->cga_security_level == 0) {
 104                 return TRUE;
 105         }
 106
 107         if (prepare->cga_security_level > 7) {
 108                 return FALSE;
 109         }
 110
 111         SHA1Init(&ctx);
 112         SHA1Update(&ctx, &prepare->cga_modifier.octets,
 113             IN6_CGA_MODIFIER_LENGTH);
 114         SHA1Update(&ctx, &zeroes, IN6_CGA_PREPARE_ZEROES);
 115         SHA1Update(&ctx, pubkey->iov_base, pubkey->iov_len);
 116         /* FUTURE: extension fields */
 117         SHA1Final(sha1, &ctx);
 118
 119         n = 2 * (u_int) prepare->cga_security_level;
 120         VERIFY(n < SHA1_RESULTLEN);
 121         for (i = 0; i < n; ++i) {
 122                 if (sha1[i] != 0) {
 123                         return FALSE;
 124                 }
 125         }
 126
 127         return TRUE;
 128 }
 129
 130 /*
 131  * @brief Generate interface identifier for CGA
 132  *      XXX You may notice that following does not really
 133  *      mirror what is decribed in:
 134  *      https://tools.ietf.org/html/rfc3972#section-4
 135  *      By design kernel here will assume that that
 136  *      modifier has been converged on by userspace
 137  *      for first part of the algorithm for the given
 138  *      security level.
 139  *      We are not doing that yet but that's how the code
 140  *      below is written. So really we are starting
 141  *      from bullet 4 of the algorithm.
 142  *
 143  * @param prepare Pointer to object containing modifier,
 144  *      security level & externsion to be used.
 145  * @param pubkey Public key used for IID generation
 146  * @param collisions Collission count on DAD failure
 147  *      XXX We are not really re-generating IID on DAD
 148  *      failures for now.
 149  * @param in6 Pointer to the address containing
 150  *      the prefix.
 151  *
 152  * @return void
 153  */
 154 static void
 155 in6_cga_generate_iid(const struct in6_cga_prepare *prepare,
 156     const struct iovec *pubkey, u_int8_t collisions, struct in6_addr *in6)
 157 {
 158         SHA1_CTX ctx;
 159         u_int8_t sha1[SHA1_RESULTLEN];
 160
 161         VERIFY(prepare != NULL);
 162         VERIFY(prepare->cga_security_level < 8);
 163         VERIFY(pubkey != NULL && pubkey->iov_base != NULL);
 164         VERIFY(in6 != NULL);
 165
 166         SHA1Init(&ctx);
 167         SHA1Update(&ctx, &prepare->cga_modifier.octets, 16);
 168         SHA1Update(&ctx, in6->s6_addr, 8);
 169         SHA1Update(&ctx, &collisions, 1);
 170         SHA1Update(&ctx, pubkey->iov_base, pubkey->iov_len);
 171         /* FUTURE: extension fields */
 172         SHA1Final(sha1, &ctx);
 173
 174         in6->s6_addr8[8] =
 175             (prepare->cga_security_level << 5) | (sha1[0] & 0x1c);
 176         in6->s6_addr8[9] = sha1[1];
 177         in6->s6_addr8[10] = sha1[2];
 178         in6->s6_addr8[11] = sha1[3];
 179         in6->s6_addr8[12] = sha1[4];
 180         in6->s6_addr8[13] = sha1[5];
 181         in6->s6_addr8[14] = sha1[6];
 182         in6->s6_addr8[15] = sha1[7];
 183 }
 184
 185 void
 186 in6_cga_init(void)
 187 {
 188         lck_mtx_init(&in6_cga.cga_mutex, ifa_mtx_grp, ifa_mtx_attr);
 189         in6_cga.cga_initialized = TRUE;
 190 }
 191
 192 void
 193 in6_cga_node_lock(void)
 194 {
 195         VERIFY(in6_cga.cga_initialized);
 196         lck_mtx_lock(&in6_cga.cga_mutex);
 197 }
 198
 199 void
 200 in6_cga_node_unlock(void)
 201 {
 202         VERIFY(in6_cga.cga_initialized);
 203         lck_mtx_unlock(&in6_cga.cga_mutex);
 204 }
 205
 206 void
 207 in6_cga_query(struct in6_cga_nodecfg *cfg)
 208 {
 209         VERIFY(cfg != NULL);
 210         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 211
 212         cfg->cga_pubkey = in6_cga.cga_pubkey;
 213         cfg->cga_prepare = in6_cga.cga_prepare;
 214 }
 215
 216 int
 217 in6_cga_start(const struct in6_cga_nodecfg *cfg)
 218 {
 219         struct iovec privkey, pubkey;
 220         const struct in6_cga_prepare *prepare;
 221         caddr_t pubkeycopy, privkeycopy;
 222
 223         VERIFY(cfg != NULL);
 224         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 225
 226         privkey = cfg->cga_privkey;
 227         if (privkey.iov_base == NULL || privkey.iov_len == 0 ||
 228             privkey.iov_len >= IN6_CGA_KEY_MAXSIZE) {
 229                 return EINVAL;
 230         }
 231         pubkey = cfg->cga_pubkey;
 232         if (pubkey.iov_base == NULL || pubkey.iov_len == 0 ||
 233             pubkey.iov_len >= IN6_CGA_KEY_MAXSIZE) {
 234                 return EINVAL;
 235         }
 236         prepare = &cfg->cga_prepare;
 237
 238         if (!in6_cga_is_prepare_valid(prepare, &pubkey)) {
 239                 return EINVAL;
 240         }
 241
 242         in6_cga.cga_prepare = *prepare;
 243
 244         MALLOC(privkeycopy, caddr_t, privkey.iov_len, M_IP6CGA, M_WAITOK);
 245         if (privkeycopy == NULL) {
 246                 return ENOMEM;
 247         }
 248
 249         MALLOC(pubkeycopy, caddr_t, pubkey.iov_len, M_IP6CGA, M_WAITOK);
 250         if (pubkeycopy == NULL) {
 251                 if (privkeycopy != NULL) {
 252                         FREE(privkeycopy, M_IP6CGA);
 253                 }
 254                 return ENOMEM;
 255         }
 256
 257         bcopy(privkey.iov_base, privkeycopy, privkey.iov_len);
 258         privkey.iov_base = privkeycopy;
 259         if (in6_cga.cga_privkey.iov_base != NULL) {
 260                 FREE(in6_cga.cga_privkey.iov_base, M_IP6CGA);
 261         }
 262         in6_cga.cga_privkey = privkey;
 263
 264         bcopy(pubkey.iov_base, pubkeycopy, pubkey.iov_len);
 265         pubkey.iov_base = pubkeycopy;
 266         if (in6_cga.cga_pubkey.iov_base != NULL) {
 267                 FREE(in6_cga.cga_pubkey.iov_base, M_IP6CGA);
 268         }
 269         in6_cga.cga_pubkey = pubkey;
 270
 271         return 0;
 272 }
 273
 274 int
 275 in6_cga_stop(void)
 276 {
 277         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 278
 279         if (in6_cga.cga_privkey.iov_base != NULL) {
 280                 FREE(in6_cga.cga_privkey.iov_base, M_IP6CGA);
 281                 in6_cga.cga_privkey.iov_base = NULL;
 282                 in6_cga.cga_privkey.iov_len = 0;
 283         }
 284
 285         if (in6_cga.cga_pubkey.iov_base != NULL) {
 286                 FREE(in6_cga.cga_pubkey.iov_base, M_IP6CGA);
 287                 in6_cga.cga_pubkey.iov_base = NULL;
 288                 in6_cga.cga_pubkey.iov_len = 0;
 289         }
 290
 291         return 0;
 292 }
 293
 294 ssize_t
 295 in6_cga_parameters_prepare(void *output, size_t max,
 296     const struct in6_addr *prefix, u_int8_t collisions,
 297     const struct in6_cga_modifier *modifier)
 298 {
 299         caddr_t cursor;
 300
 301         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 302
 303         if (in6_cga.cga_pubkey.iov_len == 0) {
 304                 /* No public key */
 305                 return EINVAL;
 306         }
 307
 308         if (output == NULL ||
 309             max < in6_cga.cga_pubkey.iov_len + sizeof(modifier->octets) + 9) {
 310                 /* Output buffer error */
 311                 return EINVAL;
 312         }
 313
 314         cursor = output;
 315         if (modifier == NULL) {
 316                 modifier = &in6_cga.cga_prepare.cga_modifier;
 317         }
 318         if (prefix == NULL) {
 319                 static const struct in6_addr llprefix = {{{ 0xfe, 0x80 }}};
 320                 prefix = &llprefix;
 321         }
 322
 323         bcopy(&modifier->octets, cursor, sizeof(modifier->octets));
 324         cursor += sizeof(modifier->octets);
 325
 326         *cursor++ = (char) collisions;
 327
 328         bcopy(&prefix->s6_addr[0], cursor, 8);
 329         cursor += 8;
 330
 331         bcopy(in6_cga.cga_pubkey.iov_base, cursor, in6_cga.cga_pubkey.iov_len);
 332         cursor += in6_cga.cga_pubkey.iov_len;
 333
 334         /* FUTURE: Extension fields */
 335
 336         return (ssize_t)(cursor - (caddr_t)output);
 337 }
 338
 339 int
 340 in6_cga_generate(struct in6_cga_prepare *prepare, u_int8_t collisions,
 341     struct in6_addr *in6)
 342 {
 343         int error;
 344         const struct iovec *pubkey;
 345
 346         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 347         VERIFY(in6 != NULL);
 348
 349         if (prepare == NULL) {
 350                 prepare = &in6_cga.cga_prepare;
 351         } else {
 352                 prepare->cga_security_level =
 353                     in6_cga.cga_prepare.cga_security_level;
 354         }
 355
 356         pubkey = &in6_cga.cga_pubkey;
 357
 358         if (pubkey->iov_base != NULL) {
 359                 in6_cga_generate_iid(prepare, pubkey, collisions, in6);
 360                 error = 0;
 361         } else {
 362                 error = EADDRNOTAVAIL;
 363         }
 364
 365         return error;
 366 }
 367
 368 /* End of file */