crypto.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /* SPDX-License-Identifier: MIT
    2  *
    3  * Copyright (C) 2015-2021 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
    4  * Copyright (c) 2022 The FreeBSD Foundation
    5  */
    6 
    7 #ifndef _WG_CRYPTO
    8 #define _WG_CRYPTO
    9 
   10 #include <sys/param.h>
   11 #include <sys/endian.h>
   12 #include <crypto/chacha20_poly1305.h>
   13 #include <crypto/curve25519.h>
   14 
   15 struct mbuf;
   16 
   17 int crypto_init(void);
   18 void crypto_deinit(void);
   19 
   20 enum chacha20poly1305_lengths {
   21         XCHACHA20POLY1305_NONCE_SIZE = 24,
   22         CHACHA20POLY1305_KEY_SIZE = 32,
   23         CHACHA20POLY1305_AUTHTAG_SIZE = 16
   24 };
   25 
   26 static inline void
   27 chacha20poly1305_encrypt(uint8_t *dst, const uint8_t *src, const size_t src_len,
   28                          const uint8_t *ad, const size_t ad_len,
   29                          const uint64_t nonce,
   30                          const uint8_t key[CHACHA20POLY1305_KEY_SIZE])
   31 {
   32         uint8_t nonce_bytes[8];
   33 
   34         le64enc(nonce_bytes, nonce);
   35         chacha20_poly1305_encrypt(dst, src, src_len, ad, ad_len,
   36                                   nonce_bytes, sizeof(nonce_bytes), key);
   37 }
   38 
   39 static inline bool
   40 chacha20poly1305_decrypt(uint8_t *dst, const uint8_t *src, const size_t src_len,
   41                          const uint8_t *ad, const size_t ad_len,
   42                          const uint64_t nonce,
   43                          const uint8_t key[CHACHA20POLY1305_KEY_SIZE])
   44 {
   45         uint8_t nonce_bytes[8];
   46 
   47         le64enc(nonce_bytes, nonce);
   48         return (chacha20_poly1305_decrypt(dst, src, src_len, ad, ad_len,
   49                                           nonce_bytes, sizeof(nonce_bytes), key));
   50 }
   51 
   52 static inline void
   53 xchacha20poly1305_encrypt(uint8_t *dst, const uint8_t *src,
   54                           const size_t src_len, const uint8_t *ad,
   55                           const size_t ad_len,
   56                           const uint8_t nonce[XCHACHA20POLY1305_NONCE_SIZE],
   57                           const uint8_t key[CHACHA20POLY1305_KEY_SIZE])
   58 {
   59         xchacha20_poly1305_encrypt(dst, src, src_len, ad, ad_len, nonce, key);
   60 }
   61 
   62 static inline bool
   63 xchacha20poly1305_decrypt(uint8_t *dst, const uint8_t *src,
   64                           const size_t src_len,  const uint8_t *ad,
   65                           const size_t ad_len,
   66                           const uint8_t nonce[XCHACHA20POLY1305_NONCE_SIZE],
   67                           const uint8_t key[CHACHA20POLY1305_KEY_SIZE])
   68 {
   69         return (xchacha20_poly1305_decrypt(dst, src, src_len, ad, ad_len, nonce, key));
   70 }
   71 
   72 int
   73 chacha20poly1305_encrypt_mbuf(struct mbuf *, const uint64_t nonce,
   74                               const uint8_t key[CHACHA20POLY1305_KEY_SIZE]);
   75 
   76 int
   77 chacha20poly1305_decrypt_mbuf(struct mbuf *, const uint64_t nonce,
   78                               const uint8_t key[CHACHA20POLY1305_KEY_SIZE]);
   79 
   80 
   81 enum blake2s_lengths {
   82         BLAKE2S_BLOCK_SIZE = 64,
   83         BLAKE2S_HASH_SIZE = 32,
   84         BLAKE2S_KEY_SIZE = 32
   85 };
   86 
   87 #ifdef COMPAT_NEED_BLAKE2S
   88 struct blake2s_state {
   89         uint32_t h[8];
   90         uint32_t t[2];
   91         uint32_t f[2];
   92         uint8_t buf[BLAKE2S_BLOCK_SIZE];
   93         unsigned int buflen;
   94         unsigned int outlen;
   95 };
   96 
   97 void blake2s_init(struct blake2s_state *state, const size_t outlen);
   98 
   99 void blake2s_init_key(struct blake2s_state *state, const size_t outlen,
  100                       const uint8_t *key, const size_t keylen);
  101 
  102 void blake2s_update(struct blake2s_state *state, const uint8_t *in, size_t inlen);
  103 
  104 void blake2s_final(struct blake2s_state *state, uint8_t *out);
  105 
  106 static inline void blake2s(uint8_t *out, const uint8_t *in, const uint8_t *key,
  107                            const size_t outlen, const size_t inlen, const size_t keylen)
  108 {
  109         struct blake2s_state state;
  110 
  111         if (keylen)
  112                 blake2s_init_key(&state, outlen, key, keylen);
  113         else
  114                 blake2s_init(&state, outlen);
  115 
  116         blake2s_update(&state, in, inlen);
  117         blake2s_final(&state, out);
  118 }
  119 #endif
  120 
  121 #endif

Cache object: c4364ed24e7bc9b23ce07a8ef69e98ad

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/wg/crypto.h

FreeBSD/Linux Kernel Cross Reference
sys/dev/wg/crypto.h