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         VERIFY(in6_cga.cga_initialized);
  85         lck_mtx_assert(&in6_cga.cga_mutex, owned);
  86 }
  87
  88 static boolean_t
  89 in6_cga_is_prepare_valid(const struct in6_cga_prepare *prepare,
  90     const struct iovec *pubkey)
  91 {
  92         static const u_int8_t zeroes[IN6_CGA_PREPARE_ZEROES] = { };
  93         SHA1_CTX ctx;
  94         u_int8_t sha1[SHA1_RESULTLEN];
  95         u_int i, n;
  96
  97         VERIFY(prepare != NULL);
  98         VERIFY(pubkey != NULL && pubkey->iov_base != NULL);
  99
 100         if (prepare->cga_security_level == 0)
 101                 return (TRUE);
 102
 103         if (prepare->cga_security_level > 7)
 104                 return (FALSE);
 105
 106         SHA1Init(&ctx);
 107         SHA1Update(&ctx, &prepare->cga_modifier.octets,
 108             IN6_CGA_MODIFIER_LENGTH);
 109         SHA1Update(&ctx, &zeroes, IN6_CGA_PREPARE_ZEROES);
 110         SHA1Update(&ctx, pubkey->iov_base, pubkey->iov_len);
 111         /* FUTURE: extension fields */
 112         SHA1Final(sha1, &ctx);
 113
 114         n = 2 * (u_int) prepare->cga_security_level;
 115         VERIFY(n < SHA1_RESULTLEN);
 116         for (i = 0; i < n; ++i)
 117                 if (sha1[i] != 0)
 118                         return (FALSE);
 119
 120         return (TRUE);
 121 }
 122
 123 /*
 124  * @brief Generate interface identifier for CGA
 125  *      XXX You may notice that following does not really
 126  *      mirror what is decribed in:
 127  *      https://tools.ietf.org/html/rfc3972#section-4
 128  *      By design kernel here will assume that that
 129  *      modifier has been converged on by userspace
 130  *      for first part of the algorithm for the given
 131  *      security level.
 132  *      We are not doing that yet but that's how the code
 133  *      below is written. So really we are starting
 134  *      from bullet 4 of the algorithm.
 135  *
 136  * @param prepare Pointer to object containing modifier,
 137  *      security level & externsion to be used.
 138  * @param pubkey Public key used for IID generation
 139  * @param collisions Collission count on DAD failure
 140  *      XXX We are not really re-generating IID on DAD
 141  *      failures for now.
 142  * @param in6 Pointer to the address containing
 143  *      the prefix.
 144  *
 145  * @return void
 146  */
 147 static void
 148 in6_cga_generate_iid(const struct in6_cga_prepare *prepare,
 149     const struct iovec *pubkey, u_int8_t collisions, struct in6_addr *in6)
 150 {
 151         SHA1_CTX ctx;
 152         u_int8_t sha1[SHA1_RESULTLEN];
 153
 154         VERIFY(prepare != NULL);
 155         VERIFY(prepare->cga_security_level < 8);
 156         VERIFY(pubkey != NULL && pubkey->iov_base != NULL);
 157         VERIFY(in6 != NULL);
 158
 159         SHA1Init(&ctx);
 160         SHA1Update(&ctx, &prepare->cga_modifier.octets, 16);
 161         SHA1Update(&ctx, in6->s6_addr, 8);
 162         SHA1Update(&ctx, &collisions, 1);
 163         SHA1Update(&ctx, pubkey->iov_base, pubkey->iov_len);
 164         /* FUTURE: extension fields */
 165         SHA1Final(sha1, &ctx);
 166
 167         in6->s6_addr8[8] =
 168             (prepare->cga_security_level << 5) | (sha1[0] & 0x1c);
 169         in6->s6_addr8[9] = sha1[1];
 170         in6->s6_addr8[10] = sha1[2];
 171         in6->s6_addr8[11] = sha1[3];
 172         in6->s6_addr8[12] = sha1[4];
 173         in6->s6_addr8[13] = sha1[5];
 174         in6->s6_addr8[14] = sha1[6];
 175         in6->s6_addr8[15] = sha1[7];
 176 }
 177
 178 void
 179 in6_cga_init(void)
 180 {
 181         lck_mtx_init(&in6_cga.cga_mutex, ifa_mtx_grp, ifa_mtx_attr);
 182         in6_cga.cga_initialized = TRUE;
 183 }
 184
 185 void
 186 in6_cga_node_lock(void)
 187 {
 188         VERIFY(in6_cga.cga_initialized);
 189         lck_mtx_lock(&in6_cga.cga_mutex);
 190 }
 191
 192 void
 193 in6_cga_node_unlock(void)
 194 {
 195         VERIFY(in6_cga.cga_initialized);
 196         lck_mtx_unlock(&in6_cga.cga_mutex);
 197 }
 198
 199 void
 200 in6_cga_query(struct in6_cga_nodecfg *cfg)
 201 {
 202         VERIFY(cfg != NULL);
 203         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 204
 205         cfg->cga_pubkey = in6_cga.cga_pubkey;
 206         cfg->cga_prepare = in6_cga.cga_prepare;
 207 }
 208
 209 int
 210 in6_cga_start(const struct in6_cga_nodecfg *cfg)
 211 {
 212         struct iovec privkey, pubkey;
 213         const struct in6_cga_prepare *prepare;
 214         caddr_t pubkeycopy, privkeycopy;
 215
 216         VERIFY(cfg != NULL);
 217         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 218
 219         privkey = cfg->cga_privkey;
 220         if (privkey.iov_base == NULL || privkey.iov_len == 0 ||
 221             privkey.iov_len >= IN6_CGA_KEY_MAXSIZE)
 222                 return (EINVAL);
 223         pubkey = cfg->cga_pubkey;
 224         if (pubkey.iov_base == NULL || pubkey.iov_len == 0 ||
 225             pubkey.iov_len >= IN6_CGA_KEY_MAXSIZE)
 226                 return (EINVAL);
 227         prepare = &cfg->cga_prepare;
 228
 229         if (!in6_cga_is_prepare_valid(prepare, &pubkey))
 230                 return (EINVAL);
 231
 232         in6_cga.cga_prepare = *prepare;
 233
 234         MALLOC(privkeycopy, caddr_t, privkey.iov_len, M_IP6CGA, M_WAITOK);
 235         if (privkeycopy == NULL)
 236                 return (ENOMEM);
 237
 238         MALLOC(pubkeycopy, caddr_t, pubkey.iov_len, M_IP6CGA, M_WAITOK);
 239         if (pubkeycopy == NULL) {
 240                 if (privkeycopy != NULL)
 241                         FREE(privkeycopy, M_IP6CGA);
 242                 return (ENOMEM);
 243         }
 244
 245         bcopy(privkey.iov_base, privkeycopy, privkey.iov_len);
 246         privkey.iov_base = privkeycopy;
 247         if (in6_cga.cga_privkey.iov_base != NULL)
 248                 FREE(in6_cga.cga_privkey.iov_base, M_IP6CGA);
 249         in6_cga.cga_privkey = privkey;
 250
 251         bcopy(pubkey.iov_base, pubkeycopy, pubkey.iov_len);
 252         pubkey.iov_base = pubkeycopy;
 253         if (in6_cga.cga_pubkey.iov_base != NULL)
 254                 FREE(in6_cga.cga_pubkey.iov_base, M_IP6CGA);
 255         in6_cga.cga_pubkey = pubkey;
 256
 257         return (0);
 258 }
 259
 260 int
 261 in6_cga_stop(void)
 262 {
 263         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 264
 265         if (in6_cga.cga_privkey.iov_base != NULL) {
 266                 FREE(in6_cga.cga_privkey.iov_base, M_IP6CGA);
 267                 in6_cga.cga_privkey.iov_base = NULL;
 268                 in6_cga.cga_privkey.iov_len = 0;
 269         }
 270
 271         if (in6_cga.cga_pubkey.iov_base != NULL) {
 272                 FREE(in6_cga.cga_pubkey.iov_base, M_IP6CGA);
 273                 in6_cga.cga_pubkey.iov_base = NULL;
 274                 in6_cga.cga_pubkey.iov_len = 0;
 275         }
 276
 277         return (0);
 278 }
 279
 280 ssize_t
 281 in6_cga_parameters_prepare(void *output, size_t max,
 282     const struct in6_addr *prefix, u_int8_t collisions,
 283     const struct in6_cga_modifier *modifier)
 284 {
 285         caddr_t cursor;
 286
 287         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 288
 289         if (in6_cga.cga_pubkey.iov_len == 0) {
 290                 /* No public key */
 291                 return (EINVAL);
 292         }
 293
 294         if (output == NULL ||
 295             max < in6_cga.cga_pubkey.iov_len + sizeof (modifier->octets) + 9) {
 296                 /* Output buffer error */
 297                 return (EINVAL);
 298         }
 299
 300         cursor = output;
 301         if (modifier == NULL) modifier = &in6_cga.cga_prepare.cga_modifier;
 302         if (prefix == NULL) {
 303                 static const struct in6_addr llprefix = {{{ 0xfe, 0x80 }}};
 304                 prefix = &llprefix;
 305         }
 306
 307         bcopy(&modifier->octets, cursor, sizeof (modifier->octets));
 308         cursor += sizeof (modifier->octets);
 309
 310         *cursor++ = (char) collisions;
 311
 312         bcopy(&prefix->s6_addr[0], cursor, 8);
 313         cursor += 8;
 314
 315         bcopy(in6_cga.cga_pubkey.iov_base, cursor, in6_cga.cga_pubkey.iov_len);
 316         cursor += in6_cga.cga_pubkey.iov_len;
 317
 318         /* FUTURE: Extension fields */
 319
 320         return ((ssize_t)(cursor - (caddr_t)output));
 321 }
 322
 323 int
 324 in6_cga_generate(struct in6_cga_prepare *prepare, u_int8_t collisions,
 325     struct in6_addr *in6)
 326 {
 327         int error;
 328         const struct iovec *pubkey;
 329
 330         in6_cga_node_lock_assert(LCK_MTX_ASSERT_OWNED);
 331         VERIFY(in6 != NULL);
 332
 333         if (prepare == NULL)
 334                 prepare = &in6_cga.cga_prepare;
 335         else
 336                 prepare->cga_security_level =
 337                     in6_cga.cga_prepare.cga_security_level;
 338
 339         pubkey = &in6_cga.cga_pubkey;
 340
 341         if (pubkey->iov_base != NULL) {
 342                 in6_cga_generate_iid(prepare, pubkey, collisions, in6);
 343                 error = 0;
 344         }
 345         else
 346                 error = EADDRNOTAVAIL;
 347
 348         return (error);
 349 }
 350
 351 /* End of file */