/ 
Crypt-Sodium-XS-0.000026
River stage zero No dependents
/ Crypt::Sodium::XS::secretstream

NAME

Crypt::Sodium::XS::secretstream - Secret key authenticated encryption for multiple in-order messages

SYNOPSIS

use Crypt::Sodium::XS::secretstream ":default";

my $key = secretstream_xchacha20poly1305_keygen();

# encryption
my ($header, $stream_enc) = secretstream_xchacha20poly1305_init_encrypt($key);
my $ciphertext = $stream_enc->encrypt("hello,");

my $adata = "foo bar";
my $ct2 = $stream_enc->encrypt(
  " world!",
  secretstream_xchacha20poly1305_TAG_PUSH,
  $adata
);

# decryption
# note that $header (created above) is required to begin decryption.
my $stream_dec = secretstream_xchacha20poly1305_init_decrypt($header, $key);
my $plaintext = $stream_dec->decrypt($ciphertext);

# note that $adata (created above) is required to decrypt successfully.
my ($pt2, $tag) = $stream_dec->decrypt($ct2, $adata);
if ($tag == secretstream_xchacha20poly1305_TAG_MESSAGE()) {
  # default, most common tag
  ...
}
elsif ($tag == secretstream_xchacha20poly1305_TAG_PUSH()) {
  # in-band mark for application to delimit related messages
  ...
}
elsif ($tag == secretstream_xchacha20poly1305_TAG_REKEY()) {
  # re-keying after this message triggered by sender
  ...
}
elsif ($tag == secretstream_xchacha20poly1305_TAG_FINAL()) {
  # last message
  ...
}

DESCRIPTION

Crypt::Sodium::XS::secretstream encrypts a sequence of messages, or a single message split into an arbitrary number of chunks, using a secret key, with the following properties:

  • Messages cannot be truncated, removed, reordered, duplicated or modified without this being detected by the decryption functions.

  • The same sequence encrypted twice will produce different ciphertexts.

  • An authentication tag is added to each encrypted message: stream corruption will be detected early, without having to read the stream until the end.

  • Each message can include additional data (ex: timestamp, protocol version) in the computation of the authentication tag.

  • Messages can have different sizes.

  • There are no practical limits to the total length of the stream, or to the total number of individual messages.

  • Ratcheting: at any point in the stream, it is possible to "forget" the key used to encrypt the previous messages, and switch to a new key.

Crypt::Sodium::XS::secretstream can be used to securely send an ordered sequence of messages to a peer. Since the length of the stream is not limited, it can also be used to encrypt files regardless of their size.

It transparently generates nonces and automatically handles key rotation.

FUNCTIONS

Nothing is exported by default. Crypt::Sodium::XS::secretstream, like libsodium, supports only the primitive-specific functions for one primitive currently. There is a single :xchacha20poly1305 import tag for the functions and constants listed below.

secretstream_xchacha20poly1305_init_decrypt

my $stream_dec = secretstream_xchacha20poly1305_init_decrypt($header, $key);

NOTE: this is the libsodium function crypto_secretstream_xchacha20poly1305_init_pull. Its name is slightly different for consistency of this API.

secretstream_xchacha20poly1305_init_encrypt

my ($header, $stream_enc) = secretstream_xchacha20poly1305_init_encrypt($key);

NOTE: this is the libsodium function crypto_secretstream_xchacha20poly1305_init_push. Its name is slightly different for consistency of this API.

secretstream_xchacha20poly1305_keygen

my $key = secretstream_xchacha20poly1305_keygen();

STREAM INTERFACE

OVERVIEW

An encrypted stream starts with a short header, whose size is "secretstream_xchacha20poly1305_HEADERBYTES" bytes. That header must be sent/stored before the sequence of encrypted messages, as it is required to decrypt the stream. The header content doesn’t have to be secret and decryption with a different header would fail.

A tag is attached to each message. That tag can be any of:

* 0, or "secretstream_xchacha20poly1305_TAG_MESSAGE": the most common tag, that doesn’t add any information about the nature of the message.

* "secretstream_xchacha20poly1305_TAG_FINAL": indicates that the message marks the end of the stream, and erases the secret key used to encrypt the previous sequence.

* "secretstream_xchacha20poly1305_TAG_PUSH": indicates that the message marks the end of a set of messages, but not the end of the stream. For example, a huge JSON string sent as multiple chunks can use this tag to indicate to the application that the string is complete and that it can be decoded. But the stream itself is not closed, and more data may follow.

* "secretstream_xchacha20poly1305_TAG_REKEY": “forget” the key used to encrypt this message and the previous ones, and derive a new secret key.

A typical encrypted stream simply attaches 0 as a tag to all messages, except the last one which is tagged as TAG_FINAL.

Note that tags are encrypted; encrypted streams do not reveal any information about sequence boundaries (PUSH and REKEY tags).

For each message, additional data can be included in the computation of the authentication tag. With this API, additional data is rarely required, and most applications can just use NULL and a length of 0 instead.

ENCRYPTION

The "secretstream_xchacha20poly1305_init_encrypt" method returns a header and a secretstream encryption object. This is an opaque object with the following methods:

encrypt
my $ciphertext = $stream_enc->encrypt($plaintext, $tag, $adata);

$tag is optional, and defaults to "secrestream_xchacha20poly1305_TAG_MESSAGE". The most common use is a tag of "secretstream_xchacha20poly1305_TAG_FINAL" to indicate the last message in a stream.

$adata is optional. If provided, it must match the additional data that was used when encrypting this message. It is rarely needed with the secretstream interface.

DECRYPTION

The "init_decrypt" method is the decryption counterpart for the receiving end of a stream. It takes a header and a secret key; the key must match the one used to create the encryption object, and the header must match the one that was returned when it was created.

Returns a secretstream decryption object. This is an opaque object with the following methods:

decrypt
my $plaintext = $stream_dec->decrypt($ciphertext, $adata);
my ($plaintext, $tag) = $stream_dec->decrypt($ciphertext, $adata);

Croaks on decryption failure.

$tag will be one of the tags listed in "CONSTANTS"; the tag used when encrypting this message. The most common use is a tag of "secretstream_xchacha20poly1305_TAG_FINAL" indicating the last message of a stream.

$adata is optional. It is rarely needed with the secretstream interface.

CONSTANTS

secretstream_PRIMITIVE

my $default_primitive = secretstream_PRIMITIVE();

secretstream_ABYTES

my $additional_data_length = secretstream_ABYTES();

This is not a restriction on the amount of additional data, it is the size of the ciphertext MAC.

secretstream_HEADERBYTES

my $header_length = secretstream_HEADERBYTES();

secretstream_KEYBYTES

my $key_length = secretstream_KEYBYTES();

secretstream_MESSAGEBYTES_MAX

my $message_max_length = secretstream_MESSAGEBYTES_MAX();

secretstream_TAG_MESSAGE

my $message_tag = secretstream_TAG_MESSAGE();

secretstream_TAG_PUSH

my $push_tag = secretstream_TAG_PUSH();

secretstream_TAG_REKEY

my $rekey_tag = secretstream_TAG_REKEY();

secretstream_TAG_FINAL

my $final_tag = secretstream_TAG_FINAL();

PRIMITIVES

All constants (except _PRIMITIVE) and functions have secretstream_<primitive>-prefixed counterparts (e.g., secretstream_xchacha20poly1305_init_decrypt, secretstream_xchacha20poly1305_KEYBYTES).

  • xchacha20poly1305

SEE ALSO

Crypt::Sodium::XS
https://doc.libsodium.org/secret-key_cryptography/secretstream
https://doc.libsodium.org/secret-key_cryptography/encrypted-messages

FEEDBACK

For reporting bugs, giving feedback, submitting patches, etc. please use the following:

For any security sensitive reports, please email the author directly or contact privately via IRC.

AUTHOR

Brad Barden <perlmodules@5c30.org>

COPYRIGHT & LICENSE

Copyright (c) 2022 Brad Barden. All rights reserved.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.