cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

dh.h (3107B)

      1/* SPDX-License-Identifier: GPL-2.0-or-later */
      2/*
      3 * Diffie-Hellman secret to be used with kpp API along with helper functions
      4 *
      5 * Copyright (c) 2016, Intel Corporation
      6 * Authors: Salvatore Benedetto <salvatore.benedetto@intel.com>
      7 */
      8#ifndef _CRYPTO_DH_
      9#define _CRYPTO_DH_
     10
     11/**
     12 * DOC: DH Helper Functions
     13 *
     14 * To use DH with the KPP cipher API, the following data structure and
     15 * functions should be used.
     16 *
     17 * To use DH with KPP, the following functions should be used to operate on
     18 * a DH private key. The packet private key that can be set with
     19 * the KPP API function call of crypto_kpp_set_secret.
     20 */
     21
     22/**
     23 * struct dh - define a DH private key
     24 *
     25 * @key:	Private DH key
     26 * @p:		Diffie-Hellman parameter P
     27 * @g:		Diffie-Hellman generator G
     28 * @key_size:	Size of the private DH key
     29 * @p_size:	Size of DH parameter P
     30 * @g_size:	Size of DH generator G
     31 */
     32struct dh {
     33	const void *key;
     34	const void *p;
     35	const void *g;
     36	unsigned int key_size;
     37	unsigned int p_size;
     38	unsigned int g_size;
     39};
     40
     41/**
     42 * crypto_dh_key_len() - Obtain the size of the private DH key
     43 * @params:	private DH key
     44 *
     45 * This function returns the packet DH key size. A caller can use that
     46 * with the provided DH private key reference to obtain the required
     47 * memory size to hold a packet key.
     48 *
     49 * Return: size of the key in bytes
     50 */
     51unsigned int crypto_dh_key_len(const struct dh *params);
     52
     53/**
     54 * crypto_dh_encode_key() - encode the private key
     55 * @buf:	Buffer allocated by the caller to hold the packet DH
     56 *		private key. The buffer should be at least crypto_dh_key_len
     57 *		bytes in size.
     58 * @len:	Length of the packet private key buffer
     59 * @params:	Buffer with the caller-specified private key
     60 *
     61 * The DH implementations operate on a packet representation of the private
     62 * key.
     63 *
     64 * Return:	-EINVAL if buffer has insufficient size, 0 on success
     65 */
     66int crypto_dh_encode_key(char *buf, unsigned int len, const struct dh *params);
     67
     68/**
     69 * crypto_dh_decode_key() - decode a private key
     70 * @buf:	Buffer holding a packet key that should be decoded
     71 * @len:	Length of the packet private key buffer
     72 * @params:	Buffer allocated by the caller that is filled with the
     73 *		unpacked DH private key.
     74 *
     75 * The unpacking obtains the private key by pointing @p to the correct location
     76 * in @buf. Thus, both pointers refer to the same memory.
     77 *
     78 * Return:	-EINVAL if buffer has insufficient size, 0 on success
     79 */
     80int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params);
     81
     82/**
     83 * __crypto_dh_decode_key() - decode a private key without parameter checks
     84 * @buf:	Buffer holding a packet key that should be decoded
     85 * @len:	Length of the packet private key buffer
     86 * @params:	Buffer allocated by the caller that is filled with the
     87 *		unpacked DH private key.
     88 *
     89 * Internal function providing the same services as the exported
     90 * crypto_dh_decode_key(), but without any of those basic parameter
     91 * checks conducted by the latter.
     92 *
     93 * Return:	-EINVAL if buffer has insufficient size, 0 on success
     94 */
     95int __crypto_dh_decode_key(const char *buf, unsigned int len,
     96			   struct dh *params);
     97
     98#endif