crypto/ecdh_helper.c

   1 /*
   2  * Copyright (c) 2016, Intel Corporation
   3  * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version
   8  * 2 of the License, or (at your option) any later version.
   9  */
  10 #include <linux/kernel.h>
  11 #include <linux/export.h>
  12 #include <linux/err.h>
  13 #include <linux/string.h>
  14 #include <crypto/ecdh.h>
  15 #include <crypto/kpp.h>
  16
  17 #define ECDH_KPP_SECRET_MIN_SIZE (sizeof(struct kpp_secret) + 2 * sizeof(short))
  18
  19 static inline u8 *ecdh_pack_data(void *dst, const void *src, size_t sz)
  20 {
  21         memcpy(dst, src, sz);
  22         return dst + sz;
  23 }
  24
  25 static inline const u8 *ecdh_unpack_data(void *dst, const void *src, size_t sz)
  26 {
  27         memcpy(dst, src, sz);
  28         return src + sz;
  29 }
  30
  31 unsigned int crypto_ecdh_key_len(const struct ecdh *params)
  32 {
  33         return ECDH_KPP_SECRET_MIN_SIZE + params->key_size;
  34 }
  35 EXPORT_SYMBOL_GPL(crypto_ecdh_key_len);
  36
  37 int crypto_ecdh_encode_key(char *buf, unsigned int len,
  38                            const struct ecdh *params)
  39 {
  40         u8 *ptr = buf;
  41         struct kpp_secret secret = {
  42                 .type = CRYPTO_KPP_SECRET_TYPE_ECDH,
  43                 .len = len
  44         };
  45
  46         if (unlikely(!buf))
  47                 return -EINVAL;
  48
  49         if (len != crypto_ecdh_key_len(params))
  50                 return -EINVAL;
  51
  52         ptr = ecdh_pack_data(ptr, &secret, sizeof(secret));
  53         ptr = ecdh_pack_data(ptr, &params->curve_id, sizeof(params->curve_id));
  54         ptr = ecdh_pack_data(ptr, &params->key_size, sizeof(params->key_size));
  55         ecdh_pack_data(ptr, params->key, params->key_size);
  56
  57         return 0;
  58 }
  59 EXPORT_SYMBOL_GPL(crypto_ecdh_encode_key);
  60
  61 int crypto_ecdh_decode_key(const char *buf, unsigned int len,
  62                            struct ecdh *params)
  63 {
  64         const u8 *ptr = buf;
  65         struct kpp_secret secret;
  66
  67         if (unlikely(!buf || len < ECDH_KPP_SECRET_MIN_SIZE))
  68                 return -EINVAL;
  69
  70         ptr = ecdh_unpack_data(&secret, ptr, sizeof(secret));
  71         if (secret.type != CRYPTO_KPP_SECRET_TYPE_ECDH)
  72                 return -EINVAL;
  73
  74         ptr = ecdh_unpack_data(&params->curve_id, ptr, sizeof(params->curve_id));
  75         ptr = ecdh_unpack_data(&params->key_size, ptr, sizeof(params->key_size));
  76         if (secret.len != crypto_ecdh_key_len(params))
  77                 return -EINVAL;
  78
  79         /* Don't allocate memory. Set pointer to data
  80          * within the given buffer
  81          */
  82         params->key = (void *)ptr;
  83
  84         return 0;
  85 }
  86 EXPORT_SYMBOL_GPL(crypto_ecdh_decode_key);