Current section
Files
Jump to
Current section
Files
src/gose@internal@key_encryption.erl
-module(gose@internal@key_encryption).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gose/internal/key_encryption.gleam").
-export([get_octet_key/2, wrap_aes_kw/3, unwrap_aes_kw/3, wrap_aes_gcm/4, unwrap_aes_gcm/5, unwrap_aes_gcm_kw/5, wrap_chacha20_by_variant/4, unwrap_chacha20_by_variant/5, unwrap_chacha20_kw/5, wrap_rsa_oaep/3, unwrap_rsa_oaep/3, wrap_rsa_pkcs1v15/2, unwrap_rsa_pkcs1v15_safe/3, unwrap_direct/2, compute_ecdh_shared_secret/1, compute_ecdh_shared_secret_with_epk/2, derive_ecdh_key/5, wrap_ecdh_es_chacha20_kw/6, unwrap_ecdh_es_chacha20_kw/9, wrap_ecdh_es_direct/5, unwrap_ecdh_es_direct/6, wrap_ecdh_es_kw/6, unwrap_ecdh_es_kw/7]).
-export_type([ephemeral_public_key/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(false).
-type ephemeral_public_key() :: {ec_ephemeral_key,
kryptos@ec:curve(),
bitstring(),
bitstring()} |
{xdh_ephemeral_key, kryptos@xdh:curve(), bitstring()}.
-file("src/gose/internal/key_encryption.gleam", 49).
?DOC(false).
-spec get_octet_key(gose:key(any()), integer()) -> {ok, bitstring()} |
{error, gose:gose_error()}.
get_octet_key(Key, Expected_size) ->
gleam@result:'try'(
begin
_pipe = gose:material_octet_secret(gose:material(Key)),
gleam@result:replace_error(
_pipe,
{invalid_state, <<"expected octet key"/utf8>>}
)
end,
fun(Secret) ->
Actual_size = erlang:byte_size(Secret),
gleam@bool:guard(
Actual_size /= Expected_size,
{error,
{invalid_state,
<<<<<<"expected "/utf8,
(erlang:integer_to_binary(Expected_size))/binary>>/binary,
"-byte key, got "/utf8>>/binary,
(erlang:integer_to_binary(Actual_size))/binary>>}},
fun() -> {ok, Secret} end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 27).
?DOC(false).
-spec wrap_aes_kw(gose:key(any()), bitstring(), gose:aes_key_size()) -> {ok,
bitstring()} |
{error, gose:gose_error()}.
wrap_aes_kw(Key, Cek, Size) ->
gleam@result:'try'(
get_octet_key(Key, gose:aes_key_size(Size)),
fun(Secret) ->
gleam@result:'try'(
gose@internal@content_encryption:aes_cipher(Size, Secret),
fun(Cipher) -> _pipe = kryptos@block:wrap(Cipher, Cek),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"AES Key Wrap failed"/utf8>>}
) end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 38).
?DOC(false).
-spec unwrap_aes_kw(gose:key(any()), bitstring(), gose:aes_key_size()) -> {ok,
bitstring()} |
{error, gose:gose_error()}.
unwrap_aes_kw(Key, Encrypted_key, Size) ->
gleam@result:'try'(
get_octet_key(Key, gose:aes_key_size(Size)),
fun(Secret) ->
gleam@result:'try'(
gose@internal@content_encryption:aes_cipher(Size, Secret),
fun(Cipher) ->
_pipe = kryptos@block:unwrap(Cipher, Encrypted_key),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"AES Key Unwrap failed"/utf8>>}
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 72).
?DOC(false).
-spec wrap_aes_gcm(bitstring(), bitstring(), bitstring(), gose:aes_key_size()) -> {ok,
{bitstring(), bitstring()}} |
{error, gose:gose_error()}.
wrap_aes_gcm(Kek, Cek, Iv, Size) ->
gleam@result:'try'(
gose@internal@content_encryption:aes_cipher(Size, Kek),
fun(Cipher) ->
Ctx = kryptos@aead:gcm(Cipher),
_pipe = kryptos@aead:seal(Ctx, Iv, Cek),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"AES-GCM Key Wrap failed"/utf8>>}
)
end
).
-file("src/gose/internal/key_encryption.gleam", 84).
?DOC(false).
-spec unwrap_aes_gcm(
bitstring(),
bitstring(),
bitstring(),
bitstring(),
gose:aes_key_size()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_aes_gcm(Kek, Encrypted_cek, Iv, Tag, Size) ->
gleam@result:'try'(
gose@internal@content_encryption:aes_cipher(Size, Kek),
fun(Cipher) ->
Ctx = kryptos@aead:gcm(Cipher),
_pipe = kryptos@aead:open(Ctx, Iv, Tag, Encrypted_cek),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"AES-GCM Key Unwrap failed"/utf8>>}
)
end
).
-file("src/gose/internal/key_encryption.gleam", 97).
?DOC(false).
-spec unwrap_aes_gcm_kw(
gose:key(any()),
bitstring(),
gose:aes_key_size(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_aes_gcm_kw(Key, Encrypted_cek, Size, Kw_iv, Kw_tag) ->
gleam@result:'try'(
gleam@option:to_result(
Kw_iv,
{parse_error, <<"missing iv header for AES-GCM Key Wrap"/utf8>>}
),
fun(Iv) ->
gleam@result:'try'(
gleam@option:to_result(
Kw_tag,
{parse_error,
<<"missing tag header for AES-GCM Key Wrap"/utf8>>}
),
fun(Tag) ->
gleam@result:'try'(
get_octet_key(Key, gose:aes_key_size(Size)),
fun(Kek) ->
unwrap_aes_gcm(Kek, Encrypted_cek, Iv, Tag, Size)
end
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 117).
?DOC(false).
-spec chacha20_variant_params(gose:cha_cha20_kw()) -> {fun((bitstring()) -> {ok,
kryptos@aead:aead_context()} |
{error, nil}),
binary()}.
chacha20_variant_params(Variant) ->
case Variant of
c20_p_kw ->
{fun kryptos@aead:chacha20_poly1305/1, <<"ChaCha20-Poly1305"/utf8>>};
x_c20_p_kw ->
{fun kryptos@aead:xchacha20_poly1305/1,
<<"XChaCha20-Poly1305"/utf8>>}
end.
-file("src/gose/internal/key_encryption.gleam", 126).
?DOC(false).
-spec wrap_chacha20_variant(
bitstring(),
bitstring(),
bitstring(),
fun((bitstring()) -> {ok, kryptos@aead:aead_context()} | {error, nil}),
binary()
) -> {ok, {bitstring(), bitstring()}} | {error, gose:gose_error()}.
wrap_chacha20_variant(Kek, Cek, Nonce, Cipher_fn, Variant_name) ->
gleam@result:'try'(
begin
_pipe = Cipher_fn(Kek),
gleam@result:replace_error(
_pipe,
{crypto_error,
<<<<"invalid key size for "/utf8, Variant_name/binary>>/binary,
" Key Wrap"/utf8>>}
)
end,
fun(Ctx) -> _pipe@1 = kryptos@aead:seal(Ctx, Nonce, Cek),
gleam@result:replace_error(
_pipe@1,
{crypto_error, <<Variant_name/binary, " Key Wrap failed"/utf8>>}
) end
).
-file("src/gose/internal/key_encryption.gleam", 143).
?DOC(false).
-spec unwrap_chacha20_variant(
bitstring(),
bitstring(),
bitstring(),
bitstring(),
fun((bitstring()) -> {ok, kryptos@aead:aead_context()} | {error, nil}),
binary()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_chacha20_variant(Kek, Encrypted_cek, Nonce, Tag, Cipher_fn, Variant_name) ->
gleam@result:'try'(
begin
_pipe = Cipher_fn(Kek),
gleam@result:replace_error(
_pipe,
{crypto_error,
<<<<"invalid key size for "/utf8, Variant_name/binary>>/binary,
" Key Unwrap"/utf8>>}
)
end,
fun(Ctx) -> _pipe@1 = kryptos@aead:open(Ctx, Nonce, Tag, Encrypted_cek),
gleam@result:replace_error(
_pipe@1,
{crypto_error,
<<Variant_name/binary, " Key Unwrap failed"/utf8>>}
) end
).
-file("src/gose/internal/key_encryption.gleam", 161).
?DOC(false).
-spec wrap_chacha20_by_variant(
bitstring(),
bitstring(),
bitstring(),
gose:cha_cha20_kw()
) -> {ok, {bitstring(), bitstring()}} | {error, gose:gose_error()}.
wrap_chacha20_by_variant(Kek, Cek, Nonce, Variant) ->
{Cipher_fn, Variant_name} = chacha20_variant_params(Variant),
wrap_chacha20_variant(Kek, Cek, Nonce, Cipher_fn, Variant_name).
-file("src/gose/internal/key_encryption.gleam", 177).
?DOC(false).
-spec unwrap_chacha20_by_variant(
bitstring(),
bitstring(),
bitstring(),
bitstring(),
gose:cha_cha20_kw()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_chacha20_by_variant(Kek, Encrypted_cek, Nonce, Tag, Variant) ->
{Cipher_fn, Variant_name} = chacha20_variant_params(Variant),
unwrap_chacha20_variant(
Kek,
Encrypted_cek,
Nonce,
Tag,
Cipher_fn,
Variant_name
).
-file("src/gose/internal/key_encryption.gleam", 195).
?DOC(false).
-spec unwrap_chacha20_kw(
gose:key(any()),
bitstring(),
gose:cha_cha20_kw(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_chacha20_kw(Key, Encrypted_cek, Variant, Kw_iv, Kw_tag) ->
gleam@result:'try'(
gleam@option:to_result(
Kw_iv,
{parse_error, <<"missing iv header for ChaCha20 Key Wrap"/utf8>>}
),
fun(Iv) ->
gleam@result:'try'(
gleam@option:to_result(
Kw_tag,
{parse_error,
<<"missing tag header for ChaCha20 Key Wrap"/utf8>>}
),
fun(Tag) ->
gleam@result:'try'(
get_octet_key(Key, 32),
fun(Kek) ->
unwrap_chacha20_by_variant(
Kek,
Encrypted_cek,
Iv,
Tag,
Variant
)
end
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 271).
?DOC(false).
-spec wrap_rsa_oaep(gose:key(any()), bitstring(), kryptos@hash:hash_algorithm()) -> {ok,
bitstring()} |
{error, gose:gose_error()}.
wrap_rsa_oaep(Key, Cek, Hash_alg) ->
gleam@result:'try'(
begin
_pipe = gose@internal@key_extract:rsa_public_key(gose:material(Key)),
gleam@result:replace_error(
_pipe,
{invalid_state, <<"RSA encryption requires an RSA key"/utf8>>}
)
end,
fun(Public) ->
Padding = {oaep, Hash_alg, <<>>},
_pipe@1 = kryptos_ffi:rsa_encrypt(Public, Cek, Padding),
gleam@result:replace_error(
_pipe@1,
{crypto_error, <<"RSA-OAEP encryption failed"/utf8>>}
)
end
).
-file("src/gose/internal/key_encryption.gleam", 287).
?DOC(false).
-spec unwrap_rsa_oaep(
gose:key(any()),
bitstring(),
kryptos@hash:hash_algorithm()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_rsa_oaep(Key, Encrypted_key, Hash_alg) ->
gleam@result:'try'(
begin
_pipe = gose@internal@key_extract:rsa_private_key(
gose:material(Key)
),
gleam@result:replace_error(
_pipe,
{invalid_state,
<<"RSA decryption requires an RSA private key"/utf8>>}
)
end,
fun(Private) ->
Padding = {oaep, Hash_alg, <<>>},
_pipe@1 = kryptos_ffi:rsa_decrypt(Private, Encrypted_key, Padding),
gleam@result:replace_error(
_pipe@1,
{crypto_error, <<"RSA-OAEP decryption failed"/utf8>>}
)
end
).
-file("src/gose/internal/key_encryption.gleam", 303).
?DOC(false).
-spec wrap_rsa_pkcs1v15(gose:key(any()), bitstring()) -> {ok, bitstring()} |
{error, gose:gose_error()}.
wrap_rsa_pkcs1v15(Key, Cek) ->
gleam@result:'try'(
begin
_pipe = gose@internal@key_extract:rsa_public_key(gose:material(Key)),
gleam@result:replace_error(
_pipe,
{invalid_state, <<"RSA encryption requires an RSA key"/utf8>>}
)
end,
fun(Public) ->
_pipe@1 = kryptos_ffi:rsa_encrypt(Public, Cek, encrypt_pkcs1v15),
gleam@result:replace_error(
_pipe@1,
{crypto_error, <<"RSA PKCS1v15 encryption failed"/utf8>>}
)
end
).
-file("src/gose/internal/key_encryption.gleam", 337).
?DOC(false).
-spec validate_decrypted_size(bitstring(), integer()) -> {ok, bitstring()} |
{error, nil}.
validate_decrypted_size(Decrypted, Expected_size) ->
case erlang:byte_size(Decrypted) =:= Expected_size of
true ->
{ok, Decrypted};
false ->
{error, nil}
end.
-file("src/gose/internal/key_encryption.gleam", 317).
?DOC(false).
-spec unwrap_rsa_pkcs1v15_safe(gose:key(any()), bitstring(), gose:content_alg()) -> {ok,
bitstring()} |
{error, gose:gose_error()}.
unwrap_rsa_pkcs1v15_safe(Key, Encrypted_key, Enc) ->
gleam@result:'try'(
begin
_pipe = gose@internal@key_extract:rsa_private_key(
gose:material(Key)
),
gleam@result:replace_error(
_pipe,
{invalid_state,
<<"RSA decryption requires an RSA private key"/utf8>>}
)
end,
fun(Private) ->
Expected_size = gose:content_alg_key_size(Enc),
Random_cek = gose@internal@content_encryption:generate_cek(Enc),
Cek = begin
_pipe@1 = kryptos_ffi:rsa_decrypt(
Private,
Encrypted_key,
encrypt_pkcs1v15
),
_pipe@2 = gleam@result:'try'(
_pipe@1,
fun(_capture) ->
validate_decrypted_size(_capture, Expected_size)
end
),
gleam@result:unwrap(_pipe@2, Random_cek)
end,
{ok, Cek}
end
).
-file("src/gose/internal/key_encryption.gleam", 347).
?DOC(false).
-spec unwrap_direct(gose:key(any()), gose:content_alg()) -> {ok, bitstring()} |
{error, gose:gose_error()}.
unwrap_direct(Key, Enc) ->
gleam@result:'try'(
begin
_pipe = gose:material_octet_secret(gose:material(Key)),
gleam@result:replace_error(
_pipe,
{invalid_state,
<<"direct encryption requires an octet key"/utf8>>}
)
end,
fun(Secret) ->
Expected_size = gose:content_alg_key_size(Enc),
Actual_size = erlang:byte_size(Secret),
case Actual_size =:= Expected_size of
true ->
{ok, Secret};
false ->
{error,
{invalid_state,
<<<<<<<<<<"direct encryption requires "/utf8,
(erlang:integer_to_binary(
Expected_size
))/binary>>/binary,
"-byte key for "/utf8>>/binary,
(gleam@string:inspect(Enc))/binary>>/binary,
", got "/utf8>>/binary,
(erlang:integer_to_binary(Actual_size))/binary>>}}
end
end
).
-file("src/gose/internal/key_encryption.gleam", 457).
?DOC(false).
-spec compute_ec_shared_secret(gose:key_material()) -> {ok,
{bitstring(), ephemeral_public_key()}} |
{error, gose:gose_error()}.
compute_ec_shared_secret(Mat) ->
gleam@result:'try'(
gose:material_ec(Mat),
fun(Ec_mat) ->
{Peer_public, Curve@2} = case Ec_mat of
{ec_private, _, Public, Curve} ->
{Public, Curve};
{ec_public, Public@1, Curve@1} ->
{Public@1, Curve@1}
end,
{Ephemeral_private, Ephemeral_public} = kryptos_ffi:ec_generate_key_pair(
Curve@2
),
gleam@result:'try'(
begin
_pipe = kryptos_ffi:ecdh_compute_shared_secret(
Ephemeral_private,
Peer_public
),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"ECDH key agreement failed"/utf8>>}
)
end,
fun(Shared) ->
_pipe@1 = gose:ec_raw_coordinates(Ephemeral_public, Curve@2),
gleam@result:map(
_pipe@1,
fun(Coords) ->
{X, Y} = Coords,
{Shared, {ec_ephemeral_key, Curve@2, X, Y}}
end
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 477).
?DOC(false).
-spec compute_xdh_shared_secret(gose:key_material()) -> {ok,
{bitstring(), ephemeral_public_key()}} |
{error, gose:gose_error()}.
compute_xdh_shared_secret(Mat) ->
gleam@result:'try'(
gose:material_xdh(Mat),
fun(Xdh_mat) ->
{Peer_public, Curve@2} = case Xdh_mat of
{xdh_private, _, Public, Curve} ->
{Public, Curve};
{xdh_public, Public@1, Curve@1} ->
{Public@1, Curve@1}
end,
{Ephemeral_private, Ephemeral_public} = kryptos_ffi:xdh_generate_key_pair(
Curve@2
),
gleam@result:'try'(
begin
_pipe = kryptos@xdh:compute_shared_secret(
Ephemeral_private,
Peer_public
),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"XDH key agreement failed"/utf8>>}
)
end,
fun(Shared) ->
X = kryptos_ffi:xdh_public_key_to_bytes(Ephemeral_public),
{ok, {Shared, {xdh_ephemeral_key, Curve@2, X}}}
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 448).
?DOC(false).
-spec compute_ecdh_shared_secret(gose:key(any())) -> {ok,
{bitstring(), ephemeral_public_key()}} |
{error, gose:gose_error()}.
compute_ecdh_shared_secret(Key) ->
Mat = gose:material(Key),
_pipe = compute_ec_shared_secret(Mat),
_pipe@1 = gleam@result:lazy_or(
_pipe,
fun() -> compute_xdh_shared_secret(Mat) end
),
gleam@result:replace_error(
_pipe@1,
{invalid_state, <<"ECDH-ES requires an EC or XDH key"/utf8>>}
).
-file("src/gose/internal/key_encryption.gleam", 494).
?DOC(false).
-spec compute_ecdh_shared_secret_with_epk(
gose:key(any()),
ephemeral_public_key()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
compute_ecdh_shared_secret_with_epk(Key, Epk) ->
Mat = gose:material(Key),
case Epk of
{ec_ephemeral_key, Epk_curve, X, Y} ->
Key_error = {invalid_state,
<<"key type does not match ephemeral key type"/utf8>>},
gleam@result:'try'(
begin
_pipe = gose:material_ec(Mat),
gleam@result:replace_error(_pipe, Key_error)
end,
fun(Ec_mat) -> case Ec_mat of
{ec_private, Private, _, Curve} ->
gleam@bool:guard(
Curve /= Epk_curve,
{error,
{invalid_state,
<<"ephemeral key curve mismatch"/utf8>>}},
fun() ->
gleam@result:'try'(
gose:ec_public_key_from_raw_coordinates(
Curve,
X,
Y
),
fun(Epk_public) ->
_pipe@1 = kryptos_ffi:ecdh_compute_shared_secret(
Private,
Epk_public
),
gleam@result:replace_error(
_pipe@1,
{crypto_error,
<<"ECDH key agreement failed"/utf8>>}
)
end
)
end
);
{ec_public, _, _} ->
{error, Key_error}
end end
);
{xdh_ephemeral_key, Epk_curve@1, X@1} ->
Key_error@1 = {invalid_state,
<<"key type does not match ephemeral key type"/utf8>>},
gleam@result:'try'(
begin
_pipe@2 = gose:material_xdh(Mat),
gleam@result:replace_error(_pipe@2, Key_error@1)
end,
fun(Xdh_mat) -> case Xdh_mat of
{xdh_private, Private@1, _, Curve@1} ->
gleam@bool:guard(
Curve@1 /= Epk_curve@1,
{error,
{invalid_state,
<<"ephemeral key curve mismatch"/utf8>>}},
fun() ->
gleam@result:'try'(
begin
_pipe@3 = kryptos_ffi:xdh_public_key_from_bytes(
Curve@1,
X@1
),
gleam@result:replace_error(
_pipe@3,
{parse_error,
<<"invalid ephemeral public key"/utf8>>}
)
end,
fun(Epk_public@1) ->
_pipe@4 = kryptos@xdh:compute_shared_secret(
Private@1,
Epk_public@1
),
gleam@result:replace_error(
_pipe@4,
{crypto_error,
<<"XDH key agreement failed"/utf8>>}
)
end
)
end
);
{xdh_public, _, _} ->
{error, Key_error@1}
end end
)
end.
-file("src/gose/internal/key_encryption.gleam", 550).
?DOC(false).
-spec derive_ecdh_key(
bitstring(),
binary(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring()),
integer()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
derive_ecdh_key(Secret, Alg_id, Apu, Apv, Length) ->
Alg_bits = gleam_stdlib:identity(Alg_id),
Alg_len = erlang:byte_size(Alg_bits),
Algorithm_id = <<Alg_len:32, Alg_bits/bitstring>>,
Apu_bits = gleam@option:unwrap(Apu, <<>>),
Apu_len = erlang:byte_size(Apu_bits),
Party_u_info = <<Apu_len:32, Apu_bits/bitstring>>,
Apv_bits = gleam@option:unwrap(Apv, <<>>),
Apv_len = erlang:byte_size(Apv_bits),
Party_v_info = <<Apv_len:32, Apv_bits/bitstring>>,
Supp_pub_info = <<((Length * 8)):32>>,
Info = gleam_stdlib:bit_array_concat(
[Algorithm_id, Party_u_info, Party_v_info, Supp_pub_info]
),
_pipe = kryptos@crypto:concat_kdf(sha256, Secret, Info, Length),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"ECDH key derivation failed"/utf8>>}
).
-file("src/gose/internal/key_encryption.gleam", 215).
?DOC(false).
-spec wrap_ecdh_es_chacha20_kw(
gose:key(any()),
bitstring(),
gose:cha_cha20_kw(),
binary(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, {bitstring(), ephemeral_public_key(), bitstring(), bitstring()}} |
{error, gose:gose_error()}.
wrap_ecdh_es_chacha20_kw(Key, Cek, Variant, Alg_id, Apu, Apv) ->
gleam@result:'try'(
compute_ecdh_shared_secret(Key),
fun(_use0) ->
{Shared_secret, Epk} = _use0,
gleam@result:'try'(
derive_ecdh_key(Shared_secret, Alg_id, Apu, Apv, 32),
fun(Kek) ->
Nonce_size = gose:chacha20_kw_nonce_size(Variant),
Nonce = kryptos_ffi:random_bytes(Nonce_size),
gleam@result:'try'(
wrap_chacha20_by_variant(Kek, Cek, Nonce, Variant),
fun(_use0@1) ->
{Encrypted_cek, Kw_tag} = _use0@1,
{ok, {Encrypted_cek, Epk, Nonce, Kw_tag}}
end
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 243).
?DOC(false).
-spec unwrap_ecdh_es_chacha20_kw(
gose:key(any()),
bitstring(),
gose:cha_cha20_kw(),
binary(),
ephemeral_public_key(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring()),
bitstring(),
bitstring()
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_ecdh_es_chacha20_kw(
Key,
Encrypted_key,
Variant,
Alg_id,
Epk,
Apu,
Apv,
Kw_iv,
Kw_tag
) ->
gleam@result:'try'(
compute_ecdh_shared_secret_with_epk(Key, Epk),
fun(Shared_secret) ->
gleam@result:'try'(
derive_ecdh_key(Shared_secret, Alg_id, Apu, Apv, 32),
fun(Kek) ->
unwrap_chacha20_by_variant(
Kek,
Encrypted_key,
Kw_iv,
Kw_tag,
Variant
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 374).
?DOC(false).
-spec wrap_ecdh_es_direct(
gose:key(any()),
gose:content_alg(),
binary(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, {bitstring(), ephemeral_public_key()}} | {error, gose:gose_error()}.
wrap_ecdh_es_direct(Key, Enc, Alg_id, Apu, Apv) ->
Key_len = gose:content_alg_key_size(Enc),
gleam@result:'try'(
compute_ecdh_shared_secret(Key),
fun(_use0) ->
{Shared_secret, Epk} = _use0,
_pipe = derive_ecdh_key(Shared_secret, Alg_id, Apu, Apv, Key_len),
gleam@result:map(_pipe, fun(Cek) -> {Cek, Epk} end)
end
).
-file("src/gose/internal/key_encryption.gleam", 387).
?DOC(false).
-spec unwrap_ecdh_es_direct(
gose:key(any()),
gose:content_alg(),
binary(),
ephemeral_public_key(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_ecdh_es_direct(Key, Enc, Alg_id, Epk, Apu, Apv) ->
Key_len = gose:content_alg_key_size(Enc),
gleam@result:'try'(
compute_ecdh_shared_secret_with_epk(Key, Epk),
fun(Shared_secret) ->
derive_ecdh_key(Shared_secret, Alg_id, Apu, Apv, Key_len)
end
).
-file("src/gose/internal/key_encryption.gleam", 400).
?DOC(false).
-spec wrap_ecdh_es_kw(
gose:key(any()),
bitstring(),
gose:aes_key_size(),
binary(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, {bitstring(), ephemeral_public_key()}} | {error, gose:gose_error()}.
wrap_ecdh_es_kw(Key, Cek, Size, Alg_id, Apu, Apv) ->
gleam@result:'try'(
compute_ecdh_shared_secret(Key),
fun(_use0) ->
{Shared_secret, Epk} = _use0,
Kw_key_len = gose:aes_key_size(Size),
gleam@result:'try'(
derive_ecdh_key(Shared_secret, Alg_id, Apu, Apv, Kw_key_len),
fun(Kek) ->
gleam@result:'try'(
gose@internal@content_encryption:aes_cipher(Size, Kek),
fun(Cipher) -> _pipe = kryptos@block:wrap(Cipher, Cek),
_pipe@1 = gleam@result:replace_error(
_pipe,
{crypto_error, <<"AES Key Wrap failed"/utf8>>}
),
gleam@result:map(
_pipe@1,
fun(Wrapped) -> {Wrapped, Epk} end
) end
)
end
)
end
).
-file("src/gose/internal/key_encryption.gleam", 424).
?DOC(false).
-spec unwrap_ecdh_es_kw(
gose:key(any()),
bitstring(),
gose:aes_key_size(),
binary(),
ephemeral_public_key(),
gleam@option:option(bitstring()),
gleam@option:option(bitstring())
) -> {ok, bitstring()} | {error, gose:gose_error()}.
unwrap_ecdh_es_kw(Key, Encrypted_key, Size, Alg_id, Epk, Apu, Apv) ->
gleam@result:'try'(
compute_ecdh_shared_secret_with_epk(Key, Epk),
fun(Shared_secret) ->
Kw_key_len = gose:aes_key_size(Size),
gleam@result:'try'(
derive_ecdh_key(Shared_secret, Alg_id, Apu, Apv, Kw_key_len),
fun(Kek) ->
gleam@result:'try'(
gose@internal@content_encryption:aes_cipher(Size, Kek),
fun(Cipher) ->
_pipe = kryptos@block:unwrap(Cipher, Encrypted_key),
gleam@result:replace_error(
_pipe,
{crypto_error, <<"AES Key Unwrap failed"/utf8>>}
)
end
)
end
)
end
).