src/plugins/wireguard/wireguard_key.c

   1 /*
   2  * Copyright (c) 2020 Doc.ai and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <wireguard/wireguard_key.h>
  17 #include <openssl/evp.h>
  18
  19 bool
  20 curve25519_gen_shared (u8 shared_key[CURVE25519_KEY_SIZE],
  21                        const u8 secret_key[CURVE25519_KEY_SIZE],
  22                        const u8 basepoint[CURVE25519_KEY_SIZE])
  23 {
  24
  25   bool ret;
  26   EVP_PKEY_CTX *ctx;
  27   size_t key_len;
  28
  29   EVP_PKEY *peerkey = NULL;
  30   EVP_PKEY *pkey =
  31     EVP_PKEY_new_raw_private_key (EVP_PKEY_X25519, NULL, secret_key,
  32                                   CURVE25519_KEY_SIZE);
  33
  34   ret = true;
  35
  36   ctx = EVP_PKEY_CTX_new (pkey, NULL);
  37   if (EVP_PKEY_derive_init (ctx) <= 0)
  38     {
  39       ret = false;
  40       goto out;
  41     }
  42
  43   peerkey =
  44     EVP_PKEY_new_raw_public_key (EVP_PKEY_X25519, NULL, basepoint,
  45                                  CURVE25519_KEY_SIZE);
  46   if (EVP_PKEY_derive_set_peer (ctx, peerkey) <= 0)
  47     {
  48       ret = false;
  49       goto out;
  50     }
  51
  52   key_len = CURVE25519_KEY_SIZE;
  53   if (EVP_PKEY_derive (ctx, shared_key, &key_len) <= 0)
  54     {
  55       ret = false;
  56     }
  57
  58 out:
  59   EVP_PKEY_CTX_free (ctx);
  60   EVP_PKEY_free (pkey);
  61   EVP_PKEY_free (peerkey);
  62   return ret;
  63 }
  64
  65 bool
  66 curve25519_gen_public (u8 public_key[CURVE25519_KEY_SIZE],
  67                        const u8 secret_key[CURVE25519_KEY_SIZE])
  68 {
  69   size_t pub_len;
  70   EVP_PKEY *pkey =
  71     EVP_PKEY_new_raw_private_key (EVP_PKEY_X25519, NULL, secret_key,
  72                                   CURVE25519_KEY_SIZE);
  73   pub_len = CURVE25519_KEY_SIZE;
  74   if (!EVP_PKEY_get_raw_public_key (pkey, public_key, &pub_len))
  75     {
  76       EVP_PKEY_free (pkey);
  77       return false;
  78     }
  79   EVP_PKEY_free (pkey);
  80   return true;
  81 }
  82
  83 bool
  84 curve25519_gen_secret (u8 secret_key[CURVE25519_KEY_SIZE])
  85 {
  86   size_t secret_len;
  87   EVP_PKEY *pkey = NULL;
  88   EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id (EVP_PKEY_X25519, NULL);
  89   EVP_PKEY_keygen_init (pctx);
  90   EVP_PKEY_keygen (pctx, &pkey);
  91   EVP_PKEY_CTX_free (pctx);
  92
  93   secret_len = CURVE25519_KEY_SIZE;
  94   if (!EVP_PKEY_get_raw_private_key (pkey, secret_key, &secret_len))
  95     {
  96       EVP_PKEY_free (pkey);
  97       return false;
  98     }
  99   EVP_PKEY_free (pkey);
 100   return true;
 101 }
 102
 103 bool
 104 key_to_base64 (const u8 * src, size_t src_len, u8 * out)
 105 {
 106   if (!EVP_EncodeBlock (out, src, src_len))
 107     return false;
 108   return true;
 109 }
 110
 111 bool
 112 key_from_base64 (const u8 * src, size_t src_len, u8 * out)
 113 {
 114   if (EVP_DecodeBlock (out, src, src_len - 1) <= 0)
 115     return false;
 116   return true;
 117 }
 118
 119 /*
 120  * fd.io coding-style-patch-verification: ON
 121  *
 122  * Local Variables:
 123  * eval: (c-set-style "gnu")
 124  * End:
 125  */