skunky/neptune
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

тонна гонвнокода

Browse source
This commit is contained in:
lost+skunk 2025-03-11 01:01:54 +03:00
parent 5ea0e943fb
commit 6b7bf681ae
25 changed files with 4396 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

2223
source/bindings/curl.d Normal file
View file

File diff suppressed because it is too large Load diff

93
source/bindings/olm/error.d Normal file
View file

@ -0,0 +1,93 @@
/* Copyright 2015-2016 OpenMarket Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
module libolm.error;
extern (C):
enum OlmErrorCode
{
OLM_SUCCESS = 0, /*!< There wasn't an error */
OLM_NOT_ENOUGH_RANDOM = 1, /*!< Not enough entropy was supplied */
OLM_OUTPUT_BUFFER_TOO_SMALL = 2, /*!< Supplied output buffer is too small */
OLM_BAD_MESSAGE_VERSION = 3, /*!< The message version is unsupported */
OLM_BAD_MESSAGE_FORMAT = 4, /*!< The message couldn't be decoded */
OLM_BAD_MESSAGE_MAC = 5, /*!< The message couldn't be decrypted */
OLM_BAD_MESSAGE_KEY_ID = 6, /*!< The message references an unknown key id */
OLM_INVALID_BASE64 = 7, /*!< The input base64 was invalid */
OLM_BAD_ACCOUNT_KEY = 8, /*!< The supplied account key is invalid */
OLM_UNKNOWN_PICKLE_VERSION = 9, /*!< The pickled object is too new */
OLM_CORRUPTED_PICKLE = 10, /*!< The pickled object couldn't be decoded */
OLM_BAD_SESSION_KEY = 11, /*!< Attempt to initialise an inbound group
session from an invalid session key */
OLM_UNKNOWN_MESSAGE_INDEX = 12, /*!< Attempt to decode a message whose
* index is earlier than our earliest
* known session key.
*/
/**
* Attempt to unpickle an account which uses pickle version 1 (which did
* not save enough space for the Ed25519 key; the key should be considered
* compromised. We don't let the user reload the account.
*/
OLM_BAD_LEGACY_ACCOUNT_PICKLE = 13,
/**
* Received message had a bad signature
*/
OLM_BAD_SIGNATURE = 14,
OLM_INPUT_BUFFER_TOO_SMALL = 15,
/**
* SAS doesn't have their key set.
*/
OLM_SAS_THEIR_KEY_NOT_SET = 16,
/**
* The pickled object was successfully decoded, but the unpickling still failed
* because it had some extraneous junk data at the end.
*/
OLM_PICKLE_EXTRA_DATA = 17
/* remember to update the list of string constants in error.c when updating
* this list. */
}
alias OLM_SUCCESS = OlmErrorCode.OLM_SUCCESS;
alias OLM_NOT_ENOUGH_RANDOM = OlmErrorCode.OLM_NOT_ENOUGH_RANDOM;
alias OLM_OUTPUT_BUFFER_TOO_SMALL = OlmErrorCode.OLM_OUTPUT_BUFFER_TOO_SMALL;
alias OLM_BAD_MESSAGE_VERSION = OlmErrorCode.OLM_BAD_MESSAGE_VERSION;
alias OLM_BAD_MESSAGE_FORMAT = OlmErrorCode.OLM_BAD_MESSAGE_FORMAT;
alias OLM_BAD_MESSAGE_MAC = OlmErrorCode.OLM_BAD_MESSAGE_MAC;
alias OLM_BAD_MESSAGE_KEY_ID = OlmErrorCode.OLM_BAD_MESSAGE_KEY_ID;
alias OLM_INVALID_BASE64 = OlmErrorCode.OLM_INVALID_BASE64;
alias OLM_BAD_ACCOUNT_KEY = OlmErrorCode.OLM_BAD_ACCOUNT_KEY;
alias OLM_UNKNOWN_PICKLE_VERSION = OlmErrorCode.OLM_UNKNOWN_PICKLE_VERSION;
alias OLM_CORRUPTED_PICKLE = OlmErrorCode.OLM_CORRUPTED_PICKLE;
alias OLM_BAD_SESSION_KEY = OlmErrorCode.OLM_BAD_SESSION_KEY;
alias OLM_UNKNOWN_MESSAGE_INDEX = OlmErrorCode.OLM_UNKNOWN_MESSAGE_INDEX;
alias OLM_BAD_LEGACY_ACCOUNT_PICKLE = OlmErrorCode.OLM_BAD_LEGACY_ACCOUNT_PICKLE;
alias OLM_BAD_SIGNATURE = OlmErrorCode.OLM_BAD_SIGNATURE;
alias OLM_INPUT_BUFFER_TOO_SMALL = OlmErrorCode.OLM_INPUT_BUFFER_TOO_SMALL;
alias OLM_SAS_THEIR_KEY_NOT_SET = OlmErrorCode.OLM_SAS_THEIR_KEY_NOT_SET;
alias OLM_PICKLE_EXTRA_DATA = OlmErrorCode.OLM_PICKLE_EXTRA_DATA;
/** get a string representation of the given error code. */
const(char)* _olm_error_to_string (OlmErrorCode error);
// extern "C"
/* OLM_ERROR_H_ */

188
source/bindings/olm/inbound.d Normal file
View file

@ -0,0 +1,188 @@
module libolm.inbound;
/* Copyright 2016 OpenMarket Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import libolm.error;
@nogc:
extern (C):
struct OlmInboundGroupSession;
/** get the size of an inbound group session, in bytes. */
size_t olm_inbound_group_session_size ();
/**
* Initialise an inbound group session object using the supplied memory
* The supplied memory should be at least olm_inbound_group_session_size()
* bytes.
*/
OlmInboundGroupSession* olm_inbound_group_session (void* memory);
/**
* A null terminated string describing the most recent error to happen to a
* group session */
const(char)* olm_inbound_group_session_last_error (const(OlmInboundGroupSession)* session);
/**
* An error code describing the most recent error to happen to a group
* session */
OlmErrorCode olm_inbound_group_session_last_error_code (const(OlmInboundGroupSession)* session);
/** Clears the memory used to back this group session */
size_t olm_clear_inbound_group_session (OlmInboundGroupSession* session);
/** Returns the number of bytes needed to store an inbound group session */
size_t olm_pickle_inbound_group_session_length (const(OlmInboundGroupSession)* session);
/**
* Stores a group session as a base64 string. Encrypts the session using the
* supplied key. Returns the length of the session on success.
*
* Returns olm_error() on failure. If the pickle output buffer
* is smaller than olm_pickle_inbound_group_session_length() then
* olm_inbound_group_session_last_error() will be "OUTPUT_BUFFER_TOO_SMALL"
*/
size_t olm_pickle_inbound_group_session (OlmInboundGroupSession* session, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/**
* Loads a group session from a pickled base64 string. Decrypts the session
* using the supplied key.
*
* Returns olm_error() on failure. If the key doesn't match the one used to
* encrypt the account then olm_inbound_group_session_last_error() will be
* "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* olm_inbound_group_session_last_error() will be "INVALID_BASE64". The input
* pickled buffer is destroyed
*/
size_t olm_unpickle_inbound_group_session (OlmInboundGroupSession* session, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/**
* Start a new inbound group session, from a key exported from
* olm_outbound_group_session_key
*
* Returns olm_error() on failure. On failure last_error will be set with an
* error code. The last_error will be:
*
* * OLM_INVALID_BASE64 if the session_key is not valid base64
* * OLM_BAD_SESSION_KEY if the session_key is invalid
*/
/* base64-encoded keys */
size_t olm_init_inbound_group_session (OlmInboundGroupSession* session, const(ubyte)* session_key, size_t session_key_length);
/**
* Import an inbound group session, from a previous export.
*
* Returns olm_error() on failure. On failure last_error will be set with an
* error code. The last_error will be:
*
* * OLM_INVALID_BASE64 if the session_key is not valid base64
* * OLM_BAD_SESSION_KEY if the session_key is invalid
*/
/* base64-encoded keys; note that it will be overwritten with the base64-decoded
data. */
size_t olm_import_inbound_group_session (OlmInboundGroupSession* session, const(ubyte)* session_key, size_t session_key_length);
/**
* Get an upper bound on the number of bytes of plain-text the decrypt method
* will write for a given input message length. The actual size could be
* different due to padding.
*
* The input message buffer is destroyed.
*
* Returns olm_error() on failure.
*/
size_t olm_group_decrypt_max_plaintext_length (OlmInboundGroupSession* session, ubyte* message, size_t message_length);
/**
* Decrypt a message.
*
* The input message buffer is destroyed.
*
* Returns the length of the decrypted plain-text, or olm_error() on failure.
*
* On failure last_error will be set with an error code. The last_error will
* be:
* * OLM_OUTPUT_BUFFER_TOO_SMALL if the plain-text buffer is too small
* * OLM_INVALID_BASE64 if the message is not valid base-64
* * OLM_BAD_MESSAGE_VERSION if the message was encrypted with an unsupported
* version of the protocol
* * OLM_BAD_MESSAGE_FORMAT if the message headers could not be decoded
* * OLM_BAD_MESSAGE_MAC if the message could not be verified
* * OLM_UNKNOWN_MESSAGE_INDEX if we do not have a session key corresponding to the
* message's index (ie, it was sent before the session key was shared with
* us)
*/
/* input; note that it will be overwritten with the base64-decoded
message. */
/* output */
size_t olm_group_decrypt (OlmInboundGroupSession* session, ubyte* message, size_t message_length, ubyte* plaintext, size_t max_plaintext_length, uint* message_index);
/**
* Get the number of bytes returned by olm_inbound_group_session_id()
*/
size_t olm_inbound_group_session_id_length (const(OlmInboundGroupSession)* session);
/**
* Get a base64-encoded identifier for this session.
*
* Returns the length of the session id on success or olm_error() on
* failure. On failure last_error will be set with an error code. The
* last_error will be OUTPUT_BUFFER_TOO_SMALL if the id buffer was too
* small.
*/
size_t olm_inbound_group_session_id (OlmInboundGroupSession* session, ubyte* id, size_t id_length);
/**
* Get the first message index we know how to decrypt.
*/
uint olm_inbound_group_session_first_known_index (const(OlmInboundGroupSession)* session);
/**
* Check if the session has been verified as a valid session.
*
* (A session is verified either because the original session share was signed,
* or because we have subsequently successfully decrypted a message.)
*
* This is mainly intended for the unit tests, currently.
*/
int olm_inbound_group_session_is_verified (const(OlmInboundGroupSession)* session);
/**
* Get the number of bytes returned by olm_export_inbound_group_session()
*/
size_t olm_export_inbound_group_session_length (const(OlmInboundGroupSession)* session);
/**
* Export the base64-encoded ratchet key for this session, at the given index,
* in a format which can be used by olm_import_inbound_group_session
*
* Returns the length of the ratchet key on success or olm_error() on
* failure. On failure last_error will be set with an error code. The
* last_error will be:
* * OUTPUT_BUFFER_TOO_SMALL if the buffer was too small
* * OLM_UNKNOWN_MESSAGE_INDEX if we do not have a session key corresponding to the
* given index (ie, it was sent before the session key was shared with
* us)
*/
size_t olm_export_inbound_group_session (OlmInboundGroupSession* session, ubyte* key, size_t key_length, uint message_index);
// extern "C"
/* OLM_INBOUND_GROUP_SESSION_H_ */

349
source/bindings/olm/olm.d Normal file
View file

@ -0,0 +1,349 @@
/* Copyright 2015, 2016 OpenMarket Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import libolm.error;
extern (C):
extern __gshared const size_t OLM_MESSAGE_TYPE_PRE_KEY;
extern __gshared const size_t OLM_MESSAGE_TYPE_MESSAGE;
struct OlmAccount;
struct OlmSession;
struct OlmUtility;
/** Get the version number of the library.
* Arguments will be updated if non-null.
*/
void olm_get_library_version (ubyte* major, ubyte* minor, ubyte* patch);
/** The size of an account object in bytes */
size_t olm_account_size ();
/** The size of a session object in bytes */
size_t olm_session_size ();
/** The size of a utility object in bytes */
size_t olm_utility_size ();
/** Initialise an account object using the supplied memory
* The supplied memory must be at least olm_account_size() bytes */
OlmAccount* olm_account (void* memory);
/** Initialise a session object using the supplied memory
* The supplied memory must be at least olm_session_size() bytes */
OlmSession* olm_session (void* memory);
/** Initialise a utility object using the supplied memory
* The supplied memory must be at least olm_utility_size() bytes */
OlmUtility* olm_utility (void* memory);
/** The value that olm will return from a function if there was an error */
size_t olm_error ();
/** A null terminated string describing the most recent error to happen to an
* account */
const(char)* olm_account_last_error (const(OlmAccount)* account);
/** An error code describing the most recent error to happen to an account */
OlmErrorCode olm_account_last_error_code (const(OlmAccount)* account);
/** A null terminated string describing the most recent error to happen to a
* session */
const(char)* olm_session_last_error (const(OlmSession)* session);
/** An error code describing the most recent error to happen to a session */
OlmErrorCode olm_session_last_error_code (const(OlmSession)* session);
/** A null terminated string describing the most recent error to happen to a
* utility */
const(char)* olm_utility_last_error (const(OlmUtility)* utility);
/** An error code describing the most recent error to happen to a utility */
OlmErrorCode olm_utility_last_error_code (const(OlmUtility)* utility);
/** Clears the memory used to back this account */
size_t olm_clear_account (OlmAccount* account);
/** Clears the memory used to back this session */
size_t olm_clear_session (OlmSession* session);
/** Clears the memory used to back this utility */
size_t olm_clear_utility (OlmUtility* utility);
/** Returns the number of bytes needed to store an account */
size_t olm_pickle_account_length (const(OlmAccount)* account);
/** Returns the number of bytes needed to store a session */
size_t olm_pickle_session_length (const(OlmSession)* session);
/** Stores an account as a base64 string. Encrypts the account using the
* supplied key. Returns the length of the pickled account on success.
* Returns olm_error() on failure. If the pickle output buffer
* is smaller than olm_pickle_account_length() then
* olm_account_last_error() will be "OUTPUT_BUFFER_TOO_SMALL" */
size_t olm_pickle_account (OlmAccount* account, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/** Stores a session as a base64 string. Encrypts the session using the
* supplied key. Returns the length of the pickled session on success.
* Returns olm_error() on failure. If the pickle output buffer
* is smaller than olm_pickle_session_length() then
* olm_session_last_error() will be "OUTPUT_BUFFER_TOO_SMALL" */
size_t olm_pickle_session (OlmSession* session, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/** Loads an account from a pickled base64 string. Decrypts the account using
* the supplied key. Returns olm_error() on failure. If the key doesn't
* match the one used to encrypt the account then olm_account_last_error()
* will be "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* olm_account_last_error() will be "INVALID_BASE64". The input pickled
* buffer is destroyed */
size_t olm_unpickle_account (OlmAccount* account, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/** Loads a session from a pickled base64 string. Decrypts the session using
* the supplied key. Returns olm_error() on failure. If the key doesn't
* match the one used to encrypt the account then olm_session_last_error()
* will be "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* olm_session_last_error() will be "INVALID_BASE64". The input pickled
* buffer is destroyed */
size_t olm_unpickle_session (OlmSession* session, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/** The number of random bytes needed to create an account.*/
size_t olm_create_account_random_length (const(OlmAccount)* account);
/** Creates a new account. Returns olm_error() on failure. If there weren't
* enough random bytes then olm_account_last_error() will be
* "NOT_ENOUGH_RANDOM" */
size_t olm_create_account (OlmAccount* account, void* random, size_t random_length);
/** The size of the output buffer needed to hold the identity keys */
size_t olm_account_identity_keys_length (const(OlmAccount)* account);
/** Writes the public parts of the identity keys for the account into the
* identity_keys output buffer. Returns olm_error() on failure. If the
* identity_keys buffer was too small then olm_account_last_error() will be
* "OUTPUT_BUFFER_TOO_SMALL". */
size_t olm_account_identity_keys (OlmAccount* account, void* identity_keys, size_t identity_key_length);
/** The length of an ed25519 signature encoded as base64. */
size_t olm_account_signature_length (const(OlmAccount)* account);
/** Signs a message with the ed25519 key for this account. Returns olm_error()
* on failure. If the signature buffer was too small then
* olm_account_last_error() will be "OUTPUT_BUFFER_TOO_SMALL" */
size_t olm_account_sign (OlmAccount* account, const(void)* message, size_t message_length, void* signature, size_t signature_length);
/** The size of the output buffer needed to hold the one time keys */
size_t olm_account_one_time_keys_length (const(OlmAccount)* account);
/** Writes the public parts of the unpublished one time keys for the account
* into the one_time_keys output buffer.
* <p>
* The returned data is a JSON-formatted object with the single property
* <tt>curve25519</tt>, which is itself an object mapping key id to
* base64-encoded Curve25519 key. For example:
* <pre>
* {
* curve25519: {
* "AAAAAA": "wo76WcYtb0Vk/pBOdmduiGJ0wIEjW4IBMbbQn7aSnTo",
* "AAAAAB": "LRvjo46L1X2vx69sS9QNFD29HWulxrmW11Up5AfAjgU"
* }
* }
* </pre>
* Returns olm_error() on failure.
* <p>
* If the one_time_keys buffer was too small then olm_account_last_error()
* will be "OUTPUT_BUFFER_TOO_SMALL". */
size_t olm_account_one_time_keys (OlmAccount* account, void* one_time_keys, size_t one_time_keys_length);
/** Marks the current set of one time keys and fallback key as being published
* Once marked as published, the one time keys will no longer be returned by
* olm_account_one_time_keys(), and the fallback key will no longer be returned
* by olm_account_unpublished_fallback_key().
*
* Returns the number of one-time keys that were marked as published. Note that
* this count does not include the fallback key. */
size_t olm_account_mark_keys_as_published (OlmAccount* account);
/** The largest number of one time keys this account can store. */
size_t olm_account_max_number_of_one_time_keys (const(OlmAccount)* account);
/** The number of random bytes needed to generate a given number of new one
* time keys. */
size_t olm_account_generate_one_time_keys_random_length (const(OlmAccount)* account, size_t number_of_keys);
/** Generates a number of new one time keys. If the total number of keys stored
* by this account exceeds max_number_of_one_time_keys() then the old keys are
* discarded. Returns olm_error() on error. If the number of random bytes is
* too small then olm_account_last_error() will be "NOT_ENOUGH_RANDOM". */
size_t olm_account_generate_one_time_keys (OlmAccount* account, size_t number_of_keys, void* random, size_t random_length);
/** The number of random bytes needed to generate a fallback key. */
size_t olm_account_generate_fallback_key_random_length (const(OlmAccount)* account);
/** Generates a new fallback key. Only one previous fallback key is
* stored. Returns olm_error() on error. If the number of random bytes is too
* small then olm_account_last_error() will be "NOT_ENOUGH_RANDOM". */
size_t olm_account_generate_fallback_key (OlmAccount* account, void* random, size_t random_length);
/** The number of bytes needed to hold the fallback key as returned by
* olm_account_fallback_key. */
size_t olm_account_fallback_key_length (const(OlmAccount)* account);
/** Deprecated: use olm_account_unpublished_fallback_key instead */
size_t olm_account_fallback_key (OlmAccount* account, void* fallback_key, size_t fallback_key_size);
/** The number of bytes needed to hold the unpublished fallback key as returned
* by olm_account_unpublished fallback_key. */
size_t olm_account_unpublished_fallback_key_length (const(OlmAccount)* account);
/** Returns the fallback key (if present, and if unpublished) into the
* fallback_key buffer */
size_t olm_account_unpublished_fallback_key (OlmAccount* account, void* fallback_key, size_t fallback_key_size);
/** Forget about the old fallback key. This should be called once you are
* reasonably certain that you will not receive any more messages that use
* the old fallback key (e.g. 5 minutes after the new fallback key has been
* published).
*/
void olm_account_forget_old_fallback_key (OlmAccount* account);
/** The number of random bytes needed to create an outbound session */
size_t olm_create_outbound_session_random_length (const(OlmSession)* session);
/** Creates a new out-bound session for sending messages to a given identity_key
* and one_time_key. Returns olm_error() on failure. If the keys couldn't be
* decoded as base64 then olm_session_last_error() will be "INVALID_BASE64"
* If there weren't enough random bytes then olm_session_last_error() will
* be "NOT_ENOUGH_RANDOM". */
size_t olm_create_outbound_session (OlmSession* session, const(OlmAccount)* account, const(void)* their_identity_key, size_t their_identity_key_length, const(void)* their_one_time_key, size_t their_one_time_key_length, void* random, size_t random_length);
/** Create a new in-bound session for sending/receiving messages from an
* incoming PRE_KEY message. Returns olm_error() on failure. If the base64
* couldn't be decoded then olm_session_last_error will be "INVALID_BASE64".
* If the message was for an unsupported protocol version then
* olm_session_last_error() will be "BAD_MESSAGE_VERSION". If the message
* couldn't be decoded then olm_session_last_error() will be
* "BAD_MESSAGE_FORMAT". If the message refers to an unknown one time
* key then olm_session_last_error() will be "BAD_MESSAGE_KEY_ID". */
size_t olm_create_inbound_session (OlmSession* session, OlmAccount* account, void* one_time_key_message, size_t message_length);
/** Same as olm_create_inbound_session, but ensures that the identity key
* in the pre-key message matches the expected identity key, supplied via the
* `their_identity_key` parameter. Fails early if there is no match. */
size_t olm_create_inbound_session_from (OlmSession* session, OlmAccount* account, const(void)* their_identity_key, size_t their_identity_key_length, void* one_time_key_message, size_t message_length);
/** The length of the buffer needed to return the id for this session. */
size_t olm_session_id_length (const(OlmSession)* session);
/** An identifier for this session. Will be the same for both ends of the
* conversation. If the id buffer is too small then olm_session_last_error()
* will be "OUTPUT_BUFFER_TOO_SMALL". */
size_t olm_session_id (OlmSession* session, void* id, size_t id_length);
int olm_session_has_received_message (const(OlmSession)* session);
/**
* Write a null-terminated string describing the internal state of an olm
* session to the buffer provided for debugging and logging purposes. If the
* buffer is not large enough to hold the entire string, it will be truncated
* and will end with "...". A buffer length of 600 will be enough to hold any
* output.
*/
void olm_session_describe (OlmSession* session, char* buf, size_t buflen);
/** Checks if the PRE_KEY message is for this in-bound session. This can happen
* if multiple messages are sent to this account before this account sends a
* message in reply. The one_time_key_message buffer is destroyed. Returns 1 if
* the session matches. Returns 0 if the session does not match. Returns
* olm_error() on failure. If the base64 couldn't be decoded then
* olm_session_last_error will be "INVALID_BASE64". If the message was for an
* unsupported protocol version then olm_session_last_error() will be
* "BAD_MESSAGE_VERSION". If the message couldn't be decoded then then
* olm_session_last_error() will be "BAD_MESSAGE_FORMAT". */
size_t olm_matches_inbound_session (OlmSession* session, void* one_time_key_message, size_t message_length);
/** Checks if the PRE_KEY message is for this in-bound session. This can happen
* if multiple messages are sent to this account before this account sends a
* message in reply. The one_time_key_message buffer is destroyed. Returns 1 if
* the session matches. Returns 0 if the session does not match. Returns
* olm_error() on failure. If the base64 couldn't be decoded then
* olm_session_last_error will be "INVALID_BASE64". If the message was for an
* unsupported protocol version then olm_session_last_error() will be
* "BAD_MESSAGE_VERSION". If the message couldn't be decoded then then
* olm_session_last_error() will be "BAD_MESSAGE_FORMAT". */
size_t olm_matches_inbound_session_from (OlmSession* session, const(void)* their_identity_key, size_t their_identity_key_length, void* one_time_key_message, size_t message_length);
/** Removes the one time keys that the session used from the account. Returns
* olm_error() on failure. If the account doesn't have any matching one time
* keys then olm_account_last_error() will be "BAD_MESSAGE_KEY_ID". */
size_t olm_remove_one_time_keys (OlmAccount* account, OlmSession* session);
/** The type of the next message that olm_encrypt() will return. Returns
* OLM_MESSAGE_TYPE_PRE_KEY if the message will be a PRE_KEY message.
* Returns OLM_MESSAGE_TYPE_MESSAGE if the message will be a normal message.
* Returns olm_error on failure. */
size_t olm_encrypt_message_type (const(OlmSession)* session);
/** The number of random bytes needed to encrypt the next message. */
size_t olm_encrypt_random_length (const(OlmSession)* session);
/** The size of the next message in bytes for the given number of plain-text
* bytes. */
size_t olm_encrypt_message_length (const(OlmSession)* session, size_t plaintext_length);
/** Encrypts a message using the session. Returns the length of the message in
* bytes on success. Writes the message as base64 into the message buffer.
* Returns olm_error() on failure. If the message buffer is too small then
* olm_session_last_error() will be "OUTPUT_BUFFER_TOO_SMALL". If there
* weren't enough random bytes then olm_session_last_error() will be
* "NOT_ENOUGH_RANDOM". */
size_t olm_encrypt (OlmSession* session, const(void)* plaintext, size_t plaintext_length, void* random, size_t random_length, void* message, size_t message_length);
/** The maximum number of bytes of plain-text a given message could decode to.
* The actual size could be different due to padding. The input message buffer
* is destroyed. Returns olm_error() on failure. If the message base64
* couldn't be decoded then olm_session_last_error() will be
* "INVALID_BASE64". If the message is for an unsupported version of the
* protocol then olm_session_last_error() will be "BAD_MESSAGE_VERSION".
* If the message couldn't be decoded then olm_session_last_error() will be
* "BAD_MESSAGE_FORMAT". */
size_t olm_decrypt_max_plaintext_length (OlmSession* session, size_t message_type, void* message, size_t message_length);
/** Decrypts a message using the session. The input message buffer is destroyed.
* Returns the length of the plain-text on success. Returns olm_error() on
* failure. If the plain-text buffer is smaller than
* olm_decrypt_max_plaintext_length() then olm_session_last_error()
* will be "OUTPUT_BUFFER_TOO_SMALL". If the base64 couldn't be decoded then
* olm_session_last_error() will be "INVALID_BASE64". If the message is for
* an unsupported version of the protocol then olm_session_last_error() will
* be "BAD_MESSAGE_VERSION". If the message couldn't be decoded then
* olm_session_last_error() will be BAD_MESSAGE_FORMAT".
* If the MAC on the message was invalid then olm_session_last_error() will
* be "BAD_MESSAGE_MAC". */
size_t olm_decrypt (OlmSession* session, size_t message_type, void* message, size_t message_length, void* plaintext, size_t max_plaintext_length);
/** The length of the buffer needed to hold the SHA-256 hash. */
size_t olm_sha256_length (const(OlmUtility)* utility);
/** Calculates the SHA-256 hash of the input and encodes it as base64. If the
* output buffer is smaller than olm_sha256_length() then
* olm_utility_last_error() will be "OUTPUT_BUFFER_TOO_SMALL". */
size_t olm_sha256 (OlmUtility* utility, const(void)* input, size_t input_length, void* output, size_t output_length);
/** Verify an ed25519 signature. If the key was too small then
* olm_utility_last_error() will be "INVALID_BASE64". If the signature was invalid
* then olm_utility_last_error() will be "BAD_MESSAGE_MAC". */
size_t olm_ed25519_verify (OlmUtility* utility, const(void)* key, size_t key_length, const(void)* message, size_t message_length, void* signature, size_t signature_length);
/* OLM_H_ */

136
source/bindings/olm/outbound.d Normal file
View file

@ -0,0 +1,136 @@
module libolm.outbound;
/* Copyright 2016 OpenMarket Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import libolm.error;
extern (C):
struct OlmOutboundGroupSession;
/** get the size of an outbound group session, in bytes. */
size_t olm_outbound_group_session_size ();
/**
* Initialise an outbound group session object using the supplied memory
* The supplied memory should be at least olm_outbound_group_session_size()
* bytes.
*/
OlmOutboundGroupSession* olm_outbound_group_session (void* memory);
/**
* A null terminated string describing the most recent error to happen to a
* group session */
const(char)* olm_outbound_group_session_last_error (const(OlmOutboundGroupSession)* session);
/**
* An error code describing the most recent error to happen to a group
* session */
OlmErrorCode olm_outbound_group_session_last_error_code (const(OlmOutboundGroupSession)* session);
/** Clears the memory used to back this group session */
size_t olm_clear_outbound_group_session (OlmOutboundGroupSession* session);
/** Returns the number of bytes needed to store an outbound group session */
size_t olm_pickle_outbound_group_session_length (const(OlmOutboundGroupSession)* session);
/**
* Stores a group session as a base64 string. Encrypts the session using the
* supplied key. Returns the length of the session on success.
*
* Returns olm_error() on failure. If the pickle output buffer
* is smaller than olm_pickle_outbound_group_session_length() then
* olm_outbound_group_session_last_error() will be "OUTPUT_BUFFER_TOO_SMALL"
*/
size_t olm_pickle_outbound_group_session (OlmOutboundGroupSession* session, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/**
* Loads a group session from a pickled base64 string. Decrypts the session
* using the supplied key.
*
* Returns olm_error() on failure. If the key doesn't match the one used to
* encrypt the account then olm_outbound_group_session_last_error() will be
* "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* olm_outbound_group_session_last_error() will be "INVALID_BASE64". The input
* pickled buffer is destroyed
*/
size_t olm_unpickle_outbound_group_session (OlmOutboundGroupSession* session, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/** The number of random bytes needed to create an outbound group session */
size_t olm_init_outbound_group_session_random_length (const(OlmOutboundGroupSession)* session);
/**
* Start a new outbound group session. Returns olm_error() on failure. On
* failure last_error will be set with an error code. The last_error will be
* NOT_ENOUGH_RANDOM if the number of random bytes was too small.
*/
size_t olm_init_outbound_group_session (OlmOutboundGroupSession* session, ubyte* random, size_t random_length);
/**
* The number of bytes that will be created by encrypting a message
*/
size_t olm_group_encrypt_message_length (OlmOutboundGroupSession* session, size_t plaintext_length);
/**
* Encrypt some plain-text. Returns the length of the encrypted message or
* olm_error() on failure. On failure last_error will be set with an
* error code. The last_error will be OUTPUT_BUFFER_TOO_SMALL if the output
* buffer is too small.
*/
size_t olm_group_encrypt (OlmOutboundGroupSession* session, const(ubyte)* plaintext, size_t plaintext_length, ubyte* message, size_t message_length);
/**
* Get the number of bytes returned by olm_outbound_group_session_id()
*/
size_t olm_outbound_group_session_id_length (const(OlmOutboundGroupSession)* session);
/**
* Get a base64-encoded identifier for this session.
*
* Returns the length of the session id on success or olm_error() on
* failure. On failure last_error will be set with an error code. The
* last_error will be OUTPUT_BUFFER_TOO_SMALL if the id buffer was too
* small.
*/
size_t olm_outbound_group_session_id (OlmOutboundGroupSession* session, ubyte* id, size_t id_length);
/**
* Get the current message index for this session.
*
* Each message is sent with an increasing index; this returns the index for
* the next message.
*/
uint olm_outbound_group_session_message_index (OlmOutboundGroupSession* session);
/**
* Get the number of bytes returned by olm_outbound_group_session_key()
*/
size_t olm_outbound_group_session_key_length (const(OlmOutboundGroupSession)* session);
/**
* Get the base64-encoded current ratchet key for this session.
*
* Each message is sent with a different ratchet key. This function returns the
* ratchet key that will be used for the next message.
*
* Returns the length of the ratchet key on success or olm_error() on
* failure. On failure last_error will be set with an error code. The
* last_error will be OUTPUT_BUFFER_TOO_SMALL if the buffer was too small.
*/
size_t olm_outbound_group_session_key (OlmOutboundGroupSession* session, ubyte* key, size_t key_length);
// extern "C"
/* OLM_OUTBOUND_GROUP_SESSION_H_ */

37
source/bindings/olm/package.d Normal file
View file

@ -0,0 +1,37 @@
module bindings.olm;
// import api: Encrypted;
// void decrypt(Encrypted* evt) @nogc {
// import main: session;
// import libolm.inbound;
// import core.stdc.stdlib;
// import core.stdc.string: strcpy;
// // import std.stdio;
// char[] buf = cast(char[])malloc(evt.ciphertext.length)[0..evt.ciphertext.length];
// strcpy(cast(char*)buf, cast(char*)evt.ciphertext);
// size_t mlen = olm_group_decrypt_max_plaintext_length (
// session,
// cast(ubyte*)buf,
// buf.length
// );
// char[] decbuf = cast(char[])malloc(mlen)[0..mlen];
// size_t dcr = olm_group_decrypt (
// session,
// cast(ubyte*)buf,
// buf.length,
// cast(ubyte*)decbuf,
// mlen,
// null
// );
// import core.stdc.stdio;
// printf("%d\n", dcr);
// // // string msg = cast(string)decbuf[0..dcr];
// // writeln(dcr);
// // writeln(msg);
// }

203
source/bindings/olm/pk.d Normal file
View file

@ -0,0 +1,203 @@
/* Copyright 2018, 2019 New Vector Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import libolm.error;
extern (C):
struct OlmPkEncryption;
/* The size of an encryption object in bytes */
size_t olm_pk_encryption_size ();
/** Initialise an encryption object using the supplied memory
* The supplied memory must be at least olm_pk_encryption_size() bytes */
OlmPkEncryption* olm_pk_encryption (void* memory);
/** A null terminated string describing the most recent error to happen to an
* encryption object */
const(char)* olm_pk_encryption_last_error (const(OlmPkEncryption)* encryption);
/** An error code describing the most recent error to happen to an encryption
* object */
OlmErrorCode olm_pk_encryption_last_error_code (const(OlmPkEncryption)* encryption);
/** Clears the memory used to back this encryption object */
size_t olm_clear_pk_encryption (OlmPkEncryption* encryption);
/** Set the recipient's public key for encrypting to */
size_t olm_pk_encryption_set_recipient_key (OlmPkEncryption* encryption, const(void)* public_key, size_t public_key_length);
/** Get the length of the ciphertext that will correspond to a plaintext of the
* given length. */
size_t olm_pk_ciphertext_length (const(OlmPkEncryption)* encryption, size_t plaintext_length);
/** Get the length of the message authentication code. */
size_t olm_pk_mac_length (const(OlmPkEncryption)* encryption);
/** Get the length of a public or ephemeral key */
size_t olm_pk_key_length ();
/** The number of random bytes needed to encrypt a message. */
size_t olm_pk_encrypt_random_length (const(OlmPkEncryption)* encryption);
/** Encrypt a plaintext for the recipient set using
* olm_pk_encryption_set_recipient_key. Writes to the ciphertext, mac, and
* ephemeral_key buffers, whose values should be sent to the recipient. mac is
* a Message Authentication Code to ensure that the data is received and
* decrypted properly. ephemeral_key is the public part of the ephemeral key
* used (together with the recipient's key) to generate a symmetric encryption
* key. Returns olm_error() on failure. If the ciphertext, mac, or
* ephemeral_key buffers were too small then olm_pk_encryption_last_error()
* will be "OUTPUT_BUFFER_TOO_SMALL". If there weren't enough random bytes then
* olm_pk_encryption_last_error() will be "OLM_INPUT_BUFFER_TOO_SMALL". */
size_t olm_pk_encrypt (OlmPkEncryption* encryption, const(void)* plaintext, size_t plaintext_length, void* ciphertext, size_t ciphertext_length, void* mac, size_t mac_length, void* ephemeral_key, size_t ephemeral_key_size, const(void)* random, size_t random_length);
struct OlmPkDecryption;
/* The size of a decryption object in bytes */
size_t olm_pk_decryption_size ();
/** Initialise a decryption object using the supplied memory
* The supplied memory must be at least olm_pk_decryption_size() bytes */
OlmPkDecryption* olm_pk_decryption (void* memory);
/** A null terminated string describing the most recent error to happen to a
* decription object */
const(char)* olm_pk_decryption_last_error (const(OlmPkDecryption)* decryption);
/** An error code describing the most recent error to happen to a decription
* object */
OlmErrorCode olm_pk_decryption_last_error_code (const(OlmPkDecryption)* decryption);
/** Clears the memory used to back this decryption object */
size_t olm_clear_pk_decryption (OlmPkDecryption* decryption);
/** Get the number of bytes required to store an olm private key
*/
size_t olm_pk_private_key_length ();
/** DEPRECATED: Use olm_pk_private_key_length()
*/
size_t olm_pk_generate_key_random_length ();
/** Initialise the key from the private part of a key as returned by
* olm_pk_get_private_key(). The associated public key will be written to the
* pubkey buffer. Returns olm_error() on failure. If the pubkey buffer is too
* small then olm_pk_decryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL".
* If the private key was not long enough then olm_pk_decryption_last_error()
* will be "OLM_INPUT_BUFFER_TOO_SMALL".
*
* Note that the pubkey is a base64 encoded string, but the private key is
* an unencoded byte array
*/
size_t olm_pk_key_from_private (OlmPkDecryption* decryption, void* pubkey, size_t pubkey_length, const(void)* privkey, size_t privkey_length);
/** DEPRECATED: Use olm_pk_key_from_private
*/
size_t olm_pk_generate_key (OlmPkDecryption* decryption, void* pubkey, size_t pubkey_length, const(void)* privkey, size_t privkey_length);
/** Returns the number of bytes needed to store a decryption object. */
size_t olm_pickle_pk_decryption_length (const(OlmPkDecryption)* decryption);
/** Stores decryption object as a base64 string. Encrypts the object using the
* supplied key. Returns the length of the pickled object on success.
* Returns olm_error() on failure. If the pickle output buffer
* is smaller than olm_pickle_pk_decryption_length() then
* olm_pk_decryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL" */
size_t olm_pickle_pk_decryption (OlmPkDecryption* decryption, const(void)* key, size_t key_length, void* pickled, size_t pickled_length);
/** Loads a decryption object from a pickled base64 string. The associated
* public key will be written to the pubkey buffer. Decrypts the object using
* the supplied key. Returns olm_error() on failure. If the key doesn't
* match the one used to encrypt the account then olm_pk_decryption_last_error()
* will be "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* olm_pk_decryption_last_error() will be "INVALID_BASE64". The input pickled
* buffer is destroyed */
size_t olm_unpickle_pk_decryption (OlmPkDecryption* decryption, const(void)* key, size_t key_length, void* pickled, size_t pickled_length, void* pubkey, size_t pubkey_length);
/** Get the length of the plaintext that will correspond to a ciphertext of the
* given length. */
size_t olm_pk_max_plaintext_length (const(OlmPkDecryption)* decryption, size_t ciphertext_length);
/** Decrypt a ciphertext. The input ciphertext buffer is destroyed. See the
* olm_pk_encrypt function for descriptions of the ephemeral_key and mac
* arguments. Returns the length of the plaintext on success. Returns
* olm_error() on failure. If the plaintext buffer is too small then
* olm_pk_encryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL". */
size_t olm_pk_decrypt (OlmPkDecryption* decryption, const(void)* ephemeral_key, size_t ephemeral_key_length, const(void)* mac, size_t mac_length, void* ciphertext, size_t ciphertext_length, void* plaintext, size_t max_plaintext_length);
/**
* Get the private key for an OlmDecryption object as an unencoded byte array
* private_key must be a pointer to a buffer of at least
* olm_pk_private_key_length() bytes and this length must be passed in
* private_key_length. If the given buffer is too small, returns olm_error()
* and olm_pk_encryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL".
* Returns the number of bytes written.
*/
size_t olm_pk_get_private_key (OlmPkDecryption* decryption, void* private_key, size_t private_key_length);
struct OlmPkSigning;
/* The size of a signing object in bytes */
size_t olm_pk_signing_size ();
/** Initialise a signing object using the supplied memory
* The supplied memory must be at least olm_pk_signing_size() bytes */
OlmPkSigning* olm_pk_signing (void* memory);
/** A null terminated string describing the most recent error to happen to a
* signing object */
const(char)* olm_pk_signing_last_error (const(OlmPkSigning)* sign);
/** A null terminated string describing the most recent error to happen to a
* signing object */
OlmErrorCode olm_pk_signing_last_error_code (const(OlmPkSigning)* sign);
/** Clears the memory used to back this signing object */
size_t olm_clear_pk_signing (OlmPkSigning* sign);
/**
* Initialise the signing object with a public/private keypair from a seed. The
* associated public key will be written to the pubkey buffer. Returns
* olm_error() on failure. If the public key buffer is too small then
* olm_pk_signing_last_error() will be "OUTPUT_BUFFER_TOO_SMALL". If the seed
* buffer is too small then olm_pk_signing_last_error() will be
* "INPUT_BUFFER_TOO_SMALL".
*/
size_t olm_pk_signing_key_from_seed (OlmPkSigning* sign, void* pubkey, size_t pubkey_length, const(void)* seed, size_t seed_length);
/**
* The size required for the seed for initialising a signing object.
*/
size_t olm_pk_signing_seed_length ();
/**
* The size of the public key of a signing object.
*/
size_t olm_pk_signing_public_key_length ();
/**
* The size of a signature created by a signing object.
*/
size_t olm_pk_signature_length ();
/**
* Sign a message. The signature will be written to the signature
* buffer. Returns olm_error() on failure. If the signature buffer is too
* small, olm_pk_signing_last_error() will be "OUTPUT_BUFFER_TOO_SMALL".
*/
size_t olm_pk_sign (OlmPkSigning* sign, const(ubyte)* message, size_t message_length, ubyte* signature, size_t signature_length);
/* OLM_PK_H_ */

142
source/bindings/olm/sas.d Normal file
View file

@ -0,0 +1,142 @@
/* Copyright 2018-2019 New Vector Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import libolm.error;
extern (C):
/** @defgroup SAS Short Authentication String verification
* These functions are used for verifying keys using the Short Authentication
* String (SAS) method.
* @{
*/
struct OlmSAS;
/** A null terminated string describing the most recent error to happen to an
* SAS object. */
const(char)* olm_sas_last_error (const(OlmSAS)* sas);
/** An error code describing the most recent error to happen to an SAS
* object. */
OlmErrorCode olm_sas_last_error_code (const(OlmSAS)* sas);
/** The size of an SAS object in bytes. */
size_t olm_sas_size ();
/** Initialize an SAS object using the supplied memory.
* The supplied memory must be at least `olm_sas_size()` bytes. */
OlmSAS* olm_sas (void* memory);
/** Clears the memory used to back an SAS object. */
size_t olm_clear_sas (OlmSAS* sas);
/** The number of random bytes needed to create an SAS object. */
size_t olm_create_sas_random_length (const(OlmSAS)* sas);
/** Creates a new SAS object.
*
* @param[in] sas the SAS object to create, initialized by `olm_sas()`.
* @param[in] random array of random bytes. The contents of the buffer may be
* overwritten.
* @param[in] random_length the number of random bytes provided. Must be at
* least `olm_create_sas_random_length()`.
*
* @return `olm_error()` on failure. If there weren't enough random bytes then
* `olm_sas_last_error()` will be `NOT_ENOUGH_RANDOM`.
*/
size_t olm_create_sas (OlmSAS* sas, void* random, size_t random_length);
/** The size of a public key in bytes. */
size_t olm_sas_pubkey_length (const(OlmSAS)* sas);
/** Get the public key for the SAS object.
*
* @param[in] sas the SAS object.
* @param[out] pubkey buffer to store the public key.
* @param[in] pubkey_length the size of the `pubkey` buffer. Must be at least
* `olm_sas_pubkey_length()`.
*
* @return `olm_error()` on failure. If the `pubkey` buffer is too small, then
* `olm_sas_last_error()` will be `OUTPUT_BUFFER_TOO_SMALL`.
*/
size_t olm_sas_get_pubkey (OlmSAS* sas, void* pubkey, size_t pubkey_length);
/** Sets the public key of other user.
*
* @param[in] sas the SAS object.
* @param[in] their_key the other user's public key. The contents of the
* buffer will be overwritten.
* @param[in] their_key_length the size of the `their_key` buffer.
*
* @return `olm_error()` on failure. If the `their_key` buffer is too small,
* then `olm_sas_last_error()` will be `INPUT_BUFFER_TOO_SMALL`.
*/
size_t olm_sas_set_their_key (OlmSAS* sas, void* their_key, size_t their_key_length);
/** Checks if their key was set.
*
* @param[in] sas the SAS object.
*
*/
int olm_sas_is_their_key_set (const(OlmSAS)* sas);
/** Generate bytes to use for the short authentication string.
*
* @param[in] sas the SAS object.
* @param[in] info extra information to mix in when generating the bytes, as
* per the Matrix spec.
* @param[in] info_length the length of the `info` parameter.
* @param[out] output the output buffer.
* @param[in] output_length the size of the output buffer. For hex-based SAS
* as in the Matrix spec, this will be 5.
*
* @return `olm_error()` on failure. If their key wasn't set then
* `olm_sas_last_error()` will be `SAS_THEIR_KEY_NOT_SET`.
*/
size_t olm_sas_generate_bytes (OlmSAS* sas, const(void)* info, size_t info_length, void* output, size_t output_length);
/** The size of the message authentication code generated by
* olm_sas_calculate_mac()`. */
size_t olm_sas_mac_length (const(OlmSAS)* sas);
/** Generate a message authentication code (MAC) based on the shared secret.
*
* @param[in] sas the SAS object.
* @param[in] input the message to produce the authentication code for.
* @param[in] input_length the length of the message.
* @param[in] info extra information to mix in when generating the MAC, as per
* the Matrix spec.
* @param[in] info_length the length of the `info` parameter.
* @param[out] mac the buffer in which to store the MAC.
* @param[in] mac_length the size of the `mac` buffer. Must be at least
* `olm_sas_mac_length()`
*
* @return `olm_error()` on failure. If the `mac` buffer is too small, then
* `olm_sas_last_error()` will be `OUTPUT_BUFFER_TOO_SMALL`.
*/
size_t olm_sas_calculate_mac (OlmSAS* sas, const(void)* input, size_t input_length, const(void)* info, size_t info_length, void* mac, size_t mac_length);
// A version of the calculate mac function that produces base64 strings that are
// compatible with other base64 implementations.
size_t olm_sas_calculate_mac_fixed_base64 (OlmSAS* sas, const(void)* input, size_t input_length, const(void)* info, size_t info_length, void* mac, size_t mac_length);
// for compatibility with an old version of Riot
size_t olm_sas_calculate_mac_long_kdf (OlmSAS* sas, const(void)* input, size_t input_length, const(void)* info, size_t info_length, void* mac, size_t mac_length);
/** @} */ // end of SAS group
// extern "C"
/* OLM_SAS_H_ */