OSSL_HPKE_CTX_NEW(3ossl)
💖 OSSL_HPKE_CTX_NEW(3ossl) 💖
okay so welcome to the OSSL_HPKE_CTX_NEW(3ossl) page bestie, this is the whole HPKE saga and we're getting into it 💅
🌸 NAME 🌸
OSSL_HPKE_CTX_new, OSSL_HPKE_CTX_free, OSSL_HPKE_encap, OSSL_HPKE_decap, OSSL_HPKE_seal, OSSL_HPKE_open, OSSL_HPKE_export, OSSL_HPKE_suite_check, OSSL_HPKE_str2suite, OSSL_HPKE_keygen, OSSL_HPKE_get_grease_value, OSSL_HPKE_get_ciphertext_size, OSSL_HPKE_get_public_encap_size, OSSL_HPKE_get_recommended_ikmelen, OSSL_HPKE_CTX_set1_psk, OSSL_HPKE_CTX_set1_ikme, OSSL_HPKE_CTX_set1_authpriv, OSSL_HPKE_CTX_set1_authpub, OSSL_HPKE_CTX_get_seq, OSSL_HPKE_CTX_set_seq — Hybrid Public Key Encryption (HPKE) functions 🎀
✨ SYNOPSIS ✨
literally the whole cast of characters, no notes:
#include <openssl/hpke.h>
typedef struct {
uint16_t kem_id;
uint16_t kdf_id;
uint16_t aead_id;
} OSSL_HPKE_SUITE;
OSSL_HPKE_CTX *OSSL_HPKE_CTX_new(int mode, OSSL_HPKE_SUITE suite, int role,
OSSL_LIB_CTX *libctx, const char *propq);
void OSSL_HPKE_CTX_free(OSSL_HPKE_CTX *ctx);
int OSSL_HPKE_encap(OSSL_HPKE_CTX *ctx,
unsigned char *enc, size_t *enclen,
const unsigned char *pub, size_t publen,
const unsigned char *info, size_t infolen);
int OSSL_HPKE_seal(OSSL_HPKE_CTX *ctx,
unsigned char *ct, size_t *ctlen,
const unsigned char *aad, size_t aadlen,
const unsigned char *pt, size_t ptlen);
int OSSL_HPKE_keygen(OSSL_HPKE_SUITE suite,
unsigned char *pub, size_t *publen, EVP_PKEY **priv,
const unsigned char *ikm, size_t ikmlen,
OSSL_LIB_CTX *libctx, const char *propq);
int OSSL_HPKE_decap(OSSL_HPKE_CTX *ctx,
const unsigned char *enc, size_t enclen,
EVP_PKEY *recippriv,
const unsigned char *info, size_t infolen);
int OSSL_HPKE_open(OSSL_HPKE_CTX *ctx,
unsigned char *pt, size_t *ptlen,
const unsigned char *aad, size_t aadlen,
const unsigned char *ct, size_t ctlen);
int OSSL_HPKE_export(OSSL_HPKE_CTX *ctx,
unsigned char *secret, size_t secretlen,
const unsigned char *label, size_t labellen);
int OSSL_HPKE_CTX_set1_authpriv(OSSL_HPKE_CTX *ctx, EVP_PKEY *priv);
int OSSL_HPKE_CTX_set1_authpub(OSSL_HPKE_CTX *ctx,
unsigned char *pub, size_t publen);
int OSSL_HPKE_CTX_set1_psk(OSSL_HPKE_CTX *ctx,
const char *pskid,
const unsigned char *psk, size_t psklen);
int OSSL_HPKE_CTX_get_seq(OSSL_HPKE_CTX *ctx, uint64_t *seq);
int OSSL_HPKE_CTX_set_seq(OSSL_HPKE_CTX *ctx, uint64_t seq);
int OSSL_HPKE_CTX_set1_ikme(OSSL_HPKE_CTX *ctx,
const unsigned char *ikme, size_t ikmelen);
int OSSL_HPKE_suite_check(OSSL_HPKE_SUITE suite);
int OSSL_HPKE_get_grease_value(const OSSL_HPKE_SUITE *suite_in,
OSSL_HPKE_SUITE *suite,
unsigned char *enc, size_t *enclen,
unsigned char *ct, size_t ctlen,
OSSL_LIB_CTX *libctx, const char *propq);
int OSSL_HPKE_str2suite(const char *str, OSSL_HPKE_SUITE *suite);
size_t OSSL_HPKE_get_ciphertext_size(OSSL_HPKE_SUITE suite, size_t clearlen);
size_t OSSL_HPKE_get_public_encap_size(OSSL_HPKE_SUITE suite);
size_t OSSL_HPKE_get_recommended_ikmelen(OSSL_HPKE_SUITE suite);💜 DESCRIPTION 💜
So these functions give you an API for using the flavour of Hybrid Public Key Encryption (HPKE) that's defined in RFC9180. Real talk: you're probably gonna want to understand the HPKE spec before you start poking at these APIs, it's giving "read the docs first" energy. HPKE gets used by a bunch of other IETF specs, including the TLS Encrypted Client Hello (ECH) spec and others ✨
HPKE is a standardised, highly flexible construct for encrypting "to" a public key — and it slays because it supports combinations of a key encapsulation method (KEM), a key derivation function (KDF) and an authenticated encryption with additional data (AEAD) algorithm, plus optional sender authentication 💅
The sender and the receiver here are generally gonna be running some application or protocol that's making use of HPKE. Like, for ECH, the sender is a browser and the receiver is a web server. cute.
🦋 Data Structures 🦋
OSSL_HPKE_SUITE is a structure that holds the identifiers for the algorithms used for KEM, KDF and AEAD operations.
OSSL_HPKE_CTX is a context that keeps the internal state as HPKE operations get carried out. Heads up: separate OSSL_HPKE_CTX objects must be used for the sender and the receiver. Trying to use a single context for both? That's gonna result in errors, no cap 😭
🌈 OSSL_HPKE_SUITE Identifiers 🌈
The identifiers used by OSSL_HPKE_SUITE are:
The KEM identifier kem_id is one of the following:
0x10—OSSL_HPKE_KEM_ID_P2560x11—OSSL_HPKE_KEM_ID_P3840x12—OSSL_HPKE_KEM_ID_P5210x20—OSSL_HPKE_KEM_ID_X255190x21—OSSL_HPKE_KEM_ID_X448
The KDF identifier kdf_id is one of the following:
0x01—OSSL_HPKE_KDF_ID_HKDF_SHA2560x02—OSSL_HPKE_KDF_ID_HKDF_SHA3840x03—OSSL_HPKE_KDF_ID_HKDF_SHA512
The AEAD identifier aead_id is one of the following:
0x01—OSSL_HPKE_AEAD_ID_AES_GCM_1280x02—OSSL_HPKE_AEAD_ID_AES_GCM_2560x03—OSSL_HPKE_AEAD_ID_CHACHA_POLY13050xFFFF—OSSL_HPKE_AEAD_ID_EXPORTONLY
That last identifier up there means AEAD operations are not needed. OSSL_HPKE_export() works, but OSSL_HPKE_open() and OSSL_HPKE_seal() will return an error if you call them with a context that's using that AEAD identifier. so like, don't 🙈
🎀 HPKE Modes 🎀
HPKE supports these variants of Authentication, using a mode Identifier:
OSSL_HPKE_MODE_BASE,0x00— Authentication is not used.OSSL_HPKE_MODE_PSK,0x01— Authenticates possession of a pre-shared key (PSK).OSSL_HPKE_MODE_AUTH,0x02— Authenticates possession of a KEM-based sender private key.OSSL_HPKE_MODE_PSKAUTH,0x03— A combination ofOSSL_HPKE_MODE_PSKandOSSL_HPKE_MODE_AUTH. Both the PSK and the sender's authentication public/private must be supplied before the encapsulation/decapsulation operation will work. both or nothing, bestie.
For further info related to authentication, see "Pre-Shared Key HPKE modes" and "Sender-authenticated HPKE Modes".
🧚 HPKE Roles 🧚
HPKE contexts have a role — either sender or receiver. This controls which functions can be called, and it's also there so that senders don't reuse a key and nonce with different plaintexts (which would be bad, okay, very bad 💀).
OSSL_HPKE_CTX_free(), OSSL_HPKE_export(), OSSL_HPKE_CTX_set1_psk(), and OSSL_HPKE_CTX_get_seq() can be called regardless of role. those ones are for everyone 🫶
OSSL_HPKE_ROLE_SENDER,0— AnOSSL_HPKE_CTXwith this role can be used withOSSL_HPKE_encap(),OSSL_HPKE_seal(),OSSL_HPKE_CTX_set1_ikme()andOSSL_HPKE_CTX_set1_authpriv().OSSL_HPKE_ROLE_RECEIVER,1— AnOSSL_HPKE_CTXwith this role can be used withOSSL_HPKE_decap(),OSSL_HPKE_open(),OSSL_HPKE_CTX_set1_authpub()andOSSL_HPKE_CTX_set_seq().
Calling a function with an incorrect role set on OSSL_HPKE_CTX will result in an error. roleplay matters, but not like that 😭
⭐ Parameter Size Limits ⭐
To improve interoperability, RFC9180, section 7.2.1 suggests a RECOMMENDED maximum size of 64 octets for various input parameters. In this implementation we apply a limit of 66 octets for the ikmlen, psklen, and labellen parameters, and for the length of the string pskid for the HPKE functions below. The constant OSSL_HPKE_MAX_PARMLEN is defined as the limit of this value. (We chose 66 octets so that we can validate all the test vectors present in RFC9180, Appendix A — we love a reason 💅)
In accordance with RFC9180, section 9.5, we define a constant OSSL_HPKE_MIN_PSKLEN with a value of 32 for the minimum length of a pre-shared key, passed in psklen.
Now, while RFC9180 also RECOMMENDS a 64 octet limit for the infolen parameter, that is not sufficient for TLS Encrypted ClientHello (ECH) processing, so we enforce a limit of OSSL_HPKE_MAX_INFOLEN with a value of 1024 as the limit for the infolen parameter. it's giving "we made it bigger on purpose" ✨
💖 Context Construct/Free 💖
OSSL_HPKE_CTX_new() creates an OSSL_HPKE_CTX context object used for subsequent HPKE operations, given a mode (see "HPKE Modes"), suite (see "OSSL_HPKE_SUITE Identifiers") and a role (see "HPKE Roles"). The libctx and propq are used when fetching algorithms from providers and may be set to NULL.
OSSL_HPKE_CTX_free() frees the ctx OSSL_HPKE_CTX that was created previously by a call to OSSL_HPKE_CTX_new(). If the argument to OSSL_HPKE_CTX_free() is NULL, nothing is done. no drama, it just vibes and returns 🦋
🔥 Sender APIs 🔥
A sender's whole goal is to use HPKE to encrypt using a public key — via a KEM, then a KDF, and finally an AEAD. The first step is to encapsulate (using OSSL_HPKE_encap()) the sender's public value using the recipient's public key (pub) and to internally derive secrets. This produces the encapsulated public value (enc) to be sent to the recipient in whatever protocol is using HPKE. Having done the encapsulation step, the sender can then make one or more calls to OSSL_HPKE_seal() to encrypt plaintexts using the secret stored within ctx.
OSSL_HPKE_encap() uses the HPKE context ctx, the recipient public value pub of size publen, and an optional info parameter of size infolen, to produce the encapsulated public value enc. On input enclen should contain the maximum size of the enc buffer, and returns the output size. An error will occur if the input enclen is smaller than the value returned from OSSL_HPKE_get_public_encap_size(). info may be used to bind other protocol or application artefacts such as identifiers. Generally, the encapsulated public value enc corresponds to a single-use ephemeral private value created as part of the encapsulation process. Only a single call to OSSL_HPKE_encap() is allowed for a given OSSL_HPKE_CTX. one and done, periodt.
OSSL_HPKE_seal() takes the OSSL_HPKE_CTX context ctx, the plaintext buffer pt of size ptlen and the optional additional authenticated data buffer aad of size aadlen, and returns the ciphertext ct of size ctlen. On input ctlen should contain the maximum size of the ct buffer, and returns the output size. An error will occur if the input ctlen is smaller than the value returned from OSSL_HPKE_get_public_encap_size().
OSSL_HPKE_encap() must be called before the OSSL_HPKE_seal(). OSSL_HPKE_seal() may be called multiple times, with an internal "nonce" being incremented by one after each call. 🔥
💌 Recipient APIs 💌
ok so recipients are the chill side of HPKE — they're the ones holding a private value that's typically less ephemeral, because the whole point is that their public value gets handed out to potential senders through whatever protocol is doing the HPKE thing. so basically: recipients usually generate a key pair first, and then they have to babysit their private key value using standard mechanisms that live outside the scope of this API. the good news? private keys are just normal EVP_PKEY(3) pointers, so all your usual private key management machinery works on the relevant values 🫶
now, to make encapsulation even possible, the recipient has to get its public value over to the sender. and here's the thing — there is no generic HPKE format defined for that. nope. the relevant formatting is meant to be defined by the application/protocols that make use of HPKE, iykyk. ECH, for example, defines an ECHConfig data structure that combines the public value with other ECH data items. so you gotta use normal library functions to extract the public value in the required format, based on the EVP_PKEY(3) for the private value. no shortcuts bestie 💅
OSSL_HPKE_keygen() is the glow-up for recipients who need to generate a key pair based on the HPKE suite they're gonna use. it hands you back an EVP_PKEY(3) pointer for the private value priv and an encoded public key pub of size publen. on input, publen should hold the max size of the pub buffer, and it comes back with the output size. if your input publen is too small — error, sorry 😭. libctx and propq get used when fetching algorithms from providers and can be set to NULL, no stress. also!! the HPKE spec defines a deterministic key generation scheme where the private value is derived from initial keying material (IKM), so OSSL_HPKE_keygen() has an option to use that scheme too, via the ikm parameter of size ikmlen. if either ikm is NULL or ikmlen is zero, you get a randomly generated key for the relevant suite instead 🎲. and if you need it, ikmlen should be greater than or equal to OSSL_HPKE_get_recommended_ikmelen().
OSSL_HPKE_decap() takes the sender's encapsulated public value produced by OSSL_HPKE_encap() (enc) plus the recipient's EVP_PKEY(3) pointer (prov), and then re-generates the internal secret the sender derived. same as before, there's an optional info parameter that lets you bind that derived secret to other application/protocol artefacts. ⚠️ and this one matters: only a single call to OSSL_HPKE_decap() is allowed for a given OSSL_HPKE_CTX. one. that's it. periodt.
OSSL_HPKE_open() is the recipient's decrypt button 🔓 — it decrypts the ciphertext ct of size ctlen using the ctx and additional authenticated data aad of size aadlen, producing the plaintext pt of size ptlen. on input, ptlen should contain the max size of the pt buffer, and it returns the output size. a pt buffer that's the same size as the ct buffer will suffice — generally the plaintext output is a little smaller than the ciphertext input, cute. error if the input ptlen is too small, obviously. now OSSL_HPKE_open() may be called multiple times, but just like with OSSL_HPKE_seal() there's an internally incrementing nonce value, so ciphertexts need to be presented in the same order that OSSL_HPKE_seal() used. out of order? check "Re-sequencing" if you need to process multiple ciphertexts in a different order 👀
🔐 Exporting Secrets 🔐
HPKE defines a way to produce exported secrets for use by the application. yes bestie, secrets on demand ✨
OSSL_HPKE_export() takes the OSSL_HPKE_CTX and an application supplied label label of size labellen, and produces a secret secret of size secretlen. but the setup is important: the sender must first call OSSL_HPKE_encap(), and the receiver must call OSSL_HPKE_decap(), in order to derive the same shared secret. no matching, no secret 🙈
multiple calls to OSSL_HPKE_export() with the same inputs will produce the same secret (deterministic queen 👑). and here's a fun one: OSSL_HPKE_AEAD_ID_EXPORTONLY may be used as the OSSL_HPKE_SUITE aead_id that's passed to OSSL_HPKE_CTX_new() if the user needs to produce a shared secret but does not wish to perform HPKE encryption. secret without the encryption arc, we love to see it 💜
🪪 Sender-authenticated HPKE Modes 🪪
HPKE defines modes that support KEM-based sender-authentication: OSSL_HPKE_MODE_AUTH and OSSL_HPKE_MODE_PSKAUTH. how does it work? by binding the sender's authentication private/public values into the encapsulation and decapsulation operations 🔗. the key used for these modes must also use the same KEM as the one used for the overall exchange — no mixing, that's the rule. OSSL_HPKE_keygen() can be used to generate the private value you need.
OSSL_HPKE_CTX_set1_authpriv()— the sender's move: set the sender's private privEVP_PKEYkey into theOSSL_HPKE_CTXctx before callingOSSL_HPKE_encap().OSSL_HPKE_CTX_set1_authpub()— the receiver's move: set the sender's encoded pub key of size publen into theOSSL_HPKE_CTXctx before callingOSSL_HPKE_decap().
🤝 Pre-Shared Key HPKE modes 🤝
HPKE also defines a symmetric equivalent to the authentication described above, using a pre-shared key (PSK) and a PSK identifier. PSKs can be used with the OSSL_HPKE_MODE_PSK and OSSL_HPKE_MODE_PSKAUTH modes 🌸
OSSL_HPKE_CTX_set1_psk() sets the PSK identifier pskid string and the PSK buffer psk of size psklen into the ctx. if required, this must be called before OSSL_HPKE_encap() or OSSL_HPKE_decap(). and as per RFC9180, if required, both psk and pskid must be set to non-NULL values. since PSKs are symmetric, the same calls must happen on both the sender and receiver sides — matchy matchy, no cap 🎀
🎲 Deterministic key generation for senders 🎲
normally the sender's ephemeral private key is generated randomly inside OSSL_HPKE_encap() and stays secret forever 🤫. OSSL_HPKE_CTX_set1_ikme() lets the user override that behaviour by setting a deterministic input key material ikm of size ikmlen into the OSSL_HPKE_CTX ctx. if required, OSSL_HPKE_CTX_set1_ikme() can optionally be called before OSSL_HPKE_encap(). ikmlen should be greater than or equal to OSSL_HPKE_get_recommended_ikmelen().
⚠️ real talk: it is generally undesirable to use OSSL_HPKE_CTX_set1_ikme(), since it exposes the relevant secret to the application rather than preserving it within the library, and it's more likely to result in use of predictable values or values that leak. so like… don't unless you really need to 💀
🔁 Re-sequencing 🔁
some protocols have to deal with packet loss while still being able to decrypt arriving packets later. rude, but okay. we provide a way to set the increment used for the nonce for the next subsequent call to OSSL_HPKE_open() — but not to OSSL_HPKE_seal(), as explained below. the OSSL_HPKE_CTX_set_seq() API can be used for exactly this, with the seq parameter value resetting the internal nonce increment to be used for the next call ✨
a baseline nonce value is established based on the encapsulation or decapsulation operation, and is then incremented by 1 for each call to seal or open. (in other words, the first seq increment defaults to zero.)
if a caller needs to figure out how many calls to seal or open have been made, the OSSL_HPKE_CTX_get_seq() API can retrieve the increment (in the seq output) that will be used in the next call to seal or open. that would return 0 before the first call a sender made to OSSL_HPKE_seal(), and 1 after that first call 👑
💀 okay this is the big one: reuse of the same nonce and key with different plaintexts would be very dangerous and could lead to loss of confidentiality and integrity. that's why we only support application control over seq for decryption (i.e. OSSL_HPKE_open()) operations. do not come for us about it.
for compatibility with other implementations, these seq increments are represented as uint64_t.
🧰 Protocol Convenience Functions 🧰
additional convenience APIs let the caller peek at internal details of local HPKE support and/or algorithms — things like parameter lengths. very handy, very demure 🌈
OSSL_HPKE_suite_check()— checks if a specificOSSL_HPKE_SUITEsuite is supported locally. vibe check for algorithms, basically.OSSL_HPKE_get_ciphertext_size()— to assist with memory allocation, this tells the caller by how much ciphertext will be longer than a plaintext of length clearlen. (AEAD algorithms add a data integrity tag, so yeah, there's a small amount of ciphertext expansion. that's the tag, babe 🏷️)OSSL_HPKE_get_public_encap_size()— gives senders a way to know how big the encapsulated public value will be for a given HPKE suite.OSSL_HPKE_get_recommended_ikmelen()— returns the recommended Input Key Material size (in bytes) for a given suite. this is needed in cases where the same public value needs to be regenerated by a sender before callingOSSL_HPKE_seal(). ikmlen should be at least this size.OSSL_HPKE_get_grease_value()— produces values of the appropriate length for a given suite_in value (or a random value if suite_in isNULL), so a protocol using HPKE can send so-called GREASE (see RFC8701) values that are harder to distinguish from a real use of HPKE 🧈. buffer sizes should be supplied on input. the output enc value will have an appropriate length for suite_out and a random value, and the ct output will be a random value. the relevant sizes for buffers can be found usingOSSL_HPKE_get_ciphertext_size()andOSSL_HPKE_get_public_encap_size().OSSL_HPKE_str2suite()— maps input str strings to anOSSL_HPKE_SUITEobject. the input str should be a comma-separated string with a KEM, KDF and AEAD name in that order, for example:
"x25519,hkdf-sha256,aes-128-gcm"this can be used by command line tools that accept string form names for HPKE codepoints 🖥️. valid (case-insensitive) names are: "p-256", "p-384", "p-521", "x25519" and "x448" for KEM; "hkdf-sha256", "hkdf-sha384" and "hkdf-sha512" for KDF; and "aes-128-gcm", "aes-256-gcm", "chacha20-poly1305" and "exporter" for AEAD. string variants of the numbers listed in "OSSL_HPKE_SUITE Identifiers" can also be used 💅
🌟 RETURN VALUES 🌟
OSSL_HPKE_CTX_new()returns anOSSL_HPKE_CTXpointer, orNULLon error 😭OSSL_HPKE_get_ciphertext_size(),OSSL_HPKE_get_public_encap_size(), andOSSL_HPKE_get_recommended_ikmelen()all return asize_twith the relevant value, or zero on error.- all other functions return
1for success or zero for error. yes, the classic ✨
✨ EXAMPLES ✨
Okay bestie, this is the part where we actually do the thing 🎀 Here's a minimal round-trip with HPKE — one side generates a key, the other encrypts, and then we decrypt it back. Pure main character energy, no cap.
#include <stddef.h>
#include <string.h>
#include <openssl/hpke.h>
#include <openssl/evp.h>
/*
* this is big enough for this example, real code would need different
* handling
*/
#define LBUFSIZE 48
/* Do a round-trip, generating a key, encrypting and decrypting */
int main(int argc, char **argv)
{
int ok = 0;
int hpke_mode = OSSL_HPKE_MODE_BASE;
OSSL_HPKE_SUITE hpke_suite = OSSL_HPKE_SUITE_DEFAULT;
OSSL_HPKE_CTX *sctx = NULL, *rctx = NULL;
EVP_PKEY *priv = NULL;
unsigned char pub[LBUFSIZE];
size_t publen = sizeof(pub);
unsigned char enc[LBUFSIZE];
size_t enclen = sizeof(enc);
unsigned char ct[LBUFSIZE];
size_t ctlen = sizeof(ct);
unsigned char clear[LBUFSIZE];
size_t clearlen = sizeof(clear);
const unsigned char *pt = "a message not in a bottle";
size_t ptlen = strlen((char *)pt);
const unsigned char *info = "Some info";
size_t infolen = strlen((char *)info);
unsigned char aad[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
size_t aadlen = sizeof(aad);
/*
* Generate receiver's key pair.
* The receiver gives this public key to the sender.
*/
if (OSSL_HPKE_keygen(hpke_suite, pub, &publen, &priv,
NULL, 0, NULL, NULL) != 1)
goto err;
/* sender's actions - encrypt data using the receivers public key */
if ((sctx = OSSL_HPKE_CTX_new(hpke_mode, hpke_suite,
OSSL_HPKE_ROLE_SENDER,
NULL, NULL)) == NULL)
goto err;
if (OSSL_HPKE_encap(sctx, enc, &enclen, pub, publen, info, infolen) != 1)
goto err;
if (OSSL_HPKE_seal(sctx, ct, &ctlen, aad, aadlen, pt, ptlen) != 1)
goto err;
/* receiver's actions - decrypt data using the receivers private key */
if ((rctx = OSSL_HPKE_CTX_new(hpke_mode, hpke_suite,
OSSL_HPKE_ROLE_RECEIVER,
NULL, NULL)) == NULL)
goto err;
if (OSSL_HPKE_decap(rctx, enc, enclen, priv, info, infolen) != 1)
goto err;
if (OSSL_HPKE_open(rctx, clear, &clearlen, aad, aadlen, ct, ctlen) != 1)
goto err;
ok = 1;
err:
/* clean up */
printf(ok ? "All Good!\n" : "Error!\n");
OSSL_HPKE_CTX_free(rctx);
OSSL_HPKE_CTX_free(sctx);
EVP_PKEY_free(priv);
return 0;
}Like, walk through it with me 💅 The receiver runs OSSL_HPKE_keygen(hpke_suite, pub, &publen, &priv, NULL, 0, NULL, NULL) to make a key pair and hands the public half to the sender. Sender spins up a context with OSSL_HPKE_CTX_new(hpke_mode, hpke_suite, OSSL_HPKE_ROLE_SENDER, NULL, NULL), calls OSSL_HPKE_encap(sctx, enc, &enclen, pub, publen, info, infolen), then OSSL_HPKE_seal(sctx, ct, &ctlen, aad, aadlen, pt, ptlen) for the actual encryption. Receiver side is the mirror image: OSSL_HPKE_CTX_new(hpke_mode, hpke_suite, OSSL_HPKE_ROLE_RECEIVER, NULL, NULL), then OSSL_HPKE_decap(rctx, enc, enclen, priv, info, infolen), then OSSL_HPKE_open(rctx, clear, &clearlen, aad, aadlen, ct, ctlen). And then ok = 1 because we ate and left no crumbs 🔥 Note the LBUFSIZE 48 comment — that's just big enough for this example, real code would need different handling, so don't go copying that size into prod, bestie 🙈
💀 WARNINGS 💀
Okay this is the serious part, so put your phone down for a sec 🫶
Note that the OSSL_HPKE_CTX_set_seq() API could be dangerous — if used with GCM that could lead to nonce-reuse, which is a known danger. So avoid that entirely, or be very very careful when using that API. Like, actually careful. Not "I skimmed the docs" careful 😭
Use of an IKM value for deterministic key generation (via OSSL_HPKE_CTX_set1_ikme() or OSSL_HPKE_keygen()) creates the potential for leaking keys (or IKM values). Only use that if really needed and if you understand how keys or IKM values could be abused. No vibes-based crypto decisions, please 🎀
🦋 SEE ALSO 🦋
- The RFC9180 specification: https://datatracker.ietf.org/doc/rfc9180/ — go read it, it's giving source material ⭐
🌸 HISTORY 🌸
This functionality described here was added in OpenSSL 3.2. So if you're on something older, that's why it's not working, and no amount of recompiling will fix it, iykyk 💅
👑 COPYRIGHT 👑
Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
Licensed under the Apache License 2.0 (the "License"). You may not use this file except in compliance with the License. You can obtain a copy in the file LICENSE in the source distribution or at <https://www.openssl.org/source/license.html>.
And that's the whole page, bestie, we literally did it 🎉 This lil rewrite is living in OpenSSL 3.5.6, dated 2026-04-07, and it's filed under OSSL_HPKE_CTX_NEW(3ossl) — go forth and encrypt responsibly, mwah 💖✨
📦 where this page comes from
- freebsd 15.1: base 15.1
- 💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on : a language model's rewrite of the original, under its terms