Added support code for RSA and EC key encoding (including reconstruction of all public and private key elements from the private key structure), with raw and PKCS#8 formats, both in DER and PEM.
This commit is contained in:
Thomas Pornin
parent
cfbc702d3d
commit
d8fa415fca
32 changed files with 3528 additions and 105 deletions
|
|
@ -28,6 +28,8 @@
|
|||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "bearssl_rand.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
|
@ -797,6 +799,83 @@ br_ecdsa_vrfy br_ecdsa_vrfy_asn1_get_default(void);
|
|||
*/
|
||||
br_ecdsa_vrfy br_ecdsa_vrfy_raw_get_default(void);
|
||||
|
||||
/**
|
||||
* \brief Maximum size for EC private key element buffer.
|
||||
*
|
||||
* This is the largest number of bytes that `br_ec_keygen()` may need or
|
||||
* ever return.
|
||||
*/
|
||||
#define BR_EC_KBUF_PRIV_MAX_SIZE 72
|
||||
|
||||
/**
|
||||
* \brief Maximum size for EC public key element buffer.
|
||||
*
|
||||
* This is the largest number of bytes that `br_ec_compute_public()` may
|
||||
* need or ever return.
|
||||
*/
|
||||
#define BR_EC_KBUF_PUB_MAX_SIZE 145
|
||||
|
||||
/**
|
||||
* \brief Generate a new EC private key.
|
||||
*
|
||||
* If the specified `curve` is not supported by the elliptic curve
|
||||
* implementation (`impl`), then this function returns zero.
|
||||
*
|
||||
* The `sk` structure fields are set to the new private key data. In
|
||||
* particular, `sk.x` is made to point to the provided key buffer (`kbuf`),
|
||||
* in which the actual private key data is written. That buffer is assumed
|
||||
* to be large enough. The `BR_EC_KBUF_PRIV_MAX_SIZE` defines the maximum
|
||||
* size for all supported curves.
|
||||
*
|
||||
* The number of bytes used in `kbuf` is returned. If `kbuf` is `NULL`, then
|
||||
* the private key is not actually generated, and `sk` may also be `NULL`;
|
||||
* the minimum length for `kbuf` is still computed and returned.
|
||||
*
|
||||
* If `sk` is `NULL` but `kbuf` is not `NULL`, then the private key is
|
||||
* still generated and stored in `kbuf`.
|
||||
*
|
||||
* \param rng_ctx source PRNG context (already initialized).
|
||||
* \param impl the elliptic curve implementation.
|
||||
* \param sk the private key structure to fill, or `NULL`.
|
||||
* \param kbuf the key element buffer, or `NULL`.
|
||||
* \param curve the curve identifier.
|
||||
* \return the key data length (in bytes), or zero.
|
||||
*/
|
||||
size_t br_ec_keygen(const br_prng_class **rng_ctx,
|
||||
const br_ec_impl *impl, br_ec_private_key *sk,
|
||||
void *kbuf, int curve);
|
||||
|
||||
/**
|
||||
* \brief Compute EC public key from EC private key.
|
||||
*
|
||||
* This function uses the provided elliptic curve implementation (`impl`)
|
||||
* to compute the public key corresponding to the private key held in `sk`.
|
||||
* The public key point is written into `kbuf`, which is then linked from
|
||||
* the `*pk` structure. The size of the public key point, i.e. the number
|
||||
* of bytes used in `kbuf`, is returned.
|
||||
*
|
||||
* If `kbuf` is `NULL`, then the public key point is NOT computed, and
|
||||
* the public key structure `*pk` is unmodified (`pk` may be `NULL` in
|
||||
* that case). The size of the public key point is still returned.
|
||||
*
|
||||
* If `pk` is `NULL` but `kbuf` is not `NULL`, then the public key
|
||||
* point is computed and stored in `kbuf`, and its size is returned.
|
||||
*
|
||||
* If the curve used by the private key is not supported by the curve
|
||||
* implementation, then this function returns zero.
|
||||
*
|
||||
* The private key MUST be valid. An off-range private key value is not
|
||||
* necessarily detected, and leads to unpredictable results.
|
||||
*
|
||||
* \param impl the elliptic curve implementation.
|
||||
* \param pk the public key structure to fill (or `NULL`).
|
||||
* \param kbuf the public key point buffer (or `NULL`).
|
||||
* \param sk the source private key.
|
||||
* \return the public key point length (in bytes), or zero.
|
||||
*/
|
||||
size_t br_ec_compute_pub(const br_ec_impl *impl, br_ec_public_key *pk,
|
||||
void *kbuf, const br_ec_private_key *sk);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -236,6 +236,57 @@ br_pem_decoder_name(br_pem_decoder_context *ctx)
|
|||
return ctx->name;
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Encode an object in PEM.
|
||||
*
|
||||
* This function encodes the provided binary object (`data`, of length `len`
|
||||
* bytes) into PEM. The `banner` text will be included in the header and
|
||||
* footer (e.g. use `"CERTIFICATE"` to get a `"BEGIN CERTIFICATE"` header).
|
||||
*
|
||||
* The length (in characters) of the PEM output is returned; that length
|
||||
* does NOT include the terminating zero, that this function nevertheless
|
||||
* adds. If using the returned value for allocation purposes, the allocated
|
||||
* buffer size MUST be at least one byte larger than the returned size.
|
||||
*
|
||||
* If `dest` is `NULL`, then the encoding does not happen; however, the
|
||||
* length of the encoded object is still computed and returned.
|
||||
*
|
||||
* The `data` pointer may be `NULL` only if `len` is zero (when encoding
|
||||
* an object of length zero, which is not very useful), or when `dest`
|
||||
* is `NULL` (in that case, source data bytes are ignored).
|
||||
*
|
||||
* Some `flags` can be specified to alter the encoding behaviour:
|
||||
*
|
||||
* - If `BR_PEM_LINE64` is set, then line-breaking will occur after
|
||||
* every 64 characters of output, instead of the default of 76.
|
||||
*
|
||||
* - If `BR_PEM_CRLF` is set, then end-of-line sequence will use
|
||||
* CR+LF instead of a single LF.
|
||||
*
|
||||
* The `data` and `dest` buffers may overlap, in which case the source
|
||||
* binary data is destroyed in the process. Note that the PEM-encoded output
|
||||
* is always larger than the source binary.
|
||||
*
|
||||
* \param dest the destination buffer (or `NULL`).
|
||||
* \param data the source buffer (can be `NULL` in some cases).
|
||||
* \param len the source length (in bytes).
|
||||
* \param banner the PEM banner expression.
|
||||
* \param flags the behavioural flags.
|
||||
* \return the PEM object length (in characters), EXCLUDING the final zero.
|
||||
*/
|
||||
size_t br_pem_encode(void *dest, const void *data, size_t len,
|
||||
const char *banner, unsigned flags);
|
||||
|
||||
/**
|
||||
* \brief PEM encoding flag: split lines at 64 characters.
|
||||
*/
|
||||
#define BR_PEM_LINE64 0x0001
|
||||
|
||||
/**
|
||||
* \brief PEM encoding flag: use CR+LF line endings.
|
||||
*/
|
||||
#define BR_PEM_CRLF 0x0002
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@
|
|||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "bearssl_rand.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
|
@ -1068,7 +1070,7 @@ uint32_t br_rsa_i62_oaep_decrypt(
|
|||
* Similarly, the public key elements are written in `kbuf_pub`, with
|
||||
* pointers and lengths set in `pk`.
|
||||
*
|
||||
* If `sk` is `NULL`, then `kbuf_pub` may be `NULL`, and only the
|
||||
* If `pk` is `NULL`, then `kbuf_pub` may be `NULL`, and only the
|
||||
* private key is set.
|
||||
*
|
||||
* If `pubexp` is not zero, then its value will be used as public
|
||||
|
|
@ -1098,8 +1100,8 @@ uint32_t br_rsa_i62_oaep_decrypt(
|
|||
*/
|
||||
typedef uint32_t (*br_rsa_keygen)(
|
||||
const br_prng_class **rng_ctx,
|
||||
br_rsa_private_key *sk, unsigned char *kbuf_priv,
|
||||
br_rsa_public_key *pk, unsigned char *kbuf_pub,
|
||||
br_rsa_private_key *sk, void *kbuf_priv,
|
||||
br_rsa_public_key *pk, void *kbuf_pub,
|
||||
unsigned size, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
|
|
@ -1118,8 +1120,8 @@ typedef uint32_t (*br_rsa_keygen)(
|
|||
*/
|
||||
uint32_t br_rsa_i15_keygen(
|
||||
const br_prng_class **rng_ctx,
|
||||
br_rsa_private_key *sk, unsigned char *kbuf_priv,
|
||||
br_rsa_public_key *pk, unsigned char *kbuf_pub,
|
||||
br_rsa_private_key *sk, void *kbuf_priv,
|
||||
br_rsa_public_key *pk, void *kbuf_pub,
|
||||
unsigned size, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
|
|
@ -1138,8 +1140,8 @@ uint32_t br_rsa_i15_keygen(
|
|||
*/
|
||||
uint32_t br_rsa_i31_keygen(
|
||||
const br_prng_class **rng_ctx,
|
||||
br_rsa_private_key *sk, unsigned char *kbuf_priv,
|
||||
br_rsa_public_key *pk, unsigned char *kbuf_pub,
|
||||
br_rsa_private_key *sk, void *kbuf_priv,
|
||||
br_rsa_public_key *pk, void *kbuf_pub,
|
||||
unsigned size, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
|
|
@ -1162,8 +1164,8 @@ uint32_t br_rsa_i31_keygen(
|
|||
*/
|
||||
uint32_t br_rsa_i62_keygen(
|
||||
const br_prng_class **rng_ctx,
|
||||
br_rsa_private_key *sk, unsigned char *kbuf_priv,
|
||||
br_rsa_public_key *pk, unsigned char *kbuf_pub,
|
||||
br_rsa_private_key *sk, void *kbuf_priv,
|
||||
br_rsa_public_key *pk, void *kbuf_pub,
|
||||
unsigned size, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
|
|
@ -1184,6 +1186,176 @@ br_rsa_keygen br_rsa_i62_keygen_get(void);
|
|||
*/
|
||||
br_rsa_keygen br_rsa_keygen_get_default(void);
|
||||
|
||||
/**
|
||||
* \brief Type for a modulus computing function.
|
||||
*
|
||||
* Such a function computes the public modulus from the private key. The
|
||||
* encoded modulus (unsigned big-endian) is written on `n`, and the size
|
||||
* (in bytes) is returned. If `n` is `NULL`, then the size is returned but
|
||||
* the modulus itself is not computed.
|
||||
*
|
||||
* If the key size exceeds an internal limit, 0 is returned.
|
||||
*
|
||||
* \param n destination buffer (or `NULL`).
|
||||
* \param sk RSA private key.
|
||||
* \return the modulus length (in bytes), or 0.
|
||||
*/
|
||||
typedef size_t (*br_rsa_compute_modulus)(void *n, const br_rsa_private_key *sk);
|
||||
|
||||
/**
|
||||
* \brief Recompute RSA modulus ("i15" engine).
|
||||
*
|
||||
* \see br_rsa_compute_modulus
|
||||
*
|
||||
* \param n destination buffer (or `NULL`).
|
||||
* \param sk RSA private key.
|
||||
* \return the modulus length (in bytes), or 0.
|
||||
*/
|
||||
size_t br_rsa_i15_compute_modulus(void *n, const br_rsa_private_key *sk);
|
||||
|
||||
/**
|
||||
* \brief Recompute RSA modulus ("i31" engine).
|
||||
*
|
||||
* \see br_rsa_compute_modulus
|
||||
*
|
||||
* \param n destination buffer (or `NULL`).
|
||||
* \param sk RSA private key.
|
||||
* \return the modulus length (in bytes), or 0.
|
||||
*/
|
||||
size_t br_rsa_i31_compute_modulus(void *n, const br_rsa_private_key *sk);
|
||||
|
||||
/**
|
||||
* \brief Get "default" RSA implementation (recompute modulus).
|
||||
*
|
||||
* This returns the preferred implementation of RSA (recompute modulus)
|
||||
* on the current system.
|
||||
*
|
||||
* \return the default implementation.
|
||||
*/
|
||||
br_rsa_compute_modulus br_rsa_compute_modulus_get_default(void);
|
||||
|
||||
/**
|
||||
* \brief Type for a public exponent computing function.
|
||||
*
|
||||
* Such a function recomputes the public exponent from the private key.
|
||||
* 0 is returned if any of the following occurs:
|
||||
*
|
||||
* - Either `p` or `q` is not equal to 3 modulo 4.
|
||||
*
|
||||
* - The public exponent does not fit on 32 bits.
|
||||
*
|
||||
* - An internal limit is exceeded.
|
||||
*
|
||||
* - The private key is invalid in some way.
|
||||
*
|
||||
* For all private keys produced by the key generator functions
|
||||
* (`br_rsa_keygen` type), this function succeeds and returns the true
|
||||
* public exponent. The public exponent is always an odd integer greater
|
||||
* than 1.
|
||||
*
|
||||
* \return the public exponent, or 0.
|
||||
*/
|
||||
typedef uint32_t (*br_rsa_compute_pubexp)(const br_rsa_private_key *sk);
|
||||
|
||||
/**
|
||||
* \brief Recompute RSA public exponent ("i15" engine).
|
||||
*
|
||||
* \see br_rsa_compute_pubexp
|
||||
*
|
||||
* \return the public exponent, or 0.
|
||||
*/
|
||||
uint32_t br_rsa_i15_compute_pubexp(const br_rsa_private_key *sk);
|
||||
|
||||
/**
|
||||
* \brief Recompute RSA public exponent ("i31" engine).
|
||||
*
|
||||
* \see br_rsa_compute_pubexp
|
||||
*
|
||||
* \return the public exponent, or 0.
|
||||
*/
|
||||
uint32_t br_rsa_i31_compute_pubexp(const br_rsa_private_key *sk);
|
||||
|
||||
/**
|
||||
* \brief Get "default" RSA implementation (recompute public exponent).
|
||||
*
|
||||
* This returns the preferred implementation of RSA (recompute public
|
||||
* exponent) on the current system.
|
||||
*
|
||||
* \return the default implementation.
|
||||
*/
|
||||
br_rsa_compute_pubexp br_rsa_compute_pubexp_get_default(void);
|
||||
|
||||
/**
|
||||
* \brief Type for a private exponent computing function.
|
||||
*
|
||||
* An RSA private key (`br_rsa_private_key`) contains two reduced
|
||||
* private exponents, which are sufficient to perform private key
|
||||
* operations. However, standard encoding formats for RSA private keys
|
||||
* require also a copy of the complete private exponent (non-reduced),
|
||||
* which this function recomputes.
|
||||
*
|
||||
* This function suceeds if all the following conditions hold:
|
||||
*
|
||||
* - Both private factors `p` and `q` are equal to 3 modulo 4.
|
||||
*
|
||||
* - The provided public exponent `pubexp` is correct, and, in particular,
|
||||
* is odd, relatively prime to `p-1` and `q-1`, and greater than 1.
|
||||
*
|
||||
* - No internal storage limit is exceeded.
|
||||
*
|
||||
* For all private keys produced by the key generator functions
|
||||
* (`br_rsa_keygen` type), this function succeeds. Note that the API
|
||||
* restricts the public exponent to a maximum size of 32 bits.
|
||||
*
|
||||
* The encoded private exponent is written in `d` (unsigned big-endian
|
||||
* convention), and the length (in bytes) is returned. If `d` is `NULL`,
|
||||
* then the exponent is not written anywhere, but the length is still
|
||||
* returned. On error, 0 is returned.
|
||||
*
|
||||
* Not all error conditions are detected when `d` is `NULL`; therefore, the
|
||||
* returned value shall be checked also when actually producing the value.
|
||||
*
|
||||
* \param d destination buffer (or `NULL`).
|
||||
* \param sk RSA private key.
|
||||
* \return the private exponent length (in bytes), or 0.
|
||||
*/
|
||||
typedef size_t (*br_rsa_compute_privexp)(void *d,
|
||||
const br_rsa_private_key *sk, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
* \brief Recompute RSA private exponent ("i15" engine).
|
||||
*
|
||||
* \see br_rsa_compute_privexp
|
||||
*
|
||||
* \param d destination buffer (or `NULL`).
|
||||
* \param sk RSA private key.
|
||||
* \return the private exponent length (in bytes), or 0.
|
||||
*/
|
||||
size_t br_rsa_i15_compute_privexp(void *d,
|
||||
const br_rsa_private_key *sk, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
* \brief Recompute RSA private exponent ("i31" engine).
|
||||
*
|
||||
* \see br_rsa_compute_privexp
|
||||
*
|
||||
* \param d destination buffer (or `NULL`).
|
||||
* \param sk RSA private key.
|
||||
* \return the private exponent length (in bytes), or 0.
|
||||
*/
|
||||
size_t br_rsa_i31_compute_privexp(void *d,
|
||||
const br_rsa_private_key *sk, uint32_t pubexp);
|
||||
|
||||
/**
|
||||
* \brief Get "default" RSA implementation (recompute private exponent).
|
||||
*
|
||||
* This returns the preferred implementation of RSA (recompute private
|
||||
* exponent) on the current system.
|
||||
*
|
||||
* \return the default implementation.
|
||||
*/
|
||||
br_rsa_compute_privexp br_rsa_compute_privexp_get_default(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1249,6 +1249,147 @@ br_skey_decoder_get_ec(const br_skey_decoder_context *ctx)
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Encode an RSA private key (raw DER format).
|
||||
*
|
||||
* This function encodes the provided key into the "raw" format specified
|
||||
* in PKCS#1 (RFC 8017, Appendix C, type `RSAPrivateKey`), with DER
|
||||
* encoding rules.
|
||||
*
|
||||
* The key elements are:
|
||||
*
|
||||
* - `sk`: the private key (`p`, `q`, `dp`, `dq` and `iq`)
|
||||
*
|
||||
* - `pk`: the public key (`n` and `e`)
|
||||
*
|
||||
* - `d` (size: `dlen` bytes): the private exponent
|
||||
*
|
||||
* The public key elements, and the private exponent `d`, can be
|
||||
* recomputed from the private key (see `br_rsa_compute_modulus()`,
|
||||
* `br_rsa_compute_pubexp()` and `br_rsa_compute_privexp()`).
|
||||
*
|
||||
* If `dest` is not `NULL`, then the encoded key is written at that
|
||||
* address, and the encoded length (in bytes) is returned. If `dest` is
|
||||
* `NULL`, then nothing is written, but the encoded length is still
|
||||
* computed and returned.
|
||||
*
|
||||
* \param dest the destination buffer (or `NULL`).
|
||||
* \param sk the RSA private key.
|
||||
* \param pk the RSA public key.
|
||||
* \param d the RSA private exponent.
|
||||
* \param dlen the RSA private exponent length (in bytes).
|
||||
* \return the encoded key length (in bytes).
|
||||
*/
|
||||
size_t br_encode_rsa_raw_der(void *dest, const br_rsa_private_key *sk,
|
||||
const br_rsa_public_key *pk, const void *d, size_t dlen);
|
||||
|
||||
/**
|
||||
* \brief Encode an RSA private key (PKCS#8 DER format).
|
||||
*
|
||||
* This function encodes the provided key into the PKCS#8 format
|
||||
* (RFC 5958, type `OneAsymmetricKey`). It wraps around the "raw DER"
|
||||
* format for the RSA key, as implemented by `br_encode_rsa_raw_der()`.
|
||||
*
|
||||
* The key elements are:
|
||||
*
|
||||
* - `sk`: the private key (`p`, `q`, `dp`, `dq` and `iq`)
|
||||
*
|
||||
* - `pk`: the public key (`n` and `e`)
|
||||
*
|
||||
* - `d` (size: `dlen` bytes): the private exponent
|
||||
*
|
||||
* The public key elements, and the private exponent `d`, can be
|
||||
* recomputed from the private key (see `br_rsa_compute_modulus()`,
|
||||
* `br_rsa_compute_pubexp()` and `br_rsa_compute_privexp()`).
|
||||
*
|
||||
* If `dest` is not `NULL`, then the encoded key is written at that
|
||||
* address, and the encoded length (in bytes) is returned. If `dest` is
|
||||
* `NULL`, then nothing is written, but the encoded length is still
|
||||
* computed and returned.
|
||||
*
|
||||
* \param dest the destination buffer (or `NULL`).
|
||||
* \param sk the RSA private key.
|
||||
* \param pk the RSA public key.
|
||||
* \param d the RSA private exponent.
|
||||
* \param dlen the RSA private exponent length (in bytes).
|
||||
* \return the encoded key length (in bytes).
|
||||
*/
|
||||
size_t br_encode_rsa_pkcs8_der(void *dest, const br_rsa_private_key *sk,
|
||||
const br_rsa_public_key *pk, const void *d, size_t dlen);
|
||||
|
||||
/**
|
||||
* \brief Encode an EC private key (raw DER format).
|
||||
*
|
||||
* This function encodes the provided key into the "raw" format specified
|
||||
* in RFC 5915 (type `ECPrivateKey`), with DER encoding rules.
|
||||
*
|
||||
* The private key is provided in `sk`, the public key being `pk`. If
|
||||
* `pk` is `NULL`, then the encoded key will not include the public key
|
||||
* in its `publicKey` field (which is nominally optional).
|
||||
*
|
||||
* If `dest` is not `NULL`, then the encoded key is written at that
|
||||
* address, and the encoded length (in bytes) is returned. If `dest` is
|
||||
* `NULL`, then nothing is written, but the encoded length is still
|
||||
* computed and returned.
|
||||
*
|
||||
* If the key cannot be encoded (e.g. because there is no known OBJECT
|
||||
* IDENTIFIER for the used curve), then 0 is returned.
|
||||
*
|
||||
* \param dest the destination buffer (or `NULL`).
|
||||
* \param sk the EC private key.
|
||||
* \param pk the EC public key (or `NULL`).
|
||||
* \return the encoded key length (in bytes), or 0.
|
||||
*/
|
||||
size_t br_encode_ec_raw_der(void *dest,
|
||||
const br_ec_private_key *sk, const br_ec_public_key *pk);
|
||||
|
||||
/**
|
||||
* \brief Encode an EC private key (PKCS#8 DER format).
|
||||
*
|
||||
* This function encodes the provided key into the PKCS#8 format
|
||||
* (RFC 5958, type `OneAsymmetricKey`). The curve is identified
|
||||
* by an OID provided as parameters to the `privateKeyAlgorithm`
|
||||
* field. The private key value (contents of the `privateKey` field)
|
||||
* contains the DER encoding of the `ECPrivateKey` type defined in
|
||||
* RFC 5915, without the `parameters` field (since they would be
|
||||
* redundant with the information in `privateKeyAlgorithm`).
|
||||
*
|
||||
* The private key is provided in `sk`, the public key being `pk`. If
|
||||
* `pk` is not `NULL`, then the encoded public key is included in the
|
||||
* `publicKey` field of the private key value (but not in the `publicKey`
|
||||
* field of the PKCS#8 `OneAsymmetricKey` wrapper).
|
||||
*
|
||||
* If `dest` is not `NULL`, then the encoded key is written at that
|
||||
* address, and the encoded length (in bytes) is returned. If `dest` is
|
||||
* `NULL`, then nothing is written, but the encoded length is still
|
||||
* computed and returned.
|
||||
*
|
||||
* If the key cannot be encoded (e.g. because there is no known OBJECT
|
||||
* IDENTIFIER for the used curve), then 0 is returned.
|
||||
*
|
||||
* \param dest the destination buffer (or `NULL`).
|
||||
* \param sk the EC private key.
|
||||
* \param pk the EC public key (or `NULL`).
|
||||
* \return the encoded key length (in bytes), or 0.
|
||||
*/
|
||||
size_t br_encode_ec_pkcs8_der(void *dest,
|
||||
const br_ec_private_key *sk, const br_ec_public_key *pk);
|
||||
|
||||
/**
|
||||
* \brief PEM banner for RSA private key (raw).
|
||||
*/
|
||||
#define BR_ENCODE_PEM_RSA_RAW "RSA PRIVATE KEY"
|
||||
|
||||
/**
|
||||
* \brief PEM banner for EC private key (raw).
|
||||
*/
|
||||
#define BR_ENCODE_PEM_EC_RAW "EC PRIVATE KEY"
|
||||
|
||||
/**
|
||||
* \brief PEM banner for an RSA or EC private key in PKCS#8 format.
|
||||
*/
|
||||
#define BR_ENCODE_PEM_PKCS8 "PRIVATE KEY"
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue