crypto/dh_helper.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) 2016, Intel Corporation
   4  * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
   5  */
   6 #include <linux/kernel.h>
   7 #include <linux/export.h>
   8 #include <linux/err.h>
   9 #include <linux/string.h>
  10 #include <crypto/dh.h>
  11 #include <crypto/kpp.h>
  12 #include "dhparameter.asn1.h"
  13
  14 #define DH_KPP_SECRET_MIN_SIZE (sizeof(struct kpp_secret) + 4 * sizeof(int))
  15
  16 static inline u8 *dh_pack_data(u8 *dst, u8 *end, const void *src, size_t size)
  17 {
  18         if (!dst || size > end - dst)
  19                 return NULL;
  20         memcpy(dst, src, size);
  21         return dst + size;
  22 }
  23
  24 static inline const u8 *dh_unpack_data(void *dst, const void *src, size_t size)
  25 {
  26         memcpy(dst, src, size);
  27         return src + size;
  28 }
  29
  30 static inline unsigned int dh_data_size(const struct dh *p)
  31 {
  32         return p->key_size + p->p_size + p->q_size + p->g_size;
  33 }
  34
  35 unsigned int crypto_dh_key_len(const struct dh *p)
  36 {
  37         return DH_KPP_SECRET_MIN_SIZE + dh_data_size(p);
  38 }
  39 EXPORT_SYMBOL_GPL(crypto_dh_key_len);
  40
  41 int crypto_dh_encode_key(char *buf, unsigned int len, const struct dh *params)
  42 {
  43         u8 *ptr = buf;
  44         u8 * const end = ptr + len;
  45         struct kpp_secret secret = {
  46                 .type = CRYPTO_KPP_SECRET_TYPE_DH,
  47                 .len = len
  48         };
  49
  50         if (unlikely(!len))
  51                 return -EINVAL;
  52
  53         /* Prevention of out-of-bounds access in decode code path */
  54         if ((!params->key && params->key_size) ||
  55             (!params->p && params->p_size) ||
  56             (!params->g && params->g_size))
  57                 return -EINVAL;
  58
  59         ptr = dh_pack_data(ptr, end, &secret, sizeof(secret));
  60         ptr = dh_pack_data(ptr, end, &params->key_size,
  61                            sizeof(params->key_size));
  62         ptr = dh_pack_data(ptr, end, &params->p_size, sizeof(params->p_size));
  63         ptr = dh_pack_data(ptr, end, &params->q_size, sizeof(params->q_size));
  64         ptr = dh_pack_data(ptr, end, &params->g_size, sizeof(params->g_size));
  65         if (params->key)
  66                 ptr = dh_pack_data(ptr, end, params->key, params->key_size);
  67         if (params->p)
  68                 ptr = dh_pack_data(ptr, end, params->p, params->p_size);
  69         if (params->q)
  70                 ptr = dh_pack_data(ptr, end, params->q, params->q_size);
  71         if (params->g)
  72                 ptr = dh_pack_data(ptr, end, params->g, params->g_size);
  73         if (ptr != end)
  74                 return -EINVAL;
  75         return 0;
  76 }
  77 EXPORT_SYMBOL_GPL(crypto_dh_encode_key);
  78
  79 int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params)
  80 {
  81         const u8 *ptr = buf;
  82         struct kpp_secret secret;
  83
  84         if (unlikely(!buf || len < DH_KPP_SECRET_MIN_SIZE))
  85                 return -EINVAL;
  86
  87         ptr = dh_unpack_data(&secret, ptr, sizeof(secret));
  88         if (secret.type != CRYPTO_KPP_SECRET_TYPE_DH)
  89                 return -EINVAL;
  90
  91         ptr = dh_unpack_data(&params->key_size, ptr, sizeof(params->key_size));
  92         ptr = dh_unpack_data(&params->p_size, ptr, sizeof(params->p_size));
  93         ptr = dh_unpack_data(&params->q_size, ptr, sizeof(params->q_size));
  94         ptr = dh_unpack_data(&params->g_size, ptr, sizeof(params->g_size));
  95         if (secret.len != crypto_dh_key_len(params))
  96                 return -EINVAL;
  97
  98         /*
  99          * Don't permit the buffer for 'key' or 'g' to be larger than 'p', since
 100          * some drivers assume otherwise.
 101          */
 102         if (params->key_size > params->p_size ||
 103             params->g_size > params->p_size || params->q_size > params->p_size)
 104                 return -EINVAL;
 105
 106         /* Don't allocate memory. Set pointers to data within
 107          * the given buffer
 108          */
 109         params->key = (void *)ptr;
 110         params->p = (void *)(ptr + params->key_size);
 111         params->q = (void *)(ptr + params->key_size + params->p_size);
 112         params->g = (void *)(ptr + params->key_size + params->p_size +
 113                              params->q_size);
 114
 115         /*
 116          * Don't permit 'p' to be 0.  It's not a prime number, and it's subject
 117          * to corner cases such as 'mod 0' being undefined or
 118          * crypto_kpp_maxsize() returning 0.
 119          */
 120         if (memchr_inv(params->p, 0, params->p_size) == NULL)
 121                 return -EINVAL;
 122
 123         /* It is permissible to not provide Q. */
 124         if (params->q_size == 0)
 125                 params->q = NULL;
 126
 127         return 0;
 128 }
 129 EXPORT_SYMBOL_GPL(crypto_dh_decode_key);
 130
 131 int dh_get_p(void *context, size_t hdrlen, unsigned char tag, const void *value,
 132              size_t vlen)
 133 {
 134         struct dh *dh = context;
 135
 136         /* invalid key provided */
 137         if (!value || !vlen)
 138                 return -EINVAL;
 139
 140         dh->p = value;
 141         dh->p_size = vlen;
 142
 143         return 0;
 144 }
 145
 146 int dh_get_g(void *context, size_t hdrlen, unsigned char tag,
 147              const void *value, size_t vlen)
 148 {
 149         struct dh *dh = context;
 150
 151         /* invalid base provided */
 152         if (!value || !dh->p_size || !vlen || vlen > dh->p_size)
 153                 return -EINVAL;
 154
 155         dh->g = value;
 156         dh->g_size = vlen;
 157
 158         return 0;
 159 }
 160
 161 int dh_parse_params_pkcs3(struct dh *dh, const void *param,
 162                          unsigned int param_len)
 163 {
 164         return asn1_ber_decoder(&dhparameter_decoder, dh, param, param_len);
 165 }
 166 EXPORT_SYMBOL_GPL(dh_parse_params_pkcs3);
 167