timoreo/olm
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Rename axolotlpp as olm to avoid confusion with Axolotl-the-spec and Axolotl-the-OWS-libraries at moxie's request

Browse source
This commit is contained in:
Matthew Hodgson 2015-06-27 01:15:23 +02:00
parent fe95847245
commit 09d4125ff1
39 changed files with 1268 additions and 1261 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
README.rst
View file

@ -1,5 +1,5 @@
Axolotlpp Olm
========= ===
An implementation of the axolotl ratchet as described by An implementation of the axolotl ratchet as described by
https://github.com/trevp/axolotl/wiki, written in C++11 and exposed as a C API https://github.com/trevp/axolotl/wiki, written in C++11 and exposed as a C API
@ -7,7 +7,7 @@ https://github.com/trevp/axolotl/wiki, written in C++11 and exposed as a C API
Building Building
-------- --------
To build axolotlpp as a shared library run: To build olm as a shared library run:
.. code:: bash .. code:: bash
@ -29,19 +29,19 @@ To build the javascript bindings run:
Design Design
------ ------
Axolotlpp is designed to be easy port to different platforms and to be easy Olm is designed to be easy port to different platforms and to be easy
to write bindings for. to write bindings for.
Error Handling Error Handling
~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~
All C functions in the API for axolotlpp return ``axolotl_error()`` on error. All C functions in the API for olm return ``olm_error()`` on error.
This makes it easy to check for error conditions within the language bindings. This makes it easy to check for error conditions within the language bindings.
Random Numbers Random Numbers
~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~
Axolotlpp doesn't generate random numbers itself. Instead the caller must Olm doesn't generate random numbers itself. Instead the caller must
provide the random data. This makes it easier to port the library to different provide the random data. This makes it easier to port the library to different
platforms since the caller can use whatever cryptographic random number platforms since the caller can use whatever cryptographic random number
generator their platform provides. generator their platform provides.
@ -49,7 +49,7 @@ generator their platform provides.
Memory Memory
~~~~~~ ~~~~~~
Axolotlpp avoids calling malloc or allocating memory on the heap itself. Olm avoids calling malloc or allocating memory on the heap itself.
Instead the library calculates how much memory will be needed to hold the Instead the library calculates how much memory will be needed to hold the
output and the caller supplies a buffer of the appropriate size. output and the caller supplies a buffer of the appropriate size.
@ -62,6 +62,13 @@ strings will find it easier to handle the output.
Dependencies Dependencies
~~~~~~~~~~~~ ~~~~~~~~~~~~
Axolotlpp uses pure C implementations of the cryptographic primitives used by Olm uses pure C implementations of the cryptographic primitives used by
the ratchet. While this decreases the performance it makes it much easier the ratchet. While this decreases the performance it makes it much easier
to compile the library for different architectures. to compile the library for different architectures.
What's an olm?
~~~~~~~~~~~~~~
It's a really cool species of European troglodytic salamander.
Matthew once tried to climb into a pool full of them in Postojnska Jama.
http://www.postojnska-jama.eu/en/about-the-cave/meet-the-dragon-s-offspring/

2
build_shared_library.py
View file

@ -25,7 +25,7 @@ source_files = glob.glob("src/*.cpp")
compile_args = "g++ -O0 -g -Iinclude -Ilib --std=c++11 --shared -fPIC".split() compile_args = "g++ -O0 -g -Iinclude -Ilib --std=c++11 --shared -fPIC".split()
compile_args += source_files compile_args += source_files
library = "build/libaxolotl.so" library = "build/libolm.so"
def run(args): def run(args):
print " ".join(args) print " ".join(args)

6
docs/Axolotl.svg
View file

@ -229,7 +229,7 @@
y="-64" y="-64"
x="32" x="32"
id="tspan4814" id="tspan4814"
sodipodi:role="line">&quot;AXOLOTL_ROOT&quot;</tspan></text> sodipodi:role="line">&quot;OLM_ROOT&quot;</tspan></text>
</g> </g>
<g <g
transform="translate(64,0)" transform="translate(64,0)"
@ -622,7 +622,7 @@
sodipodi:role="line" sodipodi:role="line"
id="tspan4695" id="tspan4695"
x="32" x="32"
y="-64">&quot;AXOLOTL_KEYS&quot;</tspan></text> y="-64">&quot;OLM_KEYS&quot;</tspan></text>
</g> </g>
<text <text
xml:space="preserve" xml:space="preserve"
@ -848,7 +848,7 @@
sodipodi:role="line" sodipodi:role="line"
id="tspan4904" id="tspan4904"
x="32" x="32"
y="-64">&quot;AXOLOTL_RATCHET&quot;</tspan></text> y="-64">&quot;OLM_RATCHET&quot;</tspan></text>
</g> </g>
<g <g
id="g4906" id="g4906"

Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 34 KiB

After

Width:  |  Height:  |  Size: 34 KiB

295
include/axolotl/axolotl.hh
View file

@ -1,295 +0,0 @@
/* Copyright 2015 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.
*/
#ifndef AXOLOTL_HH_
#define AXOLOTL_HH_
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
static const size_t AXOLOTL_MESSAGE_TYPE_PRE_KEY = 0;
static const size_t AXOLOTL_MESSAGE_TYPE_MESSAGE = 1;
struct AxolotlAccount;
struct AxolotlSession;
/** The size of an account object in bytes */
size_t axolotl_account_size();
/** The size of a session object in bytes */
size_t axolotl_session_size();
/** Initialise an account object using the supplied memory
* The supplied memory must be at least axolotl_account_size() bytes */
AxolotlAccount * axolotl_account(
void * memory
);
/** Initialise a session object using the supplied memory
* The supplied memory must be at least axolotl_session_size() bytes */
AxolotlSession * axolotl_session(
void * memory
);
/** The value that axolotl will return from a function if there was an error */
size_t axolotl_error();
/** A null terminated string describing the most recent error to happen to an
* account */
const char * axolotl_account_last_error(
AxolotlSession * account
);
/** A null terminated string describing the most recent error to happen to a
* session */
const char * axolotl_session_last_error(
AxolotlSession * session
);
/** Returns the number of bytes needed to store an account */
size_t axolotl_pickle_account_length(
AxolotlAccount * account
);
/** Returns the number of bytes needed to store a session */
size_t axolotl_pickle_session_length(
AxolotlSession * 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 axolotl_error() on failure. If the pickle output buffer
* is smaller than axolotl_pickle_account_length() then
* axolotl_account_last_error() will be "OUTPUT_BUFFER_TOO_SMALL" */
size_t axolotl_pickle_account(
AxolotlAccount * account,
void const * 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 axolotl_error() on failure. If the pickle output buffer
* is smaller than axolotl_pickle_session_length() then
* axolotl_session_last_error() will be "OUTPUT_BUFFER_TOO_SMALL" */
size_t axolotl_pickle_session(
AxolotlSession * session,
void const * 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 axolotl_error() on failure. If the key doesn't
* match the one used to encrypt the account then axolotl_account_last_error()
* will be "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* axolotl_account_last_error() will be "INVALID_BASE64". The input pickled
* buffer is destroyed */
size_t axolotl_unpickle_account(
AxolotlAccount * account,
void const * 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 axolotl_error() on failure. If the key doesn't
* match the one used to encrypt the account then axolotl_session_last_error()
* will be "BAD_ACCOUNT_KEY". If the base64 couldn't be decoded then
* axolotl_session_last_error() will be "INVALID_BASE64". The input pickled
* buffer is destroyed */
size_t axolotl_unpickle_session(
AxolotlSession * session,
void const * key, size_t key_length,
void * pickled, size_t pickled_length
);
/** The number of random bytes needed to create an account.*/
size_t axolotl_create_account_random_length(
AxolotlAccount * account
);
/** Creates a new account. Returns axolotl_error() on failure. If weren't
* enough random bytes then axolotl_account_last_error() will be
* "NOT_ENOUGH_RANDOM" */
size_t axolotl_create_account(
AxolotlAccount * account,
void const * random, size_t random_length
);
/** The size of the output buffer needed to hold the identity keys */
size_t axolotl_account_identity_keys_length(
AxolotlAccount * account
);
/** Writes the public parts of the identity keys for the account into the
* identity_keys output buffer. The output is formatted as though it was
* created with sprintf(output, "[[%10d,\"%43s\"]\n]", key_id, key_base64).
* The output can either be parsed as fixed width using the above format or by
* a JSON parser. Returns axolotl_error() on failure. If the identity_keys
* buffer was too small then axolotl_account_last_error() will be
* "OUTPUT_BUFFER_TOO_SMALL". */
size_t axolotl_account_identity_keys(
AxolotlAccount * account,
void * identity_keys, size_t identity_key_length
);
/** The size of the output buffer needed to hold the one time keys */
size_t axolotl_account_one_time_keys_length(
AxolotlAccount * account
);
/** Writes the public parts of the one time keys for the account into the
* one_time_keys output buffer. The first key will be formatted as though it was
* created with sprintf(output, "[[%10d,\"%43s\"]\n", key_id, key_base64).
* subsequent keys are formatted with ",[%10d,\"%43s\"]\n". The final byte of
* output will be "]". The output can either be parsed as fixed width using
* the above format or by a JSON parser. Returns axolotl_error() on failure.
* If the one_time_keys buffer was too small then axolotl_account_last_error()
* will be "OUTPUT_BUFFER_TOO_SMALL". */
size_t axolotl_account_one_time_keys(
AxolotlAccount * account,
void * one_time_keys, size_t one_time_keys_length
);
/* TODO: Add methods for marking keys as used, generating new keys, and
* tracking which keys have been uploaded to the central servers */
/** The number of random bytes needed to create an outbound session */
size_t axolotl_create_outbound_session_random_length(
AxolotlSession * session
);
/** Creates a new out-bound session for sending messages to a given identity_key
* and one_time_key. Returns axolotl_error() on failure. If the keys couldn't be
* decoded as base64 then axolotl_session_last_error() will be "INVALID_BASE64"
* If there weren't enough random bytes then axolotl_session_last_error() will
* be "NOT_ENOUGH_RANDOM". */
size_t axolotl_create_outbound_session(
AxolotlSession * session,
AxolotlAccount * account,
void const * their_identity_key, size_t their_identity_key_length,
unsigned their_one_time_key_id,
void const * their_one_time_key, size_t their_one_time_key_length,
void const * random, size_t random_length
);
/** Create a new in-bound session for sending/receiving messages from an
* incoming PRE_KEY message. Returns axolotl_error() on failure. If the base64
* couldn't be decoded then axolotl_session_last_error will be "INVALID_BASE64".
* If the message was for an unsupported protocol version then
* axolotl_session_last_error() will be "BAD_MESSAGE_VERSION". If the message
* couldn't be decoded then then axolotl_session_last_error() will be
* "BAD_MESSAGE_FORMAT". If the message refers to an unknown one time
* key then axolotl_session_last_error() will be "BAD_MESSAGE_KEY_ID". */
size_t axolotl_create_inbound_session(
AxolotlSession * session,
AxolotlAccount * account,
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. Returns axolotl_error() on failure. If the base64
* couldn't be decoded then axolotl_session_last_error will be "INVALID_BASE64".
* If the message was for an unsupported protocol version then
* axolotl_session_last_error() will be "BAD_MESSAGE_VERSION". If the message
* couldn't be decoded then then axolotl_session_last_error() will be
* "BAD_MESSAGE_FORMAT". */
size_t axolotl_matches_inbound_session(
AxolotlSession * session,
void * one_time_key_message, size_t message_length
);
/** Removes the one time keys that the session used from the account. Returns
* axolotl_error() on failure. If the account doesn't have any matching one time
* keys then axolotl_account_last_error() will be "BAD_MESSAGE_KEY_ID". */
size_t axolotl_remove_one_time_keys(
AxolotlAccount * account,
AxolotlSession * session
);
/** The type of the next message that axolotl_encrypt() will return. Returns
* AXOLOTL_MESSAGE_TYPE_PRE_KEY if the message will be a PRE_KEY message.
* Returns AXOLOTL_MESSAGE_TYPE_MESSAGE if the message will be a normal message.
* Returns axolotl_error on failure. */
size_t axolotl_encrypt_message_type(
AxolotlSession * session
);
/** The number of random bytes needed to encrypt the next message. */
size_t axolotl_encrypt_random_length(
AxolotlSession * session
);
/** The size of the next message in bytes for the given number of plain-text
* bytes. */
size_t axolotl_encrypt_message_length(
AxolotlSession * 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 axolotl_error() on failure. If the message buffer is too small then
* axolotl_session_last_error() will be "OUTPUT_BUFFER_TOO_SMALL". If there
* weren't enough random bytes then axolotl_session_last_error() will be
* "NOT_ENOUGH_RANDOM". */
size_t axolotl_encrypt(
AxolotlSession * session,
void const * plaintext, size_t plaintext_length,
void const * 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 axolotl_error() on failure. If the message base64
* couldn't be decoded then axolotl_session_last_error() will be
* "INVALID_BASE64". If the message is for an unsupported version of the
* protocol then axolotl_session_last_error() will be "BAD_MESSAGE_VERSION".
* If the message couldn't be decoded then axolotl_session_last_error() will be
* "BAD_MESSAGE_FORMAT". */
size_t axolotl_decrypt_max_plaintext_length(
AxolotlSession * 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 axolotl_error() on
* failure. If the plain-text buffer is smaller than
* axolotl_decrypt_max_plaintext_length() then axolotl_session_last_error()
* will be "OUTPUT_BUFFER_TOO_SMALL". If the base64 couldn't be decoded then
* axolotl_session_last_error() will be "INVALID_BASE64". If the message is for
* an unsupported version of the protocol then axolotl_session_last_error() will
* be "BAD_MESSAGE_VERSION". If the message couldn't be decoded then
* axolotl_session_last_error() will be BAD_MESSAGE_FORMAT".
* If the MAC on the message was invalid then axolotl_session_last_error() will
* be "BAD_MESSAGE_MAC". */
size_t axolotl_decrypt(
AxolotlSession * session,
size_t message_type,
void * message, size_t message_length,
void * plaintext, size_t max_plaintext_length
);
#ifdef __cplusplus
}
#endif
#endif /* AXOLOTL_HH_ */

16
include/axolotl/account.hh → include/olm/account.hh
View file

@ -12,16 +12,16 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef AXOLOTL_ACCOUNT_HH_ #ifndef OLM_ACCOUNT_HH_
#define AXOLOTL_ACCOUNT_HH_ #define OLM_ACCOUNT_HH_
#include "axolotl/list.hh" #include "olm/list.hh"
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include "axolotl/error.hh" #include "olm/error.hh"
#include <cstdint> #include <cstdint>
namespace axolotl { namespace olm {
struct LocalKey { struct LocalKey {
@ -79,6 +79,6 @@ std::uint8_t const * unpickle(
); );
} // namespace axolotl } // namespace olm
#endif /* AXOLOTL_ACCOUNT_HH_ */ #endif /* OLM_ACCOUNT_HH_ */

4
include/axolotl/base64.hh → include/olm/base64.hh
View file

@ -18,7 +18,7 @@
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
namespace axolotl { namespace olm {
std::size_t encode_base64_length( std::size_t encode_base64_length(
@ -43,7 +43,7 @@ void decode_base64(
); );
} // namespace axolotl } // namespace olm
#endif /* AXOLOLT_BASE64_HH_ */ #endif /* AXOLOLT_BASE64_HH_ */

8
include/axolotl/cipher.hh → include/olm/cipher.hh
View file

@ -13,13 +13,13 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef AXOLOTL_CIPHER_HH_ #ifndef OLM_CIPHER_HH_
#define AXOLOTL_CIPHER_HH_ #define OLM_CIPHER_HH_
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
namespace axolotl { namespace olm {
class Cipher { class Cipher {
public: public:
@ -125,4 +125,4 @@ private:
} // namespace } // namespace
#endif /* AXOLOTL_CIPHER_HH_ */ #endif /* OLM_CIPHER_HH_ */

10
include/axolotl/crypto.hh → include/olm/crypto.hh
View file

@ -12,13 +12,13 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef AXOLOTL_CRYPTO_HH_ #ifndef OLM_CRYPTO_HH_
#define AXOLOTL_CRYPTO_HH_ #define OLM_CRYPTO_HH_
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
namespace axolotl { namespace olm {
struct Curve25519PublicKey { struct Curve25519PublicKey {
@ -143,6 +143,6 @@ void hkdf_sha256(
std::uint8_t * output, std::size_t output_length std::uint8_t * output, std::size_t output_length
); );
} // namespace axolotl } // namespace olm
#endif /* AXOLOTL_CRYPTO_HH_ */ #endif /* OLM_CRYPTO_HH_ */

4
include/axolotl/error.hh → include/olm/error.hh
View file

@ -15,7 +15,7 @@
#ifndef ERROR_HH_ #ifndef ERROR_HH_
#define ERROR_HH_ #define ERROR_HH_
namespace axolotl { namespace olm {
enum struct ErrorCode { enum struct ErrorCode {
SUCCESS = 0, /*!< There wasn't an error */ SUCCESS = 0, /*!< There wasn't an error */
@ -29,6 +29,6 @@ enum struct ErrorCode {
BAD_ACCOUNT_KEY = 8, /*!< The supplied account key is invalid */ BAD_ACCOUNT_KEY = 8, /*!< The supplied account key is invalid */
}; };
} // namespace axolotl } // namespace olm
#endif /* ERROR_HH_ */ #endif /* ERROR_HH_ */

10
include/axolotl/list.hh → include/olm/list.hh
View file

@ -12,12 +12,12 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef AXOLOTL_LIST_HH_ #ifndef OLM_LIST_HH_
#define AXOLOTL_LIST_HH_ #define OLM_LIST_HH_
#include <cstddef> #include <cstddef>
namespace axolotl { namespace olm {
template<typename T, std::size_t max_size> template<typename T, std::size_t max_size>
class List { class List {
@ -114,6 +114,6 @@ private:
T _data[max_size]; T _data[max_size];
}; };
} // namespace axolotl } // namespace olm
#endif /* AXOLOTL_LIST_HH_ */ #endif /* OLM_LIST_HH_ */

4
include/axolotl/memory.hh → include/olm/memory.hh
View file

@ -15,7 +15,7 @@
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
namespace axolotl { namespace olm {
/** Clear the memory held in the buffer */ /** Clear the memory held in the buffer */
void unset( void unset(
@ -35,4 +35,4 @@ bool is_equal(
std::size_t length std::size_t length
); );
} // namespace axolotl } // namespace olm

4
include/axolotl/message.hh → include/olm/message.hh
View file

@ -16,7 +16,7 @@
#include <cstdint> #include <cstdint>
namespace axolotl { namespace olm {
/** /**
* The length of the buffer needed to hold a message. * The length of the buffer needed to hold a message.
@ -123,4 +123,4 @@ void decode_one_time_key_message(
); );
} // namespace axolotl } // namespace olm

295
include/olm/olm.hh Normal file
View file

@ -0,0 +1,295 @@
/* Copyright 2015 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.
*/
#ifndef OLM_HH_
#define OLM_HH_
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
static const size_t OLM_MESSAGE_TYPE_PRE_KEY = 0;
static const size_t OLM_MESSAGE_TYPE_MESSAGE = 1;
struct OlmAccount;
struct OlmSession;
/** 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();
/** 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
);
/** 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(
OlmSession * account
);
/** A null terminated string describing the most recent error to happen to a
* session */
const char * olm_session_last_error(
OlmSession * session
);
/** Returns the number of bytes needed to store an account */
size_t olm_pickle_account_length(
OlmAccount * account
);
/** Returns the number of bytes needed to store a session */
size_t olm_pickle_session_length(
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,
void const * 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,
void const * 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,
void const * 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,
void const * 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(
OlmAccount * account
);
/** Creates a new account. Returns olm_error() on failure. If weren't
* enough random bytes then olm_account_last_error() will be
* "NOT_ENOUGH_RANDOM" */
size_t olm_create_account(
OlmAccount * account,
void const * random, size_t random_length
);
/** The size of the output buffer needed to hold the identity keys */
size_t olm_account_identity_keys_length(
OlmAccount * account
);
/** Writes the public parts of the identity keys for the account into the
* identity_keys output buffer. The output is formatted as though it was
* created with sprintf(output, "[[%10d,\"%43s\"]\n]", key_id, key_base64).
* The output can either be parsed as fixed width using the above format or by
* a JSON parser. 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 size of the output buffer needed to hold the one time keys */
size_t olm_account_one_time_keys_length(
OlmAccount * account
);
/** Writes the public parts of the one time keys for the account into the
* one_time_keys output buffer. The first key will be formatted as though it was
* created with sprintf(output, "[[%10d,\"%43s\"]\n", key_id, key_base64).
* subsequent keys are formatted with ",[%10d,\"%43s\"]\n". The final byte of
* output will be "]". The output can either be parsed as fixed width using
* the above format or by a JSON parser. Returns olm_error() on failure.
* 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
);
/* TODO: Add methods for marking keys as used, generating new keys, and
* tracking which keys have been uploaded to the central servers */
/** The number of random bytes needed to create an outbound session */
size_t olm_create_outbound_session_random_length(
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,
OlmAccount * account,
void const * their_identity_key, size_t their_identity_key_length,
unsigned their_one_time_key_id,
void const * their_one_time_key, size_t their_one_time_key_length,
void const * 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 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
);
/** 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. 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
);
/** 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(
OlmSession * session
);
/** The number of random bytes needed to encrypt the next message. */
size_t olm_encrypt_random_length(
OlmSession * session
);
/** The size of the next message in bytes for the given number of plain-text
* bytes. */
size_t olm_encrypt_message_length(
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,
void const * plaintext, size_t plaintext_length,
void const * 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
);
#ifdef __cplusplus
}
#endif
#endif /* OLM_HH_ */

20
include/axolotl/pickle.hh → include/olm/pickle.hh
View file

@ -12,16 +12,16 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef AXOLOTL_PICKLE_HH_ #ifndef OLM_PICKLE_HH_
#define AXOLOTL_PICKLE_HH_ #define OLM_PICKLE_HH_
#include "axolotl/list.hh" #include "olm/list.hh"
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include <cstring> #include <cstring>
#include <cstdint> #include <cstdint>
namespace axolotl { namespace olm {
static std::size_t pickle_length( static std::size_t pickle_length(
const std::uint32_t & value const std::uint32_t & value
@ -79,7 +79,7 @@ static std::uint8_t const * unpickle(
template<typename T, std::size_t max_size> template<typename T, std::size_t max_size>
std::size_t pickle_length( std::size_t pickle_length(
axolotl::List<T, max_size> const & list olm::List<T, max_size> const & list
) { ) {
std::size_t length = pickle_length(std::uint32_t(list.size())); std::size_t length = pickle_length(std::uint32_t(list.size()));
for (auto const & value : list) { for (auto const & value : list) {
@ -92,7 +92,7 @@ std::size_t pickle_length(
template<typename T, std::size_t max_size> template<typename T, std::size_t max_size>
std::uint8_t * pickle( std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
axolotl::List<T, max_size> const & list olm::List<T, max_size> const & list
) { ) {
pos = pickle(pos, std::uint32_t(list.size())); pos = pickle(pos, std::uint32_t(list.size()));
for (auto const & value : list) { for (auto const & value : list) {
@ -105,7 +105,7 @@ std::uint8_t * pickle(
template<typename T, std::size_t max_size> template<typename T, std::size_t max_size>
std::uint8_t const * unpickle( std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::List<T, max_size> & list olm::List<T, max_size> & list
) { ) {
std::uint32_t size; std::uint32_t size;
pos = unpickle(pos, end, size); pos = unpickle(pos, end, size);
@ -170,9 +170,9 @@ std::uint8_t const * unpickle(
); );
} // namespace axolotl } // namespace olm
#endif /* AXOLOTL_PICKLE_HH */ #endif /* OLM_PICKLE_HH */

10
include/axolotl/ratchet.hh → include/olm/ratchet.hh
View file

@ -13,11 +13,11 @@
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include "axolotl/list.hh" #include "olm/list.hh"
#include "axolotl/error.hh" #include "olm/error.hh"
namespace axolotl { namespace olm {
class Cipher; class Cipher;
@ -174,4 +174,4 @@ std::uint8_t const * unpickle(
); );
} // namespace axolotl } // namespace olm

12
include/axolotl/session.hh → include/olm/session.hh
View file

@ -12,12 +12,12 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef AXOLOTL_SESSION_HH_ #ifndef OLM_SESSION_HH_
#define AXOLOTL_SESSION_HH_ #define OLM_SESSION_HH_
#include "axolotl/ratchet.hh" #include "olm/ratchet.hh"
namespace axolotl { namespace olm {
class Account; class Account;
@ -109,6 +109,6 @@ std::uint8_t const * unpickle(
); );
} // namespace axolotl } // namespace olm
#endif /* AXOLOTL_SESSION_HH_ */ #endif /* OLM_SESSION_HH_ */

1
javascript/axolotl_pre.js
View file

@ -1 +0,0 @@
Axolotl = function() {

6
javascript/build.py
View file

@ -28,8 +28,8 @@ if not os.path.exists("build"):
os.mkdir("build") os.mkdir("build")
functions = set() functions = set()
RE_FUNCTION=re.compile("(axolotl_[^( ]*)\\(") RE_FUNCTION=re.compile("(olm_[^( ]*)\\(")
with open("include/axolotl/axolotl.hh") as header: with open("include/olm/olm.hh") as header:
for line in header: for line in header:
match = RE_FUNCTION.search(line) match = RE_FUNCTION.search(line)
if match: if match:
@ -60,7 +60,7 @@ compile_args += ("--pre-js", pre_js)
compile_args += ("--post-js", post_js) compile_args += ("--post-js", post_js)
compile_args += ("-s", "EXPORTED_FUNCTIONS=@" + exported_functions) compile_args += ("-s", "EXPORTED_FUNCTIONS=@" + exported_functions)
library = "build/axolotl.js" library = "build/olm.js"
def run(args): def run(args):
print args print args

10
javascript/demo.html
View file

@ -1,6 +1,6 @@
<html> <html>
<head> <head>
<script src="../build/axolotl.js"></script> <script src="../build/olm.js"></script>
<script> <script>
document.addEventListener("DOMContentLoaded", function (event) { document.addEventListener("DOMContentLoaded", function (event) {
@ -19,10 +19,10 @@ document.addEventListener("DOMContentLoaded", function (event) {
return {start:start, done:done}; return {start:start, done:done};
} }
var alice = new Axolotl.Account(); var alice = new Olm.Account();
var bob = new Axolotl.Account(); var bob = new Olm.Account();
var a_session = new Axolotl.Session(); var a_session = new Olm.Session();
var b_session = new Axolotl.Session(); var b_session = new Olm.Session();
var message_1; var message_1;
var tasks = []; var tasks = [];

66
javascript/axolotl_post.js → javascript/olm_post.js
View file

@ -2,7 +2,7 @@ var runtime = Module['Runtime'];
var malloc = Module['_malloc']; var malloc = Module['_malloc'];
var free = Module['_free']; var free = Module['_free'];
var Pointer_stringify = Module['Pointer_stringify']; var Pointer_stringify = Module['Pointer_stringify'];
var AXOLOTL_ERROR = Module['_axolotl_error'](); var OLM_ERROR = Module['_olm_error']();
function stack(size_or_array) { function stack(size_or_array) {
return Module['allocate'](size_or_array, 'i8', Module['ALLOC_STACK']); return Module['allocate'](size_or_array, 'i8', Module['ALLOC_STACK']);
@ -31,19 +31,19 @@ function restore_stack(wrapped) {
} }
function Account() { function Account() {
var size = Module['_axolotl_account_size'](); var size = Module['_olm_account_size']();
this.buf = malloc(size); this.buf = malloc(size);
this.ptr = Module['_axolotl_account'](this.buf); this.ptr = Module['_olm_account'](this.buf);
} }
function account_method(wrapped) { function account_method(wrapped) {
return function() { return function() {
var result = wrapped.apply(this, arguments); var result = wrapped.apply(this, arguments);
if (result === AXOLOTL_ERROR) { if (result === OLM_ERROR) {
var message = Pointer_stringify( var message = Pointer_stringify(
Module['_axolotl_account_last_error'](arguments[0]) Module['_olm_account_last_error'](arguments[0])
); );
throw new Error("AXOLOTL." + message); throw new Error("OLM." + message);
} }
return result; return result;
} }
@ -55,20 +55,20 @@ Account.prototype['free'] = function() {
Account.prototype['create'] = restore_stack(function() { Account.prototype['create'] = restore_stack(function() {
var random_length = account_method( var random_length = account_method(
Module['_axolotl_create_account_random_length'] Module['_olm_create_account_random_length']
)(this.ptr); )(this.ptr);
var random = random_stack(random_length); var random = random_stack(random_length);
account_method(Module['_axolotl_create_account'])( account_method(Module['_olm_create_account'])(
this.ptr, random, random_length this.ptr, random, random_length
); );
}); });
Account.prototype['identity_keys'] = restore_stack(function() { Account.prototype['identity_keys'] = restore_stack(function() {
var keys_length = account_method( var keys_length = account_method(
Module['_axolotl_account_identity_keys_length'] Module['_olm_account_identity_keys_length']
)(this.ptr); )(this.ptr);
var keys = stack(keys_length); var keys = stack(keys_length);
account_method(Module['_axolotl_account_identity_keys'])( account_method(Module['_olm_account_identity_keys'])(
this.ptr, keys, keys_length this.ptr, keys, keys_length
); );
return Pointer_stringify(keys, keys_length); return Pointer_stringify(keys, keys_length);
@ -76,10 +76,10 @@ Account.prototype['identity_keys'] = restore_stack(function() {
Account.prototype['one_time_keys'] = restore_stack(function() { Account.prototype['one_time_keys'] = restore_stack(function() {
var keys_length = account_method( var keys_length = account_method(
Module['_axolotl_account_one_time_keys_length'] Module['_olm_account_one_time_keys_length']
)(this.ptr); )(this.ptr);
var keys = stack(keys_length); var keys = stack(keys_length);
account_method(Module['_axolotl_account_one_time_keys'])( account_method(Module['_olm_account_one_time_keys'])(
this.ptr, keys, keys_length this.ptr, keys, keys_length
); );
return Pointer_stringify(keys, keys_length); return Pointer_stringify(keys, keys_length);
@ -88,11 +88,11 @@ Account.prototype['one_time_keys'] = restore_stack(function() {
Account.prototype['pickle'] = restore_stack(function(key) { Account.prototype['pickle'] = restore_stack(function(key) {
var key_array = array_from_string(key); var key_array = array_from_string(key);
var pickle_length = account_method( var pickle_length = account_method(
Module['_axolotl_pickle_account_length'] Module['_olm_pickle_account_length']
)(this.ptr); )(this.ptr);
var key_buffer = stack(key_array); var key_buffer = stack(key_array);
var pickle_buffer = stack(pickle_length); var pickle_buffer = stack(pickle_length);
account_method(Module['_axolotl_pickle_account'])( account_method(Module['_olm_pickle_account'])(
this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length
); );
return Pointer_stringify(pickle_buffer, pickle_length); return Pointer_stringify(pickle_buffer, pickle_length);
@ -103,26 +103,26 @@ Account.prototype['unpickle'] = restore_stack(function(key, pickle) {
var key_buffer = stack(key_array); var key_buffer = stack(key_array);
var pickle_array = array_from_string(pickle); var pickle_array = array_from_string(pickle);
var pickle_buffer = stack(pickle_length); var pickle_buffer = stack(pickle_length);
account_method(Module['_axolotl_unpickle_account'])( account_method(Module['_olm_unpickle_account'])(
this.ptr, key_buffer, key_array.length, pickle_buffer, this.ptr, key_buffer, key_array.length, pickle_buffer,
pickle_array.length pickle_array.length
); );
}); });
function Session() { function Session() {
var size = Module['_axolotl_session_size'](); var size = Module['_olm_session_size']();
this.buf = malloc(size); this.buf = malloc(size);
this.ptr = Module['_axolotl_session'](this.buf); this.ptr = Module['_olm_session'](this.buf);
} }
function session_method(wrapped) { function session_method(wrapped) {
return function() { return function() {
var result = wrapped.apply(this, arguments); var result = wrapped.apply(this, arguments);
if (result === AXOLOTL_ERROR) { if (result === OLM_ERROR) {
var message = Pointer_stringify( var message = Pointer_stringify(
Module['_axolotl_session_last_error'](arguments[0]) Module['_olm_session_last_error'](arguments[0])
); );
throw new Error("AXOLOTL." + message); throw new Error("OLM." + message);
} }
return result; return result;
} }
@ -135,11 +135,11 @@ Session.prototype['free'] = function() {
Session.prototype['pickle'] = restore_stack(function(key) { Session.prototype['pickle'] = restore_stack(function(key) {
var key_array = array_from_string(key); var key_array = array_from_string(key);
var pickle_length = session_method( var pickle_length = session_method(
Module['_axolotl_pickle_session_length'] Module['_olm_pickle_session_length']
)(this.ptr); )(this.ptr);
var key_buffer = stack(key_array); var key_buffer = stack(key_array);
var pickle_buffer = stack(pickle_length); var pickle_buffer = stack(pickle_length);
session_method(Module['_axolotl_pickle_session'])( session_method(Module['_olm_pickle_session'])(
this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length
); );
return Pointer_stringify(pickle_buffer, pickle_length); return Pointer_stringify(pickle_buffer, pickle_length);
@ -150,7 +150,7 @@ Session.prototype['unpickle'] = restore_stack(function(key, pickle) {
var key_buffer = stack(key_array); var key_buffer = stack(key_array);
var pickle_array = array_from_string(pickle); var pickle_array = array_from_string(pickle);
var pickle_buffer = stack(pickle_array); var pickle_buffer = stack(pickle_array);
session_method(Module['_axolotl_unpickle_session'])( session_method(Module['_olm_unpickle_session'])(
this.ptr, key_buffer, key_array.length, pickle_buffer, this.ptr, key_buffer, key_array.length, pickle_buffer,
pickle_array.length pickle_array.length
); );
@ -160,14 +160,14 @@ Session.prototype['create_outbound'] = restore_stack(function(
account, their_identity_key, their_one_time_key_id, their_one_time_key account, their_identity_key, their_one_time_key_id, their_one_time_key
) { ) {
var random_length = session_method( var random_length = session_method(
Module['_axolotl_create_outbound_session_random_length'] Module['_olm_create_outbound_session_random_length']
)(this.ptr); )(this.ptr);
var random = random_stack(random_length); var random = random_stack(random_length);
var identity_key_array = array_from_string(their_identity_key); var identity_key_array = array_from_string(their_identity_key);
var one_time_key_array = array_from_string(their_one_time_key); var one_time_key_array = array_from_string(their_one_time_key);
var identity_key_buffer = stack(identity_key_array); var identity_key_buffer = stack(identity_key_array);
var one_time_key_buffer = stack(one_time_key_array); var one_time_key_buffer = stack(one_time_key_array);
session_method(Module['_axolotl_create_outbound_session'])( session_method(Module['_olm_create_outbound_session'])(
this.ptr, account.ptr, this.ptr, account.ptr,
identity_key_buffer, identity_key_array.length, identity_key_buffer, identity_key_array.length,
their_one_time_key_id, their_one_time_key_id,
@ -181,7 +181,7 @@ Session.prototype['create_inbound'] = restore_stack(function(
) { ) {
var message_array = array_from_string(one_time_key_message); var message_array = array_from_string(one_time_key_message);
var message_buffer = stack(message_array); var message_buffer = stack(message_array);
session_method(Module['_axolotl_create_inbound_session'])( session_method(Module['_olm_create_inbound_session'])(
this.ptr, account.ptr, message_buffer, message_array.length this.ptr, account.ptr, message_buffer, message_array.length
); );
}); });
@ -191,7 +191,7 @@ Session.prototype['matches_inbound'] = restore_stack(function(
) { ) {
var message_array = array_from_string(one_time_key_message); var message_array = array_from_string(one_time_key_message);
var message_buffer = stack(message_array); var message_buffer = stack(message_array);
return session_method(Module['_axolotl_matches_inbound_session'])( return session_method(Module['_olm_matches_inbound_session'])(
this.ptr, account.ptr, message_buffer, message_array.length this.ptr, account.ptr, message_buffer, message_array.length
) ? true : false; ) ? true : false;
}); });
@ -200,19 +200,19 @@ Session.prototype['encrypt'] = restore_stack(function(
plaintext plaintext
) { ) {
var random_length = session_method( var random_length = session_method(
Module['_axolotl_encrypt_random_length'] Module['_olm_encrypt_random_length']
)(this.ptr); )(this.ptr);
var message_type = session_method( var message_type = session_method(
Module['_axolotl_encrypt_message_type'] Module['_olm_encrypt_message_type']
)(this.ptr); )(this.ptr);
var plaintext_array = array_from_string(plaintext); var plaintext_array = array_from_string(plaintext);
var message_length = session_method( var message_length = session_method(
Module['_axolotl_encrypt_message_length'] Module['_olm_encrypt_message_length']
)(this.ptr, plaintext_array.length); )(this.ptr, plaintext_array.length);
var random = random_stack(random_length); var random = random_stack(random_length);
var plaintext_buffer = stack(plaintext_array); var plaintext_buffer = stack(plaintext_array);
var message_buffer = stack(message_length); var message_buffer = stack(message_length);
session_method(Module['_axolotl_encrypt'])( session_method(Module['_olm_encrypt'])(
this.ptr, this.ptr,
plaintext_buffer, plaintext_array.length, plaintext_buffer, plaintext_array.length,
random, random_length, random, random_length,
@ -230,13 +230,13 @@ Session.prototype['decrypt'] = restore_stack(function(
var message_array = array_from_string(message); var message_array = array_from_string(message);
var message_buffer = stack(message_array); var message_buffer = stack(message_array);
var max_plaintext_length = session_method( var max_plaintext_length = session_method(
Module['_axolotl_decrypt_max_plaintext_length'] Module['_olm_decrypt_max_plaintext_length']
)(this.ptr, message_type, message_buffer, message_array.length); )(this.ptr, message_type, message_buffer, message_array.length);
// caculating the length destroys the input buffer. // caculating the length destroys the input buffer.
// So we copy the array to a new buffer // So we copy the array to a new buffer
var message_buffer = stack(message_array); var message_buffer = stack(message_array);
var plaintext_buffer = stack(max_plaintext_length); var plaintext_buffer = stack(max_plaintext_length);
var plaintext_length = session_method(Module["_axolotl_decrypt"])( var plaintext_length = session_method(Module["_olm_decrypt"])(
this.ptr, message_type, this.ptr, message_type,
message_buffer, message.length, message_buffer, message.length,
plaintext_buffer, max_plaintext_length plaintext_buffer, max_plaintext_length

1
javascript/olm_pre.js Normal file
View file

@ -0,0 +1 @@
Olm = function() {

136
axolotl.py → olm.py
View file

@ -2,31 +2,31 @@
from ctypes import * from ctypes import *
import json import json
lib = cdll.LoadLibrary("build/libaxolotl.so") lib = cdll.LoadLibrary("build/libolm.so")
lib.axolotl_error.argtypes = [] lib.olm_error.argtypes = []
lib.axolotl_error.restypes = c_size_t lib.olm_error.restypes = c_size_t
ERR = lib.axolotl_error() ERR = lib.olm_error()
class AxolotlError(Exception): class OlmError(Exception):
pass pass
lib.axolotl_account_size.argtypes = [] lib.olm_account_size.argtypes = []
lib.axolotl_account_size.restype = c_size_t lib.olm_account_size.restype = c_size_t
lib.axolotl_account.argtypes = [c_void_p] lib.olm_account.argtypes = [c_void_p]
lib.axolotl_account.restype = c_void_p lib.olm_account.restype = c_void_p
lib.axolotl_account_last_error.argtypes = [c_void_p] lib.olm_account_last_error.argtypes = [c_void_p]
lib.axolotl_account_last_error.restype = c_char_p lib.olm_account_last_error.restype = c_char_p
def account_errcheck(res, func, args): def account_errcheck(res, func, args):
if res == ERR: if res == ERR:
raise AxolotlError("%s: %s" % ( raise OlmError("%s: %s" % (
func.__name__, lib.axolotl_account_last_error(args[0]) func.__name__, lib.olm_account_last_error(args[0])
)) ))
return res return res
@ -38,17 +38,17 @@ def account_function(func, *types):
account_function( account_function(
lib.axolotl_pickle_account, c_void_p, c_size_t, c_void_p, c_size_t lib.olm_pickle_account, c_void_p, c_size_t, c_void_p, c_size_t
) )
account_function( account_function(
lib.axolotl_unpickle_account, c_void_p, c_size_t, c_void_p, c_size_t lib.olm_unpickle_account, c_void_p, c_size_t, c_void_p, c_size_t
) )
account_function(lib.axolotl_create_account_random_length) account_function(lib.olm_create_account_random_length)
account_function(lib.axolotl_create_account, c_void_p, c_size_t) account_function(lib.olm_create_account, c_void_p, c_size_t)
account_function(lib.axolotl_account_identity_keys_length) account_function(lib.olm_account_identity_keys_length)
account_function(lib.axolotl_account_identity_keys, c_void_p, c_size_t) account_function(lib.olm_account_identity_keys, c_void_p, c_size_t)
account_function(lib.axolotl_account_one_time_keys_length) account_function(lib.olm_account_one_time_keys_length)
account_function(lib.axolotl_account_one_time_keys, c_void_p, c_size_t) account_function(lib.olm_account_one_time_keys, c_void_p, c_size_t)
def read_random(n): def read_random(n):
with open("/dev/urandom", "rb") as f: with open("/dev/urandom", "rb") as f:
@ -56,20 +56,20 @@ def read_random(n):
class Account(object): class Account(object):
def __init__(self): def __init__(self):
self.buf = create_string_buffer(lib.axolotl_account_size()) self.buf = create_string_buffer(lib.olm_account_size())
self.ptr = lib.axolotl_account(self.buf) self.ptr = lib.olm_account(self.buf)
def create(self): def create(self):
random_length = lib.axolotl_create_account_random_length(self.ptr) random_length = lib.olm_create_account_random_length(self.ptr)
random = read_random(random_length) random = read_random(random_length)
random_buffer = create_string_buffer(random) random_buffer = create_string_buffer(random)
lib.axolotl_create_account(self.ptr, random_buffer, random_length) lib.olm_create_account(self.ptr, random_buffer, random_length)
def pickle(self, key): def pickle(self, key):
key_buffer = create_string_buffer(key) key_buffer = create_string_buffer(key)
pickle_length = lib.axolotl_pickle_account_length(self.ptr) pickle_length = lib.olm_pickle_account_length(self.ptr)
pickle_buffer = create_string_buffer(pickle_length) pickle_buffer = create_string_buffer(pickle_length)
lib.axolotl_pickle_account( lib.olm_pickle_account(
self.ptr, key_buffer, len(key), pickle_buffer, pickle_length self.ptr, key_buffer, len(key), pickle_buffer, pickle_length
) )
return pickle_buffer.raw return pickle_buffer.raw
@ -77,40 +77,40 @@ class Account(object):
def unpickle(self, key, pickle): def unpickle(self, key, pickle):
key_buffer = create_string_buffer(key) key_buffer = create_string_buffer(key)
pickle_buffer = create_string_buffer(pickle) pickle_buffer = create_string_buffer(pickle)
lib.axolotl_unpickle_account( lib.olm_unpickle_account(
self.ptr, key_buffer, len(key), pickle_buffer, len(pickle) self.ptr, key_buffer, len(key), pickle_buffer, len(pickle)
) )
def identity_keys(self): def identity_keys(self):
out_length = lib.axolotl_account_identity_keys_length(self.ptr) out_length = lib.olm_account_identity_keys_length(self.ptr)
out_buffer = create_string_buffer(out_length) out_buffer = create_string_buffer(out_length)
lib.axolotl_account_identity_keys(self.ptr, out_buffer, out_length) lib.olm_account_identity_keys(self.ptr, out_buffer, out_length)
return json.loads(out_buffer.raw) return json.loads(out_buffer.raw)
def one_time_keys(self): def one_time_keys(self):
out_length = lib.axolotl_account_one_time_keys_length(self.ptr) out_length = lib.olm_account_one_time_keys_length(self.ptr)
out_buffer = create_string_buffer(out_length) out_buffer = create_string_buffer(out_length)
lib.axolotl_account_one_time_keys(self.ptr, out_buffer, out_length) lib.olm_account_one_time_keys(self.ptr, out_buffer, out_length)
return json.loads(out_buffer.raw) return json.loads(out_buffer.raw)
def clear(self): def clear(self):
pass pass
lib.axolotl_session_size.argtypes = [] lib.olm_session_size.argtypes = []
lib.axolotl_session_size.restype = c_size_t lib.olm_session_size.restype = c_size_t
lib.axolotl_session.argtypes = [c_void_p] lib.olm_session.argtypes = [c_void_p]
lib.axolotl_session.restype = c_void_p lib.olm_session.restype = c_void_p
lib.axolotl_session_last_error.argtypes = [c_void_p] lib.olm_session_last_error.argtypes = [c_void_p]
lib.axolotl_session_last_error.restype = c_char_p lib.olm_session_last_error.restype = c_char_p
def session_errcheck(res, func, args): def session_errcheck(res, func, args):
if res == ERR: if res == ERR:
raise AxolotlError("%s: %s" % ( raise OlmError("%s: %s" % (
func.__name__, lib.axolotl_session_last_error(args[0]) func.__name__, lib.olm_session_last_error(args[0])
)) ))
return res return res
@ -120,16 +120,16 @@ def session_function(func, *types):
func.restypes = c_size_t func.restypes = c_size_t
func.errcheck = session_errcheck func.errcheck = session_errcheck
session_function(lib.axolotl_session_last_error) session_function(lib.olm_session_last_error)
session_function( session_function(
lib.axolotl_pickle_session, c_void_p, c_size_t, c_void_p, c_size_t lib.olm_pickle_session, c_void_p, c_size_t, c_void_p, c_size_t
) )
session_function( session_function(
lib.axolotl_unpickle_session, c_void_p, c_size_t, c_void_p, c_size_t lib.olm_unpickle_session, c_void_p, c_size_t, c_void_p, c_size_t
) )
session_function(lib.axolotl_create_outbound_session_random_length) session_function(lib.olm_create_outbound_session_random_length)
session_function( session_function(
lib.axolotl_create_outbound_session, lib.olm_create_outbound_session,
c_void_p, # Account c_void_p, # Account
c_void_p, c_size_t, # Identity Key c_void_p, c_size_t, # Identity Key
c_uint, # One Time Key Id c_uint, # One Time Key Id
@ -137,27 +137,27 @@ session_function(
c_void_p, c_size_t, # Random c_void_p, c_size_t, # Random
) )
session_function( session_function(
lib.axolotl_create_inbound_session, lib.olm_create_inbound_session,
c_void_p, # Account c_void_p, # Account
c_void_p, c_size_t, # Pre Key Message c_void_p, c_size_t, # Pre Key Message
) )
session_function(lib.axolotl_matches_inbound_session, c_void_p, c_size_t) session_function(lib.olm_matches_inbound_session, c_void_p, c_size_t)
session_function(lib.axolotl_encrypt_message_type) session_function(lib.olm_encrypt_message_type)
session_function(lib.axolotl_encrypt_random_length) session_function(lib.olm_encrypt_random_length)
session_function(lib.axolotl_encrypt_message_length, c_size_t) session_function(lib.olm_encrypt_message_length, c_size_t)
session_function( session_function(
lib.axolotl_encrypt, lib.olm_encrypt,
c_void_p, c_size_t, # Plaintext c_void_p, c_size_t, # Plaintext
c_void_p, c_size_t, # Random c_void_p, c_size_t, # Random
c_void_p, c_size_t, # Message c_void_p, c_size_t, # Message
); );
session_function( session_function(
lib.axolotl_decrypt_max_plaintext_length, lib.olm_decrypt_max_plaintext_length,
c_size_t, # Message Type c_size_t, # Message Type
c_void_p, c_size_t, # Message c_void_p, c_size_t, # Message
) )
session_function( session_function(
lib.axolotl_decrypt, lib.olm_decrypt,
c_size_t, # Message Type c_size_t, # Message Type
c_void_p, c_size_t, # Message c_void_p, c_size_t, # Message
c_void_p, c_size_t, # Plaintext c_void_p, c_size_t, # Plaintext
@ -165,14 +165,14 @@ session_function(
class Session(object): class Session(object):
def __init__(self): def __init__(self):
self.buf = create_string_buffer(lib.axolotl_session_size()) self.buf = create_string_buffer(lib.olm_session_size())
self.ptr = lib.axolotl_session(self.buf) self.ptr = lib.olm_session(self.buf)
def pickle(self, key): def pickle(self, key):
key_buffer = create_string_buffer(key) key_buffer = create_string_buffer(key)
pickle_length = lib.axolotl_pickle_session_length(self.ptr) pickle_length = lib.olm_pickle_session_length(self.ptr)
pickle_buffer = create_string_buffer(pickle_length) pickle_buffer = create_string_buffer(pickle_length)
lib.axolotl_pickle_session( lib.olm_pickle_session(
self.ptr, key_buffer, len(key), pickle_buffer, pickle_length self.ptr, key_buffer, len(key), pickle_buffer, pickle_length
) )
return pickle_buffer.raw return pickle_buffer.raw
@ -180,18 +180,18 @@ class Session(object):
def unpickle(self, key, pickle): def unpickle(self, key, pickle):
key_buffer = create_string_buffer(key) key_buffer = create_string_buffer(key)
pickle_buffer = create_string_buffer(pickle) pickle_buffer = create_string_buffer(pickle)
lib.axolotl_unpickle_session( lib.olm_unpickle_session(
self.ptr, key_buffer, len(key), pickle_buffer, len(pickle) self.ptr, key_buffer, len(key), pickle_buffer, len(pickle)
) )
def create_outbound(self, account, identity_key, one_time_key_id, def create_outbound(self, account, identity_key, one_time_key_id,
one_time_key): one_time_key):
r_length = lib.axolotl_create_outbound_session_random_length(self.ptr) r_length = lib.olm_create_outbound_session_random_length(self.ptr)
random = read_random(r_length) random = read_random(r_length)
random_buffer = create_string_buffer(random) random_buffer = create_string_buffer(random)
identity_key_buffer = create_string_buffer(identity_key) identity_key_buffer = create_string_buffer(identity_key)
one_time_key_buffer = create_string_buffer(one_time_key) one_time_key_buffer = create_string_buffer(one_time_key)
lib.axolotl_create_outbound_session( lib.olm_create_outbound_session(
self.ptr, self.ptr,
account.ptr, account.ptr,
identity_key_buffer, len(identity_key), identity_key_buffer, len(identity_key),
@ -202,7 +202,7 @@ class Session(object):
def create_inbound(self, account, one_time_key_message): def create_inbound(self, account, one_time_key_message):
one_time_key_message_buffer = create_string_buffer(one_time_key_message) one_time_key_message_buffer = create_string_buffer(one_time_key_message)
lib.axolotl_create_inbound_session( lib.olm_create_inbound_session(
self.ptr, self.ptr,
account.ptr, account.ptr,
one_time_key_message_buffer, len(one_time_key_message) one_time_key_message_buffer, len(one_time_key_message)
@ -210,25 +210,25 @@ class Session(object):
def matches_inbound(self, one_time_key_message): def matches_inbound(self, one_time_key_message):
one_time_key_message_buffer = create_string_buffer(one_time_key_message) one_time_key_message_buffer = create_string_buffer(one_time_key_message)
return bool(lib.axolotl_create_inbound_session( return bool(lib.olm_create_inbound_session(
self.ptr, self.ptr,
one_time_key_message_buffer, len(one_time_key_message) one_time_key_message_buffer, len(one_time_key_message)
)) ))
def encrypt(self, plaintext): def encrypt(self, plaintext):
r_length = lib.axolotl_encrypt_random_length(self.ptr) r_length = lib.olm_encrypt_random_length(self.ptr)
random = read_random(r_length) random = read_random(r_length)
random_buffer = create_string_buffer(random) random_buffer = create_string_buffer(random)
message_type = lib.axolotl_encrypt_message_type(self.ptr) message_type = lib.olm_encrypt_message_type(self.ptr)
message_length = lib.axolotl_encrypt_message_length( message_length = lib.olm_encrypt_message_length(
self.ptr, len(plaintext) self.ptr, len(plaintext)
) )
message_buffer = create_string_buffer(message_length) message_buffer = create_string_buffer(message_length)
plaintext_buffer = create_string_buffer(plaintext) plaintext_buffer = create_string_buffer(plaintext)
lib.axolotl_encrypt( lib.olm_encrypt(
self.ptr, self.ptr,
plaintext_buffer, len(plaintext), plaintext_buffer, len(plaintext),
random_buffer, r_length, random_buffer, r_length,
@ -238,12 +238,12 @@ class Session(object):
def decrypt(self, message_type, message): def decrypt(self, message_type, message):
message_buffer = create_string_buffer(message) message_buffer = create_string_buffer(message)
max_plaintext_length = lib.axolotl_decrypt_max_plaintext_length( max_plaintext_length = lib.olm_decrypt_max_plaintext_length(
self.ptr, message_type, message_buffer, len(message) self.ptr, message_type, message_buffer, len(message)
) )
plaintext_buffer = create_string_buffer(max_plaintext_length) plaintext_buffer = create_string_buffer(max_plaintext_length)
message_buffer = create_string_buffer(message) message_buffer = create_string_buffer(message)
plaintext_length = lib.axolotl_decrypt( plaintext_length = lib.olm_decrypt(
self.ptr, message_type, message_buffer, len(message), self.ptr, message_type, message_buffer, len(message),
plaintext_buffer, max_plaintext_length plaintext_buffer, max_plaintext_length
) )

88
src/account.cpp
View file

@ -12,20 +12,20 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/account.hh" #include "olm/account.hh"
#include "axolotl/pickle.hh" #include "olm/pickle.hh"
axolotl::LocalKey const * axolotl::Account::lookup_key( olm::LocalKey const * olm::Account::lookup_key(
std::uint32_t id std::uint32_t id
) { ) {
for (axolotl::LocalKey const & key : one_time_keys) { for (olm::LocalKey const & key : one_time_keys) {
if (key.id == id) return &key; if (key.id == id) return &key;
} }
return 0; return 0;
} }
std::size_t axolotl::Account::remove_key( std::size_t olm::Account::remove_key(
std::uint32_t id std::uint32_t id
) { ) {
LocalKey * i; LocalKey * i;
@ -38,34 +38,34 @@ std::size_t axolotl::Account::remove_key(
return std::size_t(-1); return std::size_t(-1);
} }
std::size_t axolotl::Account::new_account_random_length() { std::size_t olm::Account::new_account_random_length() {
return 103 * 32; return 103 * 32;
} }
std::size_t axolotl::Account::new_account( std::size_t olm::Account::new_account(
uint8_t const * random, std::size_t random_length uint8_t const * random, std::size_t random_length
) { ) {
if (random_length < new_account_random_length()) { if (random_length < new_account_random_length()) {
last_error = axolotl::ErrorCode::NOT_ENOUGH_RANDOM; last_error = olm::ErrorCode::NOT_ENOUGH_RANDOM;
return std::size_t(-1); return std::size_t(-1);
} }
unsigned id = 0; unsigned id = 0;
identity_key.id = ++id; identity_key.id = ++id;
axolotl::generate_key(random, identity_key.key); olm::generate_key(random, identity_key.key);
random += 32; random += 32;
random += 32; random += 32;
last_resort_one_time_key.id = ++id; last_resort_one_time_key.id = ++id;
axolotl::generate_key(random, last_resort_one_time_key.key); olm::generate_key(random, last_resort_one_time_key.key);
random += 32; random += 32;
for (unsigned i = 0; i < 10; ++i) { for (unsigned i = 0; i < 10; ++i) {
LocalKey & key = *one_time_keys.insert(one_time_keys.end()); LocalKey & key = *one_time_keys.insert(one_time_keys.end());
key.id = ++id; key.id = ++id;
axolotl::generate_key(random, key.key); olm::generate_key(random, key.key);
random += 32; random += 32;
} }
@ -73,94 +73,94 @@ std::size_t axolotl::Account::new_account(
} }
namespace axolotl { namespace olm {
static std::size_t pickle_length( static std::size_t pickle_length(
axolotl::LocalKey const & value olm::LocalKey const & value
) { ) {
return axolotl::pickle_length(value.id) + axolotl::pickle_length(value.key); return olm::pickle_length(value.id) + olm::pickle_length(value.key);
} }
static std::uint8_t * pickle( static std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
axolotl::LocalKey const & value olm::LocalKey const & value
) { ) {
pos = axolotl::pickle(pos, value.id); pos = olm::pickle(pos, value.id);
pos = axolotl::pickle(pos, value.key); pos = olm::pickle(pos, value.key);
return pos; return pos;
} }
static std::uint8_t const * unpickle( static std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::LocalKey & value olm::LocalKey & value
) { ) {
pos = axolotl::unpickle(pos, end, value.id); pos = olm::unpickle(pos, end, value.id);
pos = axolotl::unpickle(pos, end, value.key); pos = olm::unpickle(pos, end, value.key);
return pos; return pos;
} }
static std::size_t pickle_length( static std::size_t pickle_length(
axolotl::SignedKey const & value olm::SignedKey const & value
) { ) {
return axolotl::pickle_length((axolotl::LocalKey const &) value) + 64; return olm::pickle_length((olm::LocalKey const &) value) + 64;
} }
static std::uint8_t * pickle( static std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
axolotl::SignedKey const & value olm::SignedKey const & value
) { ) {
pos = axolotl::pickle(pos, (axolotl::LocalKey const &) value); pos = olm::pickle(pos, (olm::LocalKey const &) value);
pos = axolotl::pickle_bytes(pos, value.signature, 64); pos = olm::pickle_bytes(pos, value.signature, 64);
return pos; return pos;
} }
static std::uint8_t const * unpickle( static std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::SignedKey & value olm::SignedKey & value
) { ) {
pos = axolotl::unpickle(pos, end, (axolotl::LocalKey &) value); pos = olm::unpickle(pos, end, (olm::LocalKey &) value);
pos = axolotl::unpickle_bytes(pos, end, value.signature, 64); pos = olm::unpickle_bytes(pos, end, value.signature, 64);
return pos; return pos;
} }
} // namespace axolotl } // namespace olm
std::size_t axolotl::pickle_length( std::size_t olm::pickle_length(
axolotl::Account const & value olm::Account const & value
) { ) {
std::size_t length = 0; std::size_t length = 0;
length += axolotl::pickle_length(value.identity_key); length += olm::pickle_length(value.identity_key);
length += axolotl::pickle_length(value.last_resort_one_time_key); length += olm::pickle_length(value.last_resort_one_time_key);
length += axolotl::pickle_length(value.one_time_keys); length += olm::pickle_length(value.one_time_keys);
return length; return length;
} }
std::uint8_t * axolotl::pickle( std::uint8_t * olm::pickle(
std::uint8_t * pos, std::uint8_t * pos,
axolotl::Account const & value olm::Account const & value
) { ) {
pos = axolotl::pickle(pos, value.identity_key); pos = olm::pickle(pos, value.identity_key);
pos = axolotl::pickle(pos, value.last_resort_one_time_key); pos = olm::pickle(pos, value.last_resort_one_time_key);
pos = axolotl::pickle(pos, value.one_time_keys); pos = olm::pickle(pos, value.one_time_keys);
return pos; return pos;
} }
std::uint8_t const * axolotl::unpickle( std::uint8_t const * olm::unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::Account & value olm::Account & value
) { ) {
pos = axolotl::unpickle(pos, end, value.identity_key); pos = olm::unpickle(pos, end, value.identity_key);
pos = axolotl::unpickle(pos, end, value.last_resort_one_time_key); pos = olm::unpickle(pos, end, value.last_resort_one_time_key);
pos = axolotl::unpickle(pos, end, value.one_time_keys); pos = olm::unpickle(pos, end, value.one_time_keys);
return pos; return pos;
} }

10
src/base64.cpp
View file

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/base64.hh" #include "olm/base64.hh"
namespace { namespace {
@ -45,14 +45,14 @@ static const std::uint8_t DECODE_BASE64[128] = {
} // namespace } // namespace
std::size_t axolotl::encode_base64_length( std::size_t olm::encode_base64_length(
std::size_t input_length std::size_t input_length
) { ) {
return 4 * ((input_length + 2) / 3) + (input_length + 2) % 3 - 2; return 4 * ((input_length + 2) / 3) + (input_length + 2) % 3 - 2;
} }
void axolotl::encode_base64( void olm::encode_base64(
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * output std::uint8_t * output
) { ) {
@ -87,7 +87,7 @@ void axolotl::encode_base64(
} }
std::size_t axolotl::decode_base64_length( std::size_t olm::decode_base64_length(
std::size_t input_length std::size_t input_length
) { ) {
if (input_length % 4 == 1) { if (input_length % 4 == 1) {
@ -98,7 +98,7 @@ std::size_t axolotl::decode_base64_length(
} }
void axolotl::decode_base64( void olm::decode_base64(
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * output std::uint8_t * output
) { ) {

46
src/cipher.cpp
View file

@ -12,12 +12,12 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/cipher.hh" #include "olm/cipher.hh"
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include "axolotl/memory.hh" #include "olm/memory.hh"
#include <cstring> #include <cstring>
axolotl::Cipher::~Cipher() { olm::Cipher::~Cipher() {
} }
@ -26,9 +26,9 @@ namespace {
static const std::size_t SHA256_LENGTH = 32; static const std::size_t SHA256_LENGTH = 32;
struct DerivedKeys { struct DerivedKeys {
axolotl::Aes256Key aes_key; olm::Aes256Key aes_key;
std::uint8_t mac_key[SHA256_LENGTH]; std::uint8_t mac_key[SHA256_LENGTH];
axolotl::Aes256Iv aes_iv; olm::Aes256Iv aes_iv;
}; };
@ -38,7 +38,7 @@ static void derive_keys(
DerivedKeys & keys DerivedKeys & keys
) { ) {
std::uint8_t derived_secrets[80]; std::uint8_t derived_secrets[80];
axolotl::hkdf_sha256( olm::hkdf_sha256(
key, key_length, key, key_length,
nullptr, 0, nullptr, 0,
kdf_info, kdf_info_length, kdf_info, kdf_info_length,
@ -47,7 +47,7 @@ static void derive_keys(
std::memcpy(keys.aes_key.key, derived_secrets, 32); std::memcpy(keys.aes_key.key, derived_secrets, 32);
std::memcpy(keys.mac_key, derived_secrets + 32, 32); std::memcpy(keys.mac_key, derived_secrets + 32, 32);
std::memcpy(keys.aes_iv.iv, derived_secrets + 64, 16); std::memcpy(keys.aes_iv.iv, derived_secrets + 64, 16);
axolotl::unset(derived_secrets); olm::unset(derived_secrets);
} }
static const std::size_t MAC_LENGTH = 8; static const std::size_t MAC_LENGTH = 8;
@ -55,26 +55,26 @@ static const std::size_t MAC_LENGTH = 8;
} // namespace } // namespace
axolotl::CipherAesSha256::CipherAesSha256( olm::CipherAesSha256::CipherAesSha256(
std::uint8_t const * kdf_info, std::size_t kdf_info_length std::uint8_t const * kdf_info, std::size_t kdf_info_length
) : kdf_info(kdf_info), kdf_info_length(kdf_info_length) { ) : kdf_info(kdf_info), kdf_info_length(kdf_info_length) {
} }
std::size_t axolotl::CipherAesSha256::mac_length() const { std::size_t olm::CipherAesSha256::mac_length() const {
return MAC_LENGTH; return MAC_LENGTH;
} }
std::size_t axolotl::CipherAesSha256::encrypt_ciphertext_length( std::size_t olm::CipherAesSha256::encrypt_ciphertext_length(
std::size_t plaintext_length std::size_t plaintext_length
) const { ) const {
return axolotl::aes_encrypt_cbc_length(plaintext_length); return olm::aes_encrypt_cbc_length(plaintext_length);
} }
std::size_t axolotl::CipherAesSha256::encrypt( std::size_t olm::CipherAesSha256::encrypt(
std::uint8_t const * key, std::size_t key_length, std::uint8_t const * key, std::size_t key_length,
std::uint8_t const * plaintext, std::size_t plaintext_length, std::uint8_t const * plaintext, std::size_t plaintext_length,
std::uint8_t * ciphertext, std::size_t ciphertext_length, std::uint8_t * ciphertext, std::size_t ciphertext_length,
@ -88,28 +88,28 @@ std::size_t axolotl::CipherAesSha256::encrypt(
derive_keys(kdf_info, kdf_info_length, key, key_length, keys); derive_keys(kdf_info, kdf_info_length, key, key_length, keys);
axolotl::aes_encrypt_cbc( olm::aes_encrypt_cbc(
keys.aes_key, keys.aes_iv, plaintext, plaintext_length, ciphertext keys.aes_key, keys.aes_iv, plaintext, plaintext_length, ciphertext
); );
axolotl::hmac_sha256( olm::hmac_sha256(
keys.mac_key, SHA256_LENGTH, output, output_length - MAC_LENGTH, mac keys.mac_key, SHA256_LENGTH, output, output_length - MAC_LENGTH, mac
); );
std::memcpy(output + output_length - MAC_LENGTH, mac, MAC_LENGTH); std::memcpy(output + output_length - MAC_LENGTH, mac, MAC_LENGTH);
axolotl::unset(keys); olm::unset(keys);
return output_length; return output_length;
} }
std::size_t axolotl::CipherAesSha256::decrypt_max_plaintext_length( std::size_t olm::CipherAesSha256::decrypt_max_plaintext_length(
std::size_t ciphertext_length std::size_t ciphertext_length
) const { ) const {
return ciphertext_length; return ciphertext_length;
} }
std::size_t axolotl::CipherAesSha256::decrypt( std::size_t olm::CipherAesSha256::decrypt(
std::uint8_t const * key, std::size_t key_length, std::uint8_t const * key, std::size_t key_length,
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t const * ciphertext, std::size_t ciphertext_length, std::uint8_t const * ciphertext, std::size_t ciphertext_length,
@ -120,20 +120,20 @@ std::size_t axolotl::CipherAesSha256::decrypt(
derive_keys(kdf_info, kdf_info_length, key, key_length, keys); derive_keys(kdf_info, kdf_info_length, key, key_length, keys);
axolotl::hmac_sha256( olm::hmac_sha256(
keys.mac_key, SHA256_LENGTH, input, input_length - MAC_LENGTH, mac keys.mac_key, SHA256_LENGTH, input, input_length - MAC_LENGTH, mac
); );
std::uint8_t const * input_mac = input + input_length - MAC_LENGTH; std::uint8_t const * input_mac = input + input_length - MAC_LENGTH;
if (!axolotl::is_equal(input_mac, mac, MAC_LENGTH)) { if (!olm::is_equal(input_mac, mac, MAC_LENGTH)) {
axolotl::unset(keys); olm::unset(keys);
return std::size_t(-1); return std::size_t(-1);
} }
std::size_t plaintext_length = axolotl::aes_decrypt_cbc( std::size_t plaintext_length = olm::aes_decrypt_cbc(
keys.aes_key, keys.aes_iv, ciphertext, ciphertext_length, plaintext keys.aes_key, keys.aes_iv, ciphertext, ciphertext_length, plaintext
); );
axolotl::unset(keys); olm::unset(keys);
return plaintext_length; return plaintext_length;
} }

70
src/crypto.cpp
View file

@ -12,8 +12,8 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include "axolotl/memory.hh" #include "olm/memory.hh"
#include <cstring> #include <cstring>
@ -110,7 +110,7 @@ inline void hmac_sha256_init(
} }
::sha256_init(context); ::sha256_init(context);
::sha256_update(context, i_pad, SHA256_BLOCK_LENGTH); ::sha256_update(context, i_pad, SHA256_BLOCK_LENGTH);
axolotl::unset(i_pad); olm::unset(i_pad);
} }
@ -129,16 +129,16 @@ inline void hmac_sha256_final(
::sha256_init(&final_context); ::sha256_init(&final_context);
::sha256_update(&final_context, o_pad, sizeof(o_pad)); ::sha256_update(&final_context, o_pad, sizeof(o_pad));
::sha256_final(&final_context, output); ::sha256_final(&final_context, output);
axolotl::unset(final_context); olm::unset(final_context);
axolotl::unset(o_pad); olm::unset(o_pad);
} }
} // namespace } // namespace
void axolotl::generate_key( void olm::generate_key(
std::uint8_t const * random_32_bytes, std::uint8_t const * random_32_bytes,
axolotl::Curve25519KeyPair & key_pair olm::Curve25519KeyPair & key_pair
) { ) {
std::memcpy(key_pair.private_key, random_32_bytes, 32); std::memcpy(key_pair.private_key, random_32_bytes, 32);
::curve25519_donna( ::curve25519_donna(
@ -147,17 +147,17 @@ void axolotl::generate_key(
} }
void axolotl::curve25519_shared_secret( void olm::curve25519_shared_secret(
axolotl::Curve25519KeyPair const & our_key, olm::Curve25519KeyPair const & our_key,
axolotl::Curve25519PublicKey const & their_key, olm::Curve25519PublicKey const & their_key,
std::uint8_t * output std::uint8_t * output
) { ) {
::curve25519_donna(output, our_key.private_key, their_key.public_key); ::curve25519_donna(output, our_key.private_key, their_key.public_key);
} }
void axolotl::curve25519_sign( void olm::curve25519_sign(
axolotl::Curve25519KeyPair const & our_key, olm::Curve25519KeyPair const & our_key,
std::uint8_t const * message, std::size_t message_length, std::uint8_t const * message, std::size_t message_length,
std::uint8_t * output std::uint8_t * output
) { ) {
@ -174,8 +174,8 @@ void axolotl::curve25519_sign(
} }
bool axolotl::curve25519_verify( bool olm::curve25519_verify(
axolotl::Curve25519PublicKey const & their_key, olm::Curve25519PublicKey const & their_key,
std::uint8_t const * message, std::size_t message_length, std::uint8_t const * message, std::size_t message_length,
std::uint8_t const * signature std::uint8_t const * signature
) { ) {
@ -191,16 +191,16 @@ bool axolotl::curve25519_verify(
); );
} }
std::size_t axolotl::aes_encrypt_cbc_length( std::size_t olm::aes_encrypt_cbc_length(
std::size_t input_length std::size_t input_length
) { ) {
return input_length + AES_BLOCK_LENGTH - input_length % AES_BLOCK_LENGTH; return input_length + AES_BLOCK_LENGTH - input_length % AES_BLOCK_LENGTH;
} }
void axolotl::aes_encrypt_cbc( void olm::aes_encrypt_cbc(
axolotl::Aes256Key const & key, olm::Aes256Key const & key,
axolotl::Aes256Iv const & iv, olm::Aes256Iv const & iv,
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * output std::uint8_t * output
) { ) {
@ -224,14 +224,14 @@ void axolotl::aes_encrypt_cbc(
input_block[i] ^= AES_BLOCK_LENGTH - input_length; input_block[i] ^= AES_BLOCK_LENGTH - input_length;
} }
::aes_encrypt(input_block, output, key_schedule, 256); ::aes_encrypt(input_block, output, key_schedule, 256);
axolotl::unset(key_schedule); olm::unset(key_schedule);
axolotl::unset(input_block); olm::unset(input_block);
} }
std::size_t axolotl::aes_decrypt_cbc( std::size_t olm::aes_decrypt_cbc(
axolotl::Aes256Key const & key, olm::Aes256Key const & key,
axolotl::Aes256Iv const & iv, olm::Aes256Iv const & iv,
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * output std::uint8_t * output
) { ) {
@ -246,15 +246,15 @@ std::size_t axolotl::aes_decrypt_cbc(
xor_block<AES_BLOCK_LENGTH>(&output[i], block1); xor_block<AES_BLOCK_LENGTH>(&output[i], block1);
std::memcpy(block1, block2, AES_BLOCK_LENGTH); std::memcpy(block1, block2, AES_BLOCK_LENGTH);
} }
axolotl::unset(key_schedule); olm::unset(key_schedule);
axolotl::unset(block1); olm::unset(block1);
axolotl::unset(block2); olm::unset(block2);
std::size_t padding = output[input_length - 1]; std::size_t padding = output[input_length - 1];
return (padding > input_length) ? std::size_t(-1) : (input_length - padding); return (padding > input_length) ? std::size_t(-1) : (input_length - padding);
} }
void axolotl::sha256( void olm::sha256(
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * output std::uint8_t * output
) { ) {
@ -262,10 +262,10 @@ void axolotl::sha256(
::sha256_init(&context); ::sha256_init(&context);
::sha256_update(&context, input, input_length); ::sha256_update(&context, input, input_length);
::sha256_final(&context, output); ::sha256_final(&context, output);
axolotl::unset(context); olm::unset(context);
} }
void axolotl::hmac_sha256( void olm::hmac_sha256(
std::uint8_t const * key, std::size_t key_length, std::uint8_t const * key, std::size_t key_length,
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * output std::uint8_t * output
@ -276,12 +276,12 @@ void axolotl::hmac_sha256(
hmac_sha256_init(&context, hmac_key); hmac_sha256_init(&context, hmac_key);
::sha256_update(&context, input, input_length); ::sha256_update(&context, input, input_length);
hmac_sha256_final(&context, hmac_key, output); hmac_sha256_final(&context, hmac_key, output);
axolotl::unset(hmac_key); olm::unset(hmac_key);
axolotl::unset(context); olm::unset(context);
} }
void axolotl::hkdf_sha256( void olm::hkdf_sha256(
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t const * salt, std::size_t salt_length, std::uint8_t const * salt, std::size_t salt_length,
std::uint8_t const * info, std::size_t info_length, std::uint8_t const * info, std::size_t info_length,
@ -320,7 +320,7 @@ void axolotl::hkdf_sha256(
hmac_sha256_final(&context, hmac_key, step_result); hmac_sha256_final(&context, hmac_key, step_result);
} }
std::memcpy(output, step_result, bytes_remaining); std::memcpy(output, step_result, bytes_remaining);
axolotl::unset(context); olm::unset(context);
axolotl::unset(hmac_key); olm::unset(hmac_key);
axolotl::unset(step_result); olm::unset(step_result);
} }

6
src/memory.cpp
View file

@ -12,10 +12,10 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/memory.hh" #include "olm/memory.hh"
void axolotl::unset( void olm::unset(
void volatile * buffer, std::size_t buffer_length void volatile * buffer, std::size_t buffer_length
) { ) {
char volatile * pos = reinterpret_cast<char volatile *>(buffer); char volatile * pos = reinterpret_cast<char volatile *>(buffer);
@ -26,7 +26,7 @@ void axolotl::unset(
} }
bool axolotl::is_equal( bool olm::is_equal(
std::uint8_t const * buffer_a, std::uint8_t const * buffer_a,
std::uint8_t const * buffer_b, std::uint8_t const * buffer_b,
std::size_t length std::size_t length

20
src/message.cpp
View file

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/message.hh" #include "olm/message.hh"
namespace { namespace {
@ -161,7 +161,7 @@ std::uint8_t const * skip_unknown(
} // namespace } // namespace
std::size_t axolotl::encode_message_length( std::size_t olm::encode_message_length(
std::uint32_t counter, std::uint32_t counter,
std::size_t ratchet_key_length, std::size_t ratchet_key_length,
std::size_t ciphertext_length, std::size_t ciphertext_length,
@ -176,8 +176,8 @@ std::size_t axolotl::encode_message_length(
} }
void axolotl::encode_message( void olm::encode_message(
axolotl::MessageWriter & writer, olm::MessageWriter & writer,
std::uint8_t version, std::uint8_t version,
std::uint32_t counter, std::uint32_t counter,
std::size_t ratchet_key_length, std::size_t ratchet_key_length,
@ -192,8 +192,8 @@ void axolotl::encode_message(
} }
void axolotl::decode_message( void olm::decode_message(
axolotl::MessageReader & reader, olm::MessageReader & reader,
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::size_t mac_length std::size_t mac_length
) { ) {
@ -240,7 +240,7 @@ static std::uint8_t const MESSAGE_TAG = 042;
} // namespace } // namespace
std::size_t axolotl::encode_one_time_key_message_length( std::size_t olm::encode_one_time_key_message_length(
std::uint32_t one_time_key_id, std::uint32_t one_time_key_id,
std::size_t identity_key_length, std::size_t identity_key_length,
std::size_t base_key_length, std::size_t base_key_length,
@ -255,8 +255,8 @@ std::size_t axolotl::encode_one_time_key_message_length(
} }
void axolotl::encode_one_time_key_message( void olm::encode_one_time_key_message(
axolotl::PreKeyMessageWriter & writer, olm::PreKeyMessageWriter & writer,
std::uint8_t version, std::uint8_t version,
std::uint32_t one_time_key_id, std::uint32_t one_time_key_id,
std::size_t identity_key_length, std::size_t identity_key_length,
@ -273,7 +273,7 @@ void axolotl::encode_one_time_key_message(
} }
void axolotl::decode_one_time_key_message( void olm::decode_one_time_key_message(
PreKeyMessageReader & reader, PreKeyMessageReader & reader,
std::uint8_t const * input, std::size_t input_length std::uint8_t const * input, std::size_t input_length
) { ) {

234
src/axolotl.cpp → src/olm.cpp
View file

@ -12,31 +12,31 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/axolotl.hh" #include "olm/olm.hh"
#include "axolotl/session.hh" #include "olm/session.hh"
#include "axolotl/account.hh" #include "olm/account.hh"
#include "axolotl/base64.hh" #include "olm/base64.hh"
#include "axolotl/cipher.hh" #include "olm/cipher.hh"
#include <new> #include <new>
#include <cstring> #include <cstring>
namespace { namespace {
static AxolotlAccount * to_c(axolotl::Account * account) { static OlmAccount * to_c(olm::Account * account) {
return reinterpret_cast<AxolotlAccount *>(account); return reinterpret_cast<OlmAccount *>(account);
} }
static AxolotlSession * to_c(axolotl::Session * account) { static OlmSession * to_c(olm::Session * account) {
return reinterpret_cast<AxolotlSession *>(account); return reinterpret_cast<OlmSession *>(account);
} }
static axolotl::Account * from_c(AxolotlAccount * account) { static olm::Account * from_c(OlmAccount * account) {
return reinterpret_cast<axolotl::Account *>(account); return reinterpret_cast<olm::Account *>(account);
} }
static axolotl::Session * from_c(AxolotlSession * account) { static olm::Session * from_c(OlmSession * account) {
return reinterpret_cast<axolotl::Session *>(account); return reinterpret_cast<olm::Session *>(account);
} }
static std::uint8_t * from_c(void * bytes) { static std::uint8_t * from_c(void * bytes) {
@ -49,7 +49,7 @@ static std::uint8_t const * from_c(void const * bytes) {
static const std::uint8_t CIPHER_KDF_INFO[] = "Pickle"; static const std::uint8_t CIPHER_KDF_INFO[] = "Pickle";
static const axolotl::CipherAesSha256 PICKLE_CIPHER( static const olm::CipherAesSha256 PICKLE_CIPHER(
CIPHER_KDF_INFO, sizeof(CIPHER_KDF_INFO) -1 CIPHER_KDF_INFO, sizeof(CIPHER_KDF_INFO) -1
); );
@ -58,7 +58,7 @@ std::size_t enc_output_length(
) { ) {
std::size_t length = PICKLE_CIPHER.encrypt_ciphertext_length(raw_length); std::size_t length = PICKLE_CIPHER.encrypt_ciphertext_length(raw_length);
length += PICKLE_CIPHER.mac_length(); length += PICKLE_CIPHER.mac_length();
return axolotl::encode_base64_length(length); return olm::encode_base64_length(length);
} }
@ -68,7 +68,7 @@ std::uint8_t * enc_output_pos(
) { ) {
std::size_t length = PICKLE_CIPHER.encrypt_ciphertext_length(raw_length); std::size_t length = PICKLE_CIPHER.encrypt_ciphertext_length(raw_length);
length += PICKLE_CIPHER.mac_length(); length += PICKLE_CIPHER.mac_length();
return output + axolotl::encode_base64_length(length) - length; return output + olm::encode_base64_length(length) - length;
} }
std::size_t enc_output( std::size_t enc_output(
@ -79,7 +79,7 @@ std::size_t enc_output(
raw_length raw_length
); );
std::size_t length = ciphertext_length + PICKLE_CIPHER.mac_length(); std::size_t length = ciphertext_length + PICKLE_CIPHER.mac_length();
std::size_t base64_length = axolotl::encode_base64_length(length); std::size_t base64_length = olm::encode_base64_length(length);
std::uint8_t * raw_output = output + base64_length - length; std::uint8_t * raw_output = output + base64_length - length;
PICKLE_CIPHER.encrypt( PICKLE_CIPHER.encrypt(
key, key_length, key, key_length,
@ -87,21 +87,21 @@ std::size_t enc_output(
raw_output, ciphertext_length, raw_output, ciphertext_length,
raw_output, length raw_output, length
); );
axolotl::encode_base64(raw_output, length, output); olm::encode_base64(raw_output, length, output);
return raw_length; return raw_length;
} }
std::size_t enc_input( std::size_t enc_input(
std::uint8_t const * key, std::size_t key_length, std::uint8_t const * key, std::size_t key_length,
std::uint8_t * input, size_t b64_length, std::uint8_t * input, size_t b64_length,
axolotl::ErrorCode & last_error olm::ErrorCode & last_error
) { ) {
std::size_t enc_length = axolotl::decode_base64_length(b64_length); std::size_t enc_length = olm::decode_base64_length(b64_length);
if (enc_length == std::size_t(-1)) { if (enc_length == std::size_t(-1)) {
last_error = axolotl::ErrorCode::INVALID_BASE64; last_error = olm::ErrorCode::INVALID_BASE64;
return std::size_t(-1); return std::size_t(-1);
} }
axolotl::decode_base64(input, b64_length, input); olm::decode_base64(input, b64_length, input);
std::size_t raw_length = enc_length - PICKLE_CIPHER.mac_length(); std::size_t raw_length = enc_length - PICKLE_CIPHER.mac_length();
std::size_t result = PICKLE_CIPHER.decrypt( std::size_t result = PICKLE_CIPHER.decrypt(
key, key_length, key, key_length,
@ -110,7 +110,7 @@ std::size_t enc_input(
input, raw_length input, raw_length
); );
if (result == std::size_t(-1)) { if (result == std::size_t(-1)) {
last_error = axolotl::ErrorCode::BAD_ACCOUNT_KEY; last_error = olm::ErrorCode::BAD_ACCOUNT_KEY;
} }
return result; return result;
} }
@ -119,35 +119,35 @@ std::size_t enc_input(
std::size_t b64_output_length( std::size_t b64_output_length(
size_t raw_length size_t raw_length
) { ) {
return axolotl::encode_base64_length(raw_length); return olm::encode_base64_length(raw_length);
} }
std::uint8_t * b64_output_pos( std::uint8_t * b64_output_pos(
std::uint8_t * output, std::uint8_t * output,
size_t raw_length size_t raw_length
) { ) {
return output + axolotl::encode_base64_length(raw_length) - raw_length; return output + olm::encode_base64_length(raw_length) - raw_length;
} }
std::size_t b64_output( std::size_t b64_output(
std::uint8_t * output, size_t raw_length std::uint8_t * output, size_t raw_length
) { ) {
std::size_t base64_length = axolotl::encode_base64_length(raw_length); std::size_t base64_length = olm::encode_base64_length(raw_length);
std::uint8_t * raw_output = output + base64_length - raw_length; std::uint8_t * raw_output = output + base64_length - raw_length;
axolotl::encode_base64(raw_output, raw_length, output); olm::encode_base64(raw_output, raw_length, output);
return base64_length; return base64_length;
} }
std::size_t b64_input( std::size_t b64_input(
std::uint8_t * input, size_t b64_length, std::uint8_t * input, size_t b64_length,
axolotl::ErrorCode & last_error olm::ErrorCode & last_error
) { ) {
std::size_t raw_length = axolotl::decode_base64_length(b64_length); std::size_t raw_length = olm::decode_base64_length(b64_length);
if (raw_length == std::size_t(-1)) { if (raw_length == std::size_t(-1)) {
last_error = axolotl::ErrorCode::INVALID_BASE64; last_error = olm::ErrorCode::INVALID_BASE64;
return std::size_t(-1); return std::size_t(-1);
} }
axolotl::decode_base64(input, b64_length, input); olm::decode_base64(input, b64_length, input);
return raw_length; return raw_length;
} }
@ -169,13 +169,13 @@ const char * errors[9] {
extern "C" { extern "C" {
size_t axolotl_error() { size_t olm_error() {
return std::size_t(-1); return std::size_t(-1);
} }
const char * axolotl_account_last_error( const char * olm_account_last_error(
AxolotlSession * account OlmSession * account
) { ) {
unsigned error = unsigned(from_c(account)->last_error); unsigned error = unsigned(from_c(account)->last_error);
if (error < 9) { if (error < 9) {
@ -186,8 +186,8 @@ const char * axolotl_account_last_error(
} }
const char * axolotl_session_last_error( const char * olm_session_last_error(
AxolotlSession * session OlmSession * session
) { ) {
unsigned error = unsigned(from_c(session)->last_error); unsigned error = unsigned(from_c(session)->last_error);
if (error < 9) { if (error < 9) {
@ -198,53 +198,53 @@ const char * axolotl_session_last_error(
} }
size_t axolotl_account_size() { size_t olm_account_size() {
return sizeof(axolotl::Account); return sizeof(olm::Account);
} }
size_t axolotl_session_size() { size_t olm_session_size() {
return sizeof(axolotl::Session); return sizeof(olm::Session);
} }
AxolotlAccount * axolotl_account( OlmAccount * olm_account(
void * memory void * memory
) { ) {
return to_c(new(memory) axolotl::Account()); return to_c(new(memory) olm::Account());
} }
AxolotlSession * axolotl_session( OlmSession * olm_session(
void * memory void * memory
) { ) {
return to_c(new(memory) axolotl::Session()); return to_c(new(memory) olm::Session());
} }
size_t axolotl_pickle_account_length( size_t olm_pickle_account_length(
AxolotlAccount * account OlmAccount * account
) { ) {
return enc_output_length(pickle_length(*from_c(account))); return enc_output_length(pickle_length(*from_c(account)));
} }
size_t axolotl_pickle_session_length( size_t olm_pickle_session_length(
AxolotlSession * session OlmSession * session
) { ) {
return enc_output_length(pickle_length(*from_c(session))); return enc_output_length(pickle_length(*from_c(session)));
} }
size_t axolotl_pickle_account( size_t olm_pickle_account(
AxolotlAccount * account, OlmAccount * account,
void const * key, size_t key_length, void const * key, size_t key_length,
void * pickled, size_t pickled_length void * pickled, size_t pickled_length
) { ) {
axolotl::Account & object = *from_c(account); olm::Account & object = *from_c(account);
std::size_t raw_length = pickle_length(object); std::size_t raw_length = pickle_length(object);
if (pickled_length < enc_output_length(raw_length)) { if (pickled_length < enc_output_length(raw_length)) {
object.last_error = axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; object.last_error = olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return size_t(-1); return size_t(-1);
} }
pickle(enc_output_pos(from_c(pickled), raw_length), object); pickle(enc_output_pos(from_c(pickled), raw_length), object);
@ -252,15 +252,15 @@ size_t axolotl_pickle_account(
} }
size_t axolotl_pickle_session( size_t olm_pickle_session(
AxolotlSession * session, OlmSession * session,
void const * key, size_t key_length, void const * key, size_t key_length,
void * pickled, size_t pickled_length void * pickled, size_t pickled_length
) { ) {
axolotl::Session & object = *from_c(session); olm::Session & object = *from_c(session);
std::size_t raw_length = pickle_length(object); std::size_t raw_length = pickle_length(object);
if (pickled_length < enc_output_length(raw_length)) { if (pickled_length < enc_output_length(raw_length)) {
object.last_error = axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; object.last_error = olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return size_t(-1); return size_t(-1);
} }
pickle(enc_output_pos(from_c(pickled), raw_length), object); pickle(enc_output_pos(from_c(pickled), raw_length), object);
@ -268,12 +268,12 @@ size_t axolotl_pickle_session(
} }
size_t axolotl_unpickle_account( size_t olm_unpickle_account(
AxolotlAccount * account, OlmAccount * account,
void const * key, size_t key_length, void const * key, size_t key_length,
void * pickled, size_t pickled_length void * pickled, size_t pickled_length
) { ) {
axolotl::Account & object = *from_c(account); olm::Account & object = *from_c(account);
std::uint8_t * const pos = from_c(pickled); std::uint8_t * const pos = from_c(pickled);
std::size_t raw_length = enc_input( std::size_t raw_length = enc_input(
from_c(key), key_length, pos, pickled_length, object.last_error from_c(key), key_length, pos, pickled_length, object.last_error
@ -287,12 +287,12 @@ size_t axolotl_unpickle_account(
} }
size_t axolotl_unpickle_session( size_t olm_unpickle_session(
AxolotlSession * session, OlmSession * session,
void const * key, size_t key_length, void const * key, size_t key_length,
void * pickled, size_t pickled_length void * pickled, size_t pickled_length
) { ) {
axolotl::Session & object = *from_c(session); olm::Session & object = *from_c(session);
std::uint8_t * const pos = from_c(pickled); std::uint8_t * const pos = from_c(pickled);
std::size_t raw_length = enc_input( std::size_t raw_length = enc_input(
from_c(key), key_length, pos, pickled_length, object.last_error from_c(key), key_length, pos, pickled_length, object.last_error
@ -306,15 +306,15 @@ size_t axolotl_unpickle_session(
} }
size_t axolotl_create_account_random_length( size_t olm_create_account_random_length(
AxolotlAccount * account OlmAccount * account
) { ) {
return from_c(account)->new_account_random_length(); return from_c(account)->new_account_random_length();
} }
size_t axolotl_create_account( size_t olm_create_account(
AxolotlAccount * account, OlmAccount * account,
void const * random, size_t random_length void const * random, size_t random_length
) { ) {
return from_c(account)->new_account(from_c(random), random_length); return from_c(account)->new_account(from_c(random), random_length);
@ -323,10 +323,10 @@ size_t axolotl_create_account(
namespace { namespace {
static const std::size_t OUTPUT_KEY_LENGTH = 2 + 10 + 2 + static const std::size_t OUTPUT_KEY_LENGTH = 2 + 10 + 2 +
axolotl::encode_base64_length(32) + 3; olm::encode_base64_length(32) + 3;
void output_key( void output_key(
axolotl::LocalKey const & key, olm::LocalKey const & key,
std::uint8_t sep, std::uint8_t sep,
std::uint8_t * output std::uint8_t * output
) { ) {
@ -343,7 +343,7 @@ void output_key(
} }
output[12] = ','; output[12] = ',';
output[13] = '"'; output[13] = '"';
axolotl::encode_base64(key.key.public_key, 32, output + 14); olm::encode_base64(key.key.public_key, 32, output + 14);
output[OUTPUT_KEY_LENGTH - 3] = '"'; output[OUTPUT_KEY_LENGTH - 3] = '"';
output[OUTPUT_KEY_LENGTH - 2] = ']'; output[OUTPUT_KEY_LENGTH - 2] = ']';
output[OUTPUT_KEY_LENGTH - 1] = '\n'; output[OUTPUT_KEY_LENGTH - 1] = '\n';
@ -352,21 +352,21 @@ void output_key(
} // namespace } // namespace
size_t axolotl_account_identity_keys_length( size_t olm_account_identity_keys_length(
AxolotlAccount * account OlmAccount * account
) { ) {
return OUTPUT_KEY_LENGTH + 1; return OUTPUT_KEY_LENGTH + 1;
} }
size_t axolotl_account_identity_keys( size_t olm_account_identity_keys(
AxolotlAccount * account, OlmAccount * account,
void * identity_keys, size_t identity_key_length void * identity_keys, size_t identity_key_length
) { ) {
std::size_t length = axolotl_account_identity_keys_length(account); std::size_t length = olm_account_identity_keys_length(account);
if (identity_key_length < length) { if (identity_key_length < length) {
from_c(account)->last_error = from_c(account)->last_error =
axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return size_t(-1); return size_t(-1);
} }
std::uint8_t * output = from_c(identity_keys); std::uint8_t * output = from_c(identity_keys);
@ -377,22 +377,22 @@ size_t axolotl_account_identity_keys(
} }
size_t axolotl_account_one_time_keys_length( size_t olm_account_one_time_keys_length(
AxolotlAccount * account OlmAccount * account
) { ) {
size_t count = from_c(account)->one_time_keys.size(); size_t count = from_c(account)->one_time_keys.size();
return OUTPUT_KEY_LENGTH * (count + 1) + 1; return OUTPUT_KEY_LENGTH * (count + 1) + 1;
} }
size_t axolotl_account_one_time_keys( size_t olm_account_one_time_keys(
AxolotlAccount * account, OlmAccount * account,
void * identity_keys, size_t identity_key_length void * identity_keys, size_t identity_key_length
) { ) {
std::size_t length = axolotl_account_one_time_keys_length(account); std::size_t length = olm_account_one_time_keys_length(account);
if (identity_key_length < length) { if (identity_key_length < length) {
from_c(account)->last_error = from_c(account)->last_error =
axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return size_t(-1); return size_t(-1);
} }
std::uint8_t * output = from_c(identity_keys); std::uint8_t * output = from_c(identity_keys);
@ -407,35 +407,35 @@ size_t axolotl_account_one_time_keys(
} }
size_t axolotl_create_outbound_session_random_length( size_t olm_create_outbound_session_random_length(
AxolotlSession * session OlmSession * session
) { ) {
return from_c(session)->new_outbound_session_random_length(); return from_c(session)->new_outbound_session_random_length();
} }
size_t axolotl_create_outbound_session( size_t olm_create_outbound_session(
AxolotlSession * session, OlmSession * session,
AxolotlAccount * account, OlmAccount * account,
void const * their_identity_key, size_t their_identity_key_length, void const * their_identity_key, size_t their_identity_key_length,
unsigned their_one_time_key_id, unsigned their_one_time_key_id,
void const * their_one_time_key, size_t their_one_time_key_length, void const * their_one_time_key, size_t their_one_time_key_length,
void const * random, size_t random_length void const * random, size_t random_length
) { ) {
if (axolotl::decode_base64_length(their_identity_key_length) != 32 if (olm::decode_base64_length(their_identity_key_length) != 32
|| axolotl::decode_base64_length(their_one_time_key_length) != 32 || olm::decode_base64_length(their_one_time_key_length) != 32
) { ) {
from_c(session)->last_error = axolotl::ErrorCode::INVALID_BASE64; from_c(session)->last_error = olm::ErrorCode::INVALID_BASE64;
return std::size_t(-1); return std::size_t(-1);
} }
axolotl::Curve25519PublicKey identity_key; olm::Curve25519PublicKey identity_key;
axolotl::RemoteKey one_time_key; olm::RemoteKey one_time_key;
axolotl::decode_base64( olm::decode_base64(
from_c(their_identity_key), their_identity_key_length, from_c(their_identity_key), their_identity_key_length,
identity_key.public_key identity_key.public_key
); );
one_time_key.id = their_one_time_key_id; one_time_key.id = their_one_time_key_id;
axolotl::decode_base64( olm::decode_base64(
from_c(their_one_time_key), their_one_time_key_length, from_c(their_one_time_key), their_one_time_key_length,
one_time_key.key.public_key one_time_key.key.public_key
); );
@ -447,9 +447,9 @@ size_t axolotl_create_outbound_session(
} }
size_t axolotl_create_inbound_session( size_t olm_create_inbound_session(
AxolotlSession * session, OlmSession * session,
AxolotlAccount * account, OlmAccount * account,
void * one_time_key_message, size_t message_length void * one_time_key_message, size_t message_length
) { ) {
std::size_t raw_length = b64_input( std::size_t raw_length = b64_input(
@ -464,8 +464,8 @@ size_t axolotl_create_inbound_session(
} }
size_t axolotl_matches_inbound_session( size_t olm_matches_inbound_session(
AxolotlSession * session, OlmSession * session,
void * one_time_key_message, size_t message_length void * one_time_key_message, size_t message_length
) { ) {
std::size_t raw_length = b64_input( std::size_t raw_length = b64_input(
@ -481,36 +481,36 @@ size_t axolotl_matches_inbound_session(
} }
size_t axolotl_remove_one_time_keys( size_t olm_remove_one_time_keys(
AxolotlAccount * account, OlmAccount * account,
AxolotlSession * session OlmSession * session
) { ) {
size_t result = from_c(account)->remove_key( size_t result = from_c(account)->remove_key(
from_c(session)->bob_one_time_key_id from_c(session)->bob_one_time_key_id
); );
if (result == std::size_t(-1)) { if (result == std::size_t(-1)) {
from_c(account)->last_error = axolotl::ErrorCode::BAD_MESSAGE_KEY_ID; from_c(account)->last_error = olm::ErrorCode::BAD_MESSAGE_KEY_ID;
} }
return result; return result;
} }
size_t axolotl_encrypt_message_type( size_t olm_encrypt_message_type(
AxolotlSession * session OlmSession * session
) { ) {
return size_t(from_c(session)->encrypt_message_type()); return size_t(from_c(session)->encrypt_message_type());
} }
size_t axolotl_encrypt_random_length( size_t olm_encrypt_random_length(
AxolotlSession * session OlmSession * session
) { ) {
return from_c(session)->encrypt_random_length(); return from_c(session)->encrypt_random_length();
} }
size_t axolotl_encrypt_message_length( size_t olm_encrypt_message_length(
AxolotlSession * session, OlmSession * session,
size_t plaintext_length size_t plaintext_length
) { ) {
return b64_output_length( return b64_output_length(
@ -519,8 +519,8 @@ size_t axolotl_encrypt_message_length(
} }
size_t axolotl_encrypt( size_t olm_encrypt(
AxolotlSession * session, OlmSession * session,
void const * plaintext, size_t plaintext_length, void const * plaintext, size_t plaintext_length,
void const * random, size_t random_length, void const * random, size_t random_length,
void * message, size_t message_length void * message, size_t message_length
@ -530,7 +530,7 @@ size_t axolotl_encrypt(
); );
if (message_length < raw_length) { if (message_length < raw_length) {
from_c(session)->last_error = from_c(session)->last_error =
axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return std::size_t(-1); return std::size_t(-1);
} }
from_c(session)->encrypt( from_c(session)->encrypt(
@ -542,8 +542,8 @@ size_t axolotl_encrypt(
} }
size_t axolotl_decrypt_max_plaintext_length( size_t olm_decrypt_max_plaintext_length(
AxolotlSession * session, OlmSession * session,
size_t message_type, size_t message_type,
void * message, size_t message_length void * message, size_t message_length
) { ) {
@ -554,13 +554,13 @@ size_t axolotl_decrypt_max_plaintext_length(
return std::size_t(-1); return std::size_t(-1);
} }
return from_c(session)->decrypt_max_plaintext_length( return from_c(session)->decrypt_max_plaintext_length(
axolotl::MessageType(message_type), from_c(message), raw_length olm::MessageType(message_type), from_c(message), raw_length
); );
} }
size_t axolotl_decrypt( size_t olm_decrypt(
AxolotlSession * session, OlmSession * session,
size_t message_type, size_t message_type,
void * message, size_t message_length, void * message, size_t message_length,
void * plaintext, size_t max_plaintext_length void * plaintext, size_t max_plaintext_length
@ -572,7 +572,7 @@ size_t axolotl_decrypt(
return std::size_t(-1); return std::size_t(-1);
} }
return from_c(session)->decrypt( return from_c(session)->decrypt(
axolotl::MessageType(message_type), from_c(message), raw_length, olm::MessageType(message_type), from_c(message), raw_length,
from_c(plaintext), max_plaintext_length from_c(plaintext), max_plaintext_length
); );
} }

38
src/pickle.cpp
View file

@ -12,32 +12,32 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/pickle.hh" #include "olm/pickle.hh"
std::size_t axolotl::pickle_length( std::size_t olm::pickle_length(
const axolotl::Curve25519PublicKey & value const olm::Curve25519PublicKey & value
) { ) {
return sizeof(value.public_key); return sizeof(value.public_key);
} }
std::uint8_t * axolotl::pickle( std::uint8_t * olm::pickle(
std::uint8_t * pos, std::uint8_t * pos,
const axolotl::Curve25519PublicKey & value const olm::Curve25519PublicKey & value
) { ) {
pos = axolotl::pickle_bytes( pos = olm::pickle_bytes(
pos, value.public_key, sizeof(value.public_key) pos, value.public_key, sizeof(value.public_key)
); );
return pos; return pos;
} }
std::uint8_t const * axolotl::unpickle( std::uint8_t const * olm::unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::Curve25519PublicKey & value olm::Curve25519PublicKey & value
) { ) {
pos = axolotl::unpickle_bytes( pos = olm::unpickle_bytes(
pos, end, value.public_key, sizeof(value.public_key) pos, end, value.public_key, sizeof(value.public_key)
); );
return pos; return pos;
@ -45,35 +45,35 @@ std::uint8_t const * axolotl::unpickle(
} }
std::size_t axolotl::pickle_length( std::size_t olm::pickle_length(
const axolotl::Curve25519KeyPair & value const olm::Curve25519KeyPair & value
) { ) {
return sizeof(value.public_key) + sizeof(value.private_key); return sizeof(value.public_key) + sizeof(value.private_key);
} }
std::uint8_t * axolotl::pickle( std::uint8_t * olm::pickle(
std::uint8_t * pos, std::uint8_t * pos,
const axolotl::Curve25519KeyPair & value const olm::Curve25519KeyPair & value
) { ) {
pos = axolotl::pickle_bytes( pos = olm::pickle_bytes(
pos, value.public_key, sizeof(value.public_key) pos, value.public_key, sizeof(value.public_key)
); );
pos = axolotl::pickle_bytes( pos = olm::pickle_bytes(
pos, value.private_key, sizeof(value.private_key) pos, value.private_key, sizeof(value.private_key)
); );
return pos; return pos;
} }
std::uint8_t const * axolotl::unpickle( std::uint8_t const * olm::unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::Curve25519KeyPair & value olm::Curve25519KeyPair & value
) { ) {
pos = axolotl::unpickle_bytes( pos = olm::unpickle_bytes(
pos, end, value.public_key, sizeof(value.public_key) pos, end, value.public_key, sizeof(value.public_key)
); );
pos = axolotl::unpickle_bytes( pos = olm::unpickle_bytes(
pos, end, value.private_key, sizeof(value.private_key) pos, end, value.private_key, sizeof(value.private_key)
); );
return pos; return pos;

258
src/ratchet.cpp
View file

@ -12,11 +12,11 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/ratchet.hh" #include "olm/ratchet.hh"
#include "axolotl/message.hh" #include "olm/message.hh"
#include "axolotl/memory.hh" #include "olm/memory.hh"
#include "axolotl/cipher.hh" #include "olm/cipher.hh"
#include "axolotl/pickle.hh" #include "olm/pickle.hh"
#include <cstring> #include <cstring>
@ -24,23 +24,23 @@
namespace { namespace {
std::uint8_t PROTOCOL_VERSION = 3; std::uint8_t PROTOCOL_VERSION = 3;
std::size_t KEY_LENGTH = axolotl::Curve25519PublicKey::LENGTH; std::size_t KEY_LENGTH = olm::Curve25519PublicKey::LENGTH;
std::uint8_t MESSAGE_KEY_SEED[1] = {0x01}; std::uint8_t MESSAGE_KEY_SEED[1] = {0x01};
std::uint8_t CHAIN_KEY_SEED[1] = {0x02}; std::uint8_t CHAIN_KEY_SEED[1] = {0x02};
std::size_t MAX_MESSAGE_GAP = 2000; std::size_t MAX_MESSAGE_GAP = 2000;
void create_chain_key( void create_chain_key(
axolotl::SharedKey const & root_key, olm::SharedKey const & root_key,
axolotl::Curve25519KeyPair const & our_key, olm::Curve25519KeyPair const & our_key,
axolotl::Curve25519PublicKey const & their_key, olm::Curve25519PublicKey const & their_key,
axolotl::KdfInfo const & info, olm::KdfInfo const & info,
axolotl::SharedKey & new_root_key, olm::SharedKey & new_root_key,
axolotl::ChainKey & new_chain_key olm::ChainKey & new_chain_key
) { ) {
axolotl::SharedKey secret; olm::SharedKey secret;
axolotl::curve25519_shared_secret(our_key, their_key, secret); olm::curve25519_shared_secret(our_key, their_key, secret);
std::uint8_t derived_secrets[64]; std::uint8_t derived_secrets[64];
axolotl::hkdf_sha256( olm::hkdf_sha256(
secret, sizeof(secret), secret, sizeof(secret),
root_key, sizeof(root_key), root_key, sizeof(root_key),
info.ratchet_info, info.ratchet_info_length, info.ratchet_info, info.ratchet_info_length,
@ -49,16 +49,16 @@ void create_chain_key(
std::memcpy(new_root_key, derived_secrets, 32); std::memcpy(new_root_key, derived_secrets, 32);
std::memcpy(new_chain_key.key, derived_secrets + 32, 32); std::memcpy(new_chain_key.key, derived_secrets + 32, 32);
new_chain_key.index = 0; new_chain_key.index = 0;
axolotl::unset(derived_secrets); olm::unset(derived_secrets);
axolotl::unset(secret); olm::unset(secret);
} }
void advance_chain_key( void advance_chain_key(
axolotl::ChainKey const & chain_key, olm::ChainKey const & chain_key,
axolotl::ChainKey & new_chain_key olm::ChainKey & new_chain_key
) { ) {
axolotl::hmac_sha256( olm::hmac_sha256(
chain_key.key, sizeof(chain_key.key), chain_key.key, sizeof(chain_key.key),
CHAIN_KEY_SEED, sizeof(CHAIN_KEY_SEED), CHAIN_KEY_SEED, sizeof(CHAIN_KEY_SEED),
new_chain_key.key new_chain_key.key
@ -68,11 +68,11 @@ void advance_chain_key(
void create_message_keys( void create_message_keys(
axolotl::ChainKey const & chain_key, olm::ChainKey const & chain_key,
axolotl::KdfInfo const & info, olm::KdfInfo const & info,
axolotl::MessageKey & message_key olm::MessageKey & message_key
) { ) {
axolotl::hmac_sha256( olm::hmac_sha256(
chain_key.key, sizeof(chain_key.key), chain_key.key, sizeof(chain_key.key),
MESSAGE_KEY_SEED, sizeof(MESSAGE_KEY_SEED), MESSAGE_KEY_SEED, sizeof(MESSAGE_KEY_SEED),
message_key.key message_key.key
@ -82,9 +82,9 @@ void create_message_keys(
std::size_t verify_mac_and_decrypt( std::size_t verify_mac_and_decrypt(
axolotl::Cipher const & cipher, olm::Cipher const & cipher,
axolotl::MessageKey const & message_key, olm::MessageKey const & message_key,
axolotl::MessageReader const & reader, olm::MessageReader const & reader,
std::uint8_t * plaintext, std::size_t max_plaintext_length std::uint8_t * plaintext, std::size_t max_plaintext_length
) { ) {
return cipher.decrypt( return cipher.decrypt(
@ -97,9 +97,9 @@ std::size_t verify_mac_and_decrypt(
std::size_t verify_mac_and_decrypt_for_existing_chain( std::size_t verify_mac_and_decrypt_for_existing_chain(
axolotl::Ratchet const & session, olm::Ratchet const & session,
axolotl::ChainKey const & chain, olm::ChainKey const & chain,
axolotl::MessageReader const & reader, olm::MessageReader const & reader,
std::uint8_t * plaintext, std::size_t max_plaintext_length std::uint8_t * plaintext, std::size_t max_plaintext_length
) { ) {
if (reader.counter < chain.index) { if (reader.counter < chain.index) {
@ -111,13 +111,13 @@ std::size_t verify_mac_and_decrypt_for_existing_chain(
return std::size_t(-1); return std::size_t(-1);
} }
axolotl::ChainKey new_chain = chain; olm::ChainKey new_chain = chain;
while (new_chain.index < reader.counter) { while (new_chain.index < reader.counter) {
advance_chain_key(new_chain, new_chain); advance_chain_key(new_chain, new_chain);
} }
axolotl::MessageKey message_key; olm::MessageKey message_key;
create_message_keys(new_chain, session.kdf_info, message_key); create_message_keys(new_chain, session.kdf_info, message_key);
std::size_t result = verify_mac_and_decrypt( std::size_t result = verify_mac_and_decrypt(
@ -125,18 +125,18 @@ std::size_t verify_mac_and_decrypt_for_existing_chain(
plaintext, max_plaintext_length plaintext, max_plaintext_length
); );
axolotl::unset(new_chain); olm::unset(new_chain);
return result; return result;
} }
std::size_t verify_mac_and_decrypt_for_new_chain( std::size_t verify_mac_and_decrypt_for_new_chain(
axolotl::Ratchet const & session, olm::Ratchet const & session,
axolotl::MessageReader const & reader, olm::MessageReader const & reader,
std::uint8_t * plaintext, std::size_t max_plaintext_length std::uint8_t * plaintext, std::size_t max_plaintext_length
) { ) {
axolotl::SharedKey new_root_key; olm::SharedKey new_root_key;
axolotl::ReceiverChain new_chain; olm::ReceiverChain new_chain;
/* They shouldn't move to a new chain until we've sent them a message /* They shouldn't move to a new chain until we've sent them a message
* acknowledging the last one */ * acknowledging the last one */
@ -162,29 +162,29 @@ std::size_t verify_mac_and_decrypt_for_new_chain(
session, new_chain.chain_key, reader, session, new_chain.chain_key, reader,
plaintext, max_plaintext_length plaintext, max_plaintext_length
); );
axolotl::unset(new_root_key); olm::unset(new_root_key);
axolotl::unset(new_chain); olm::unset(new_chain);
return result; return result;
} }
} // namespace } // namespace
axolotl::Ratchet::Ratchet( olm::Ratchet::Ratchet(
axolotl::KdfInfo const & kdf_info, olm::KdfInfo const & kdf_info,
Cipher const & ratchet_cipher Cipher const & ratchet_cipher
) : kdf_info(kdf_info), ) : kdf_info(kdf_info),
ratchet_cipher(ratchet_cipher), ratchet_cipher(ratchet_cipher),
last_error(axolotl::ErrorCode::SUCCESS) { last_error(olm::ErrorCode::SUCCESS) {
} }
void axolotl::Ratchet::initialise_as_bob( void olm::Ratchet::initialise_as_bob(
std::uint8_t const * shared_secret, std::size_t shared_secret_length, std::uint8_t const * shared_secret, std::size_t shared_secret_length,
axolotl::Curve25519PublicKey const & their_ratchet_key olm::Curve25519PublicKey const & their_ratchet_key
) { ) {
std::uint8_t derived_secrets[64]; std::uint8_t derived_secrets[64];
axolotl::hkdf_sha256( olm::hkdf_sha256(
shared_secret, shared_secret_length, shared_secret, shared_secret_length,
nullptr, 0, nullptr, 0,
kdf_info.root_info, kdf_info.root_info_length, kdf_info.root_info, kdf_info.root_info_length,
@ -195,16 +195,16 @@ void axolotl::Ratchet::initialise_as_bob(
std::memcpy(root_key, derived_secrets, 32); std::memcpy(root_key, derived_secrets, 32);
std::memcpy(receiver_chains[0].chain_key.key, derived_secrets + 32, 32); std::memcpy(receiver_chains[0].chain_key.key, derived_secrets + 32, 32);
receiver_chains[0].ratchet_key = their_ratchet_key; receiver_chains[0].ratchet_key = their_ratchet_key;
axolotl::unset(derived_secrets); olm::unset(derived_secrets);
} }
void axolotl::Ratchet::initialise_as_alice( void olm::Ratchet::initialise_as_alice(
std::uint8_t const * shared_secret, std::size_t shared_secret_length, std::uint8_t const * shared_secret, std::size_t shared_secret_length,
axolotl::Curve25519KeyPair const & our_ratchet_key olm::Curve25519KeyPair const & our_ratchet_key
) { ) {
std::uint8_t derived_secrets[64]; std::uint8_t derived_secrets[64];
axolotl::hkdf_sha256( olm::hkdf_sha256(
shared_secret, shared_secret_length, shared_secret, shared_secret_length,
nullptr, 0, nullptr, 0,
kdf_info.root_info, kdf_info.root_info_length, kdf_info.root_info, kdf_info.root_info_length,
@ -215,14 +215,14 @@ void axolotl::Ratchet::initialise_as_alice(
std::memcpy(root_key, derived_secrets, 32); std::memcpy(root_key, derived_secrets, 32);
std::memcpy(sender_chain[0].chain_key.key, derived_secrets + 32, 32); std::memcpy(sender_chain[0].chain_key.key, derived_secrets + 32, 32);
sender_chain[0].ratchet_key = our_ratchet_key; sender_chain[0].ratchet_key = our_ratchet_key;
axolotl::unset(derived_secrets); olm::unset(derived_secrets);
} }
namespace axolotl { namespace olm {
static std::size_t pickle_length( static std::size_t pickle_length(
const axolotl::SharedKey & value const olm::SharedKey & value
) { ) {
return KEY_LENGTH; return KEY_LENGTH;
} }
@ -230,135 +230,135 @@ static std::size_t pickle_length(
static std::uint8_t * pickle( static std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
const axolotl::SharedKey & value const olm::SharedKey & value
) { ) {
return axolotl::pickle_bytes(pos, value, KEY_LENGTH); return olm::pickle_bytes(pos, value, KEY_LENGTH);
} }
static std::uint8_t const * unpickle( static std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::SharedKey & value olm::SharedKey & value
) { ) {
return axolotl::unpickle_bytes(pos, end, value, KEY_LENGTH); return olm::unpickle_bytes(pos, end, value, KEY_LENGTH);
} }
static std::size_t pickle_length( static std::size_t pickle_length(
const axolotl::SenderChain & value const olm::SenderChain & value
) { ) {
std::size_t length = 0; std::size_t length = 0;
length += axolotl::pickle_length(value.ratchet_key); length += olm::pickle_length(value.ratchet_key);
length += axolotl::pickle_length(value.chain_key.key); length += olm::pickle_length(value.chain_key.key);
length += axolotl::pickle_length(value.chain_key.index); length += olm::pickle_length(value.chain_key.index);
return length; return length;
} }
static std::uint8_t * pickle( static std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
const axolotl::SenderChain & value const olm::SenderChain & value
) { ) {
pos = axolotl::pickle(pos, value.ratchet_key); pos = olm::pickle(pos, value.ratchet_key);
pos = axolotl::pickle(pos, value.chain_key.key); pos = olm::pickle(pos, value.chain_key.key);
pos = axolotl::pickle(pos, value.chain_key.index); pos = olm::pickle(pos, value.chain_key.index);
return pos; return pos;
} }
static std::uint8_t const * unpickle( static std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::SenderChain & value olm::SenderChain & value
) { ) {
pos = axolotl::unpickle(pos, end, value.ratchet_key); pos = olm::unpickle(pos, end, value.ratchet_key);
pos = axolotl::unpickle(pos, end, value.chain_key.key); pos = olm::unpickle(pos, end, value.chain_key.key);
pos = axolotl::unpickle(pos, end, value.chain_key.index); pos = olm::unpickle(pos, end, value.chain_key.index);
return pos; return pos;
} }
static std::size_t pickle_length( static std::size_t pickle_length(
const axolotl::ReceiverChain & value const olm::ReceiverChain & value
) { ) {
std::size_t length = 0; std::size_t length = 0;
length += axolotl::pickle_length(value.ratchet_key); length += olm::pickle_length(value.ratchet_key);
length += axolotl::pickle_length(value.chain_key.key); length += olm::pickle_length(value.chain_key.key);
length += axolotl::pickle_length(value.chain_key.index); length += olm::pickle_length(value.chain_key.index);
return length; return length;
} }
static std::uint8_t * pickle( static std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
const axolotl::ReceiverChain & value const olm::ReceiverChain & value
) { ) {
pos = axolotl::pickle(pos, value.ratchet_key); pos = olm::pickle(pos, value.ratchet_key);
pos = axolotl::pickle(pos, value.chain_key.key); pos = olm::pickle(pos, value.chain_key.key);
pos = axolotl::pickle(pos, value.chain_key.index); pos = olm::pickle(pos, value.chain_key.index);
return pos; return pos;
} }
static std::uint8_t const * unpickle( static std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::ReceiverChain & value olm::ReceiverChain & value
) { ) {
pos = axolotl::unpickle(pos, end, value.ratchet_key); pos = olm::unpickle(pos, end, value.ratchet_key);
pos = axolotl::unpickle(pos, end, value.chain_key.key); pos = olm::unpickle(pos, end, value.chain_key.key);
pos = axolotl::unpickle(pos, end, value.chain_key.index); pos = olm::unpickle(pos, end, value.chain_key.index);
return pos; return pos;
} }
static std::size_t pickle_length( static std::size_t pickle_length(
const axolotl::SkippedMessageKey & value const olm::SkippedMessageKey & value
) { ) {
std::size_t length = 0; std::size_t length = 0;
length += axolotl::pickle_length(value.ratchet_key); length += olm::pickle_length(value.ratchet_key);
length += axolotl::pickle_length(value.message_key.key); length += olm::pickle_length(value.message_key.key);
length += axolotl::pickle_length(value.message_key.index); length += olm::pickle_length(value.message_key.index);
return length; return length;
} }
static std::uint8_t * pickle( static std::uint8_t * pickle(
std::uint8_t * pos, std::uint8_t * pos,
const axolotl::SkippedMessageKey & value const olm::SkippedMessageKey & value
) { ) {
pos = axolotl::pickle(pos, value.ratchet_key); pos = olm::pickle(pos, value.ratchet_key);
pos = axolotl::pickle(pos, value.message_key.key); pos = olm::pickle(pos, value.message_key.key);
pos = axolotl::pickle(pos, value.message_key.index); pos = olm::pickle(pos, value.message_key.index);
return pos; return pos;
} }
static std::uint8_t const * unpickle( static std::uint8_t const * unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::SkippedMessageKey & value olm::SkippedMessageKey & value
) { ) {
pos = axolotl::unpickle(pos, end, value.ratchet_key); pos = olm::unpickle(pos, end, value.ratchet_key);
pos = axolotl::unpickle(pos, end, value.message_key.key); pos = olm::unpickle(pos, end, value.message_key.key);
pos = axolotl::unpickle(pos, end, value.message_key.index); pos = olm::unpickle(pos, end, value.message_key.index);
return pos; return pos;
} }
} // namespace axolotl } // namespace olm
std::size_t axolotl::pickle_length( std::size_t olm::pickle_length(
axolotl::Ratchet const & value olm::Ratchet const & value
) { ) {
std::size_t length = 0; std::size_t length = 0;
length += KEY_LENGTH; length += KEY_LENGTH;
length += axolotl::pickle_length(value.sender_chain); length += olm::pickle_length(value.sender_chain);
length += axolotl::pickle_length(value.receiver_chains); length += olm::pickle_length(value.receiver_chains);
length += axolotl::pickle_length(value.skipped_message_keys); length += olm::pickle_length(value.skipped_message_keys);
return length; return length;
} }
std::uint8_t * axolotl::pickle( std::uint8_t * olm::pickle(
std::uint8_t * pos, std::uint8_t * pos,
axolotl::Ratchet const & value olm::Ratchet const & value
) { ) {
pos = pickle(pos, value.root_key); pos = pickle(pos, value.root_key);
pos = pickle(pos, value.sender_chain); pos = pickle(pos, value.sender_chain);
@ -368,9 +368,9 @@ std::uint8_t * axolotl::pickle(
} }
std::uint8_t const * axolotl::unpickle( std::uint8_t const * olm::unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
axolotl::Ratchet & value olm::Ratchet & value
) { ) {
pos = unpickle(pos, end, value.root_key); pos = unpickle(pos, end, value.root_key);
pos = unpickle(pos, end, value.sender_chain); pos = unpickle(pos, end, value.sender_chain);
@ -380,7 +380,7 @@ std::uint8_t const * axolotl::unpickle(
} }
std::size_t axolotl::Ratchet::encrypt_output_length( std::size_t olm::Ratchet::encrypt_output_length(
std::size_t plaintext_length std::size_t plaintext_length
) { ) {
std::size_t counter = 0; std::size_t counter = 0;
@ -390,18 +390,18 @@ std::size_t axolotl::Ratchet::encrypt_output_length(
std::size_t padded = ratchet_cipher.encrypt_ciphertext_length( std::size_t padded = ratchet_cipher.encrypt_ciphertext_length(
plaintext_length plaintext_length
); );
return axolotl::encode_message_length( return olm::encode_message_length(
counter, KEY_LENGTH, padded, ratchet_cipher.mac_length() counter, KEY_LENGTH, padded, ratchet_cipher.mac_length()
); );
} }
std::size_t axolotl::Ratchet::encrypt_random_length() { std::size_t olm::Ratchet::encrypt_random_length() {
return sender_chain.empty() ? KEY_LENGTH : 0; return sender_chain.empty() ? KEY_LENGTH : 0;
} }
std::size_t axolotl::Ratchet::encrypt( std::size_t olm::Ratchet::encrypt(
std::uint8_t const * plaintext, std::size_t plaintext_length, std::uint8_t const * plaintext, std::size_t plaintext_length,
std::uint8_t const * random, std::size_t random_length, std::uint8_t const * random, std::size_t random_length,
std::uint8_t * output, std::size_t max_output_length std::uint8_t * output, std::size_t max_output_length
@ -409,17 +409,17 @@ std::size_t axolotl::Ratchet::encrypt(
std::size_t output_length = encrypt_output_length(plaintext_length); std::size_t output_length = encrypt_output_length(plaintext_length);
if (random_length < encrypt_random_length()) { if (random_length < encrypt_random_length()) {
last_error = axolotl::ErrorCode::NOT_ENOUGH_RANDOM; last_error = olm::ErrorCode::NOT_ENOUGH_RANDOM;
return std::size_t(-1); return std::size_t(-1);
} }
if (max_output_length < output_length) { if (max_output_length < output_length) {
last_error = axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; last_error = olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return std::size_t(-1); return std::size_t(-1);
} }
if (sender_chain.empty()) { if (sender_chain.empty()) {
sender_chain.insert(); sender_chain.insert();
axolotl::generate_key(random, sender_chain[0].ratchet_key); olm::generate_key(random, sender_chain[0].ratchet_key);
create_chain_key( create_chain_key(
root_key, root_key,
sender_chain[0].ratchet_key, sender_chain[0].ratchet_key,
@ -439,9 +439,9 @@ std::size_t axolotl::Ratchet::encrypt(
std::uint32_t counter = keys.index; std::uint32_t counter = keys.index;
Curve25519PublicKey const & ratchet_key = sender_chain[0].ratchet_key; Curve25519PublicKey const & ratchet_key = sender_chain[0].ratchet_key;
axolotl::MessageWriter writer; olm::MessageWriter writer;
axolotl::encode_message( olm::encode_message(
writer, PROTOCOL_VERSION, counter, KEY_LENGTH, ciphertext_length, output writer, PROTOCOL_VERSION, counter, KEY_LENGTH, ciphertext_length, output
); );
@ -454,21 +454,21 @@ std::size_t axolotl::Ratchet::encrypt(
output, output_length output, output_length
); );
axolotl::unset(keys); olm::unset(keys);
return output_length; return output_length;
} }
std::size_t axolotl::Ratchet::decrypt_max_plaintext_length( std::size_t olm::Ratchet::decrypt_max_plaintext_length(
std::uint8_t const * input, std::size_t input_length std::uint8_t const * input, std::size_t input_length
) { ) {
axolotl::MessageReader reader; olm::MessageReader reader;
axolotl::decode_message( olm::decode_message(
reader, input, input_length, ratchet_cipher.mac_length() reader, input, input_length, ratchet_cipher.mac_length()
); );
if (!reader.ciphertext) { if (!reader.ciphertext) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
@ -476,22 +476,22 @@ std::size_t axolotl::Ratchet::decrypt_max_plaintext_length(
} }
std::size_t axolotl::Ratchet::decrypt( std::size_t olm::Ratchet::decrypt(
std::uint8_t const * input, std::size_t input_length, std::uint8_t const * input, std::size_t input_length,
std::uint8_t * plaintext, std::size_t max_plaintext_length std::uint8_t * plaintext, std::size_t max_plaintext_length
) { ) {
axolotl::MessageReader reader; olm::MessageReader reader;
axolotl::decode_message( olm::decode_message(
reader, input, input_length, ratchet_cipher.mac_length() reader, input, input_length, ratchet_cipher.mac_length()
); );
if (reader.version != PROTOCOL_VERSION) { if (reader.version != PROTOCOL_VERSION) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_VERSION; last_error = olm::ErrorCode::BAD_MESSAGE_VERSION;
return std::size_t(-1); return std::size_t(-1);
} }
if (!reader.has_counter || !reader.ratchet_key || !reader.ciphertext) { if (!reader.has_counter || !reader.ratchet_key || !reader.ciphertext) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
@ -500,17 +500,17 @@ std::size_t axolotl::Ratchet::decrypt(
); );
if (max_plaintext_length < max_length) { if (max_plaintext_length < max_length) {
last_error = axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; last_error = olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return std::size_t(-1); return std::size_t(-1);
} }
if (reader.ratchet_key_length != KEY_LENGTH) { if (reader.ratchet_key_length != KEY_LENGTH) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
ReceiverChain * chain = nullptr; ReceiverChain * chain = nullptr;
for (axolotl::ReceiverChain & receiver_chain : receiver_chains) { for (olm::ReceiverChain & receiver_chain : receiver_chains) {
if (0 == std::memcmp( if (0 == std::memcmp(
receiver_chain.ratchet_key.public_key, reader.ratchet_key, receiver_chain.ratchet_key.public_key, reader.ratchet_key,
KEY_LENGTH KEY_LENGTH
@ -529,7 +529,7 @@ std::size_t axolotl::Ratchet::decrypt(
} else if (chain->chain_key.index > reader.counter) { } else if (chain->chain_key.index > reader.counter) {
/* Chain already advanced beyond the key for this message /* Chain already advanced beyond the key for this message
* Check if the message keys are in the skipped key list. */ * Check if the message keys are in the skipped key list. */
for (axolotl::SkippedMessageKey & skipped : skipped_message_keys) { for (olm::SkippedMessageKey & skipped : skipped_message_keys) {
if (reader.counter == skipped.message_key.index if (reader.counter == skipped.message_key.index
&& 0 == std::memcmp( && 0 == std::memcmp(
skipped.ratchet_key.public_key, reader.ratchet_key, skipped.ratchet_key.public_key, reader.ratchet_key,
@ -546,7 +546,7 @@ std::size_t axolotl::Ratchet::decrypt(
if (result != std::size_t(-1)) { if (result != std::size_t(-1)) {
/* Remove the key from the skipped keys now that we've /* Remove the key from the skipped keys now that we've
* decoded the message it corresponds to. */ * decoded the message it corresponds to. */
axolotl::unset(skipped); olm::unset(skipped);
skipped_message_keys.erase(&skipped); skipped_message_keys.erase(&skipped);
return result; return result;
} }
@ -559,7 +559,7 @@ std::size_t axolotl::Ratchet::decrypt(
} }
if (result == std::size_t(-1)) { if (result == std::size_t(-1)) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_MAC; last_error = olm::ErrorCode::BAD_MESSAGE_MAC;
return std::size_t(-1); return std::size_t(-1);
} }
@ -576,12 +576,12 @@ std::size_t axolotl::Ratchet::decrypt(
root_key, sender_chain[0].ratchet_key, chain->ratchet_key, root_key, sender_chain[0].ratchet_key, chain->ratchet_key,
kdf_info, root_key, chain->chain_key kdf_info, root_key, chain->chain_key
); );
axolotl::unset(sender_chain[0]); olm::unset(sender_chain[0]);
sender_chain.erase(sender_chain.begin()); sender_chain.erase(sender_chain.begin());
} }
while (chain->chain_key.index < reader.counter) { while (chain->chain_key.index < reader.counter) {
axolotl::SkippedMessageKey & key = *skipped_message_keys.insert(); olm::SkippedMessageKey & key = *skipped_message_keys.insert();
create_message_keys(chain->chain_key, kdf_info, key.message_key); create_message_keys(chain->chain_key, kdf_info, key.message_key);
key.ratchet_key = chain->ratchet_key; key.ratchet_key = chain->ratchet_key;
advance_chain_key(chain->chain_key, chain->chain_key); advance_chain_key(chain->chain_key, chain->chain_key);

170
src/session.cpp
View file

@ -12,13 +12,13 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/session.hh" #include "olm/session.hh"
#include "axolotl/cipher.hh" #include "olm/cipher.hh"
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include "axolotl/account.hh" #include "olm/account.hh"
#include "axolotl/memory.hh" #include "olm/memory.hh"
#include "axolotl/message.hh" #include "olm/message.hh"
#include "axolotl/pickle.hh" #include "olm/pickle.hh"
#include <cstring> #include <cstring>
@ -27,51 +27,51 @@ namespace {
static const std::size_t KEY_LENGTH = 32; static const std::size_t KEY_LENGTH = 32;
static const std::uint8_t PROTOCOL_VERSION = 0x3; static const std::uint8_t PROTOCOL_VERSION = 0x3;
static const std::uint8_t ROOT_KDF_INFO[] = "AXOLOTL_ROOT"; static const std::uint8_t ROOT_KDF_INFO[] = "OLM_ROOT";
static const std::uint8_t RATCHET_KDF_INFO[] = "AXOLOTL_RATCHET"; static const std::uint8_t RATCHET_KDF_INFO[] = "OLM_RATCHET";
static const std::uint8_t CIPHER_KDF_INFO[] = "AXOLOTL_KEYS"; static const std::uint8_t CIPHER_KDF_INFO[] = "OLM_KEYS";
static const axolotl::CipherAesSha256 AXOLOTL_CIPHER( static const olm::CipherAesSha256 OLM_CIPHER(
CIPHER_KDF_INFO, sizeof(CIPHER_KDF_INFO) -1 CIPHER_KDF_INFO, sizeof(CIPHER_KDF_INFO) -1
); );
static const axolotl::KdfInfo AXOLOTL_KDF_INFO = { static const olm::KdfInfo OLM_KDF_INFO = {
ROOT_KDF_INFO, sizeof(ROOT_KDF_INFO) - 1, ROOT_KDF_INFO, sizeof(ROOT_KDF_INFO) - 1,
RATCHET_KDF_INFO, sizeof(RATCHET_KDF_INFO) - 1 RATCHET_KDF_INFO, sizeof(RATCHET_KDF_INFO) - 1
}; };
} // namespace } // namespace
axolotl::Session::Session( olm::Session::Session(
) : ratchet(AXOLOTL_KDF_INFO, AXOLOTL_CIPHER), ) : ratchet(OLM_KDF_INFO, OLM_CIPHER),
last_error(axolotl::ErrorCode::SUCCESS), last_error(olm::ErrorCode::SUCCESS),
received_message(false), received_message(false),
bob_one_time_key_id(0) { bob_one_time_key_id(0) {
} }
std::size_t axolotl::Session::new_outbound_session_random_length() { std::size_t olm::Session::new_outbound_session_random_length() {
return KEY_LENGTH * 2; return KEY_LENGTH * 2;
} }
std::size_t axolotl::Session::new_outbound_session( std::size_t olm::Session::new_outbound_session(
axolotl::Account const & local_account, olm::Account const & local_account,
axolotl::Curve25519PublicKey const & identity_key, olm::Curve25519PublicKey const & identity_key,
axolotl::RemoteKey const & one_time_key, olm::RemoteKey const & one_time_key,
std::uint8_t const * random, std::size_t random_length std::uint8_t const * random, std::size_t random_length
) { ) {
if (random_length < new_outbound_session_random_length()) { if (random_length < new_outbound_session_random_length()) {
last_error = axolotl::ErrorCode::NOT_ENOUGH_RANDOM; last_error = olm::ErrorCode::NOT_ENOUGH_RANDOM;
return std::size_t(-1); return std::size_t(-1);
} }
Curve25519KeyPair base_key; Curve25519KeyPair base_key;
axolotl::generate_key(random, base_key); olm::generate_key(random, base_key);
Curve25519KeyPair ratchet_key; Curve25519KeyPair ratchet_key;
axolotl::generate_key(random + 32, ratchet_key); olm::generate_key(random + 32, ratchet_key);
received_message = false; received_message = false;
alice_identity_key.id = local_account.identity_key.id; alice_identity_key.id = local_account.identity_key.id;
@ -81,21 +81,21 @@ std::size_t axolotl::Session::new_outbound_session(
std::uint8_t shared_secret[96]; std::uint8_t shared_secret[96];
axolotl::curve25519_shared_secret( olm::curve25519_shared_secret(
local_account.identity_key.key, one_time_key.key, shared_secret local_account.identity_key.key, one_time_key.key, shared_secret
); );
axolotl::curve25519_shared_secret( olm::curve25519_shared_secret(
base_key, identity_key, shared_secret + 32 base_key, identity_key, shared_secret + 32
); );
axolotl::curve25519_shared_secret( olm::curve25519_shared_secret(
base_key, one_time_key.key, shared_secret + 64 base_key, one_time_key.key, shared_secret + 64
); );
ratchet.initialise_as_alice(shared_secret, 96, ratchet_key); ratchet.initialise_as_alice(shared_secret, 96, ratchet_key);
axolotl::unset(base_key); olm::unset(base_key);
axolotl::unset(ratchet_key); olm::unset(ratchet_key);
axolotl::unset(shared_secret); olm::unset(shared_secret);
return std::size_t(0); return std::size_t(0);
} }
@ -103,7 +103,7 @@ std::size_t axolotl::Session::new_outbound_session(
namespace { namespace {
bool check_message_fields( bool check_message_fields(
axolotl::PreKeyMessageReader & reader olm::PreKeyMessageReader & reader
) { ) {
bool ok = true; bool ok = true;
ok = ok && reader.identity_key; ok = ok && reader.identity_key;
@ -118,19 +118,19 @@ bool check_message_fields(
} // namespace } // namespace
std::size_t axolotl::Session::new_inbound_session( std::size_t olm::Session::new_inbound_session(
axolotl::Account & local_account, olm::Account & local_account,
std::uint8_t const * one_time_key_message, std::size_t message_length std::uint8_t const * one_time_key_message, std::size_t message_length
) { ) {
axolotl::PreKeyMessageReader reader; olm::PreKeyMessageReader reader;
decode_one_time_key_message(reader, one_time_key_message, message_length); decode_one_time_key_message(reader, one_time_key_message, message_length);
if (!check_message_fields(reader)) { if (!check_message_fields(reader)) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
axolotl::MessageReader message_reader; olm::MessageReader message_reader;
decode_message( decode_message(
message_reader, reader.message, reader.message_length, message_reader, reader.message, reader.message_length,
ratchet.ratchet_cipher.mac_length() ratchet.ratchet_cipher.mac_length()
@ -138,34 +138,34 @@ std::size_t axolotl::Session::new_inbound_session(
if (!message_reader.ratchet_key if (!message_reader.ratchet_key
|| message_reader.ratchet_key_length != KEY_LENGTH) { || message_reader.ratchet_key_length != KEY_LENGTH) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
std::memcpy(alice_identity_key.key.public_key, reader.identity_key, 32); std::memcpy(alice_identity_key.key.public_key, reader.identity_key, 32);
std::memcpy(alice_base_key.public_key, reader.base_key, 32); std::memcpy(alice_base_key.public_key, reader.base_key, 32);
bob_one_time_key_id = reader.one_time_key_id; bob_one_time_key_id = reader.one_time_key_id;
axolotl::Curve25519PublicKey ratchet_key; olm::Curve25519PublicKey ratchet_key;
std::memcpy(ratchet_key.public_key, message_reader.ratchet_key, 32); std::memcpy(ratchet_key.public_key, message_reader.ratchet_key, 32);
axolotl::LocalKey const * bob_one_time_key = local_account.lookup_key( olm::LocalKey const * bob_one_time_key = local_account.lookup_key(
bob_one_time_key_id bob_one_time_key_id
); );
if (!bob_one_time_key) { if (!bob_one_time_key) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_KEY_ID; last_error = olm::ErrorCode::BAD_MESSAGE_KEY_ID;
return std::size_t(-1); return std::size_t(-1);
} }
std::uint8_t shared_secret[96]; std::uint8_t shared_secret[96];
axolotl::curve25519_shared_secret( olm::curve25519_shared_secret(
bob_one_time_key->key, alice_identity_key.key, shared_secret bob_one_time_key->key, alice_identity_key.key, shared_secret
); );
axolotl::curve25519_shared_secret( olm::curve25519_shared_secret(
local_account.identity_key.key, alice_base_key, shared_secret + 32 local_account.identity_key.key, alice_base_key, shared_secret + 32
); );
axolotl::curve25519_shared_secret( olm::curve25519_shared_secret(
bob_one_time_key->key, alice_base_key, shared_secret + 64 bob_one_time_key->key, alice_base_key, shared_secret + 64
); );
@ -175,10 +175,10 @@ std::size_t axolotl::Session::new_inbound_session(
} }
bool axolotl::Session::matches_inbound_session( bool olm::Session::matches_inbound_session(
std::uint8_t const * one_time_key_message, std::size_t message_length std::uint8_t const * one_time_key_message, std::size_t message_length
) { ) {
axolotl::PreKeyMessageReader reader; olm::PreKeyMessageReader reader;
decode_one_time_key_message(reader, one_time_key_message, message_length); decode_one_time_key_message(reader, one_time_key_message, message_length);
if (!check_message_fields(reader)) { if (!check_message_fields(reader)) {
@ -197,16 +197,16 @@ bool axolotl::Session::matches_inbound_session(
} }
axolotl::MessageType axolotl::Session::encrypt_message_type() { olm::MessageType olm::Session::encrypt_message_type() {
if (received_message) { if (received_message) {
return axolotl::MessageType::MESSAGE; return olm::MessageType::MESSAGE;
} else { } else {
return axolotl::MessageType::PRE_KEY; return olm::MessageType::PRE_KEY;
} }
} }
std::size_t axolotl::Session::encrypt_message_length( std::size_t olm::Session::encrypt_message_length(
std::size_t plaintext_length std::size_t plaintext_length
) { ) {
std::size_t message_length = ratchet.encrypt_output_length( std::size_t message_length = ratchet.encrypt_output_length(
@ -226,18 +226,18 @@ std::size_t axolotl::Session::encrypt_message_length(
} }
std::size_t axolotl::Session::encrypt_random_length() { std::size_t olm::Session::encrypt_random_length() {
return ratchet.encrypt_random_length(); return ratchet.encrypt_random_length();
} }
std::size_t axolotl::Session::encrypt( std::size_t olm::Session::encrypt(
std::uint8_t const * plaintext, std::size_t plaintext_length, std::uint8_t const * plaintext, std::size_t plaintext_length,
std::uint8_t const * random, std::size_t random_length, std::uint8_t const * random, std::size_t random_length,
std::uint8_t * message, std::size_t message_length std::uint8_t * message, std::size_t message_length
) { ) {
if (message_length < encrypt_message_length(plaintext_length)) { if (message_length < encrypt_message_length(plaintext_length)) {
last_error = axolotl::ErrorCode::OUTPUT_BUFFER_TOO_SMALL; last_error = olm::ErrorCode::OUTPUT_BUFFER_TOO_SMALL;
return std::size_t(-1); return std::size_t(-1);
} }
std::uint8_t * message_body; std::uint8_t * message_body;
@ -248,7 +248,7 @@ std::size_t axolotl::Session::encrypt(
if (received_message) { if (received_message) {
message_body = message; message_body = message;
} else { } else {
axolotl::PreKeyMessageWriter writer; olm::PreKeyMessageWriter writer;
encode_one_time_key_message( encode_one_time_key_message(
writer, writer,
PROTOCOL_VERSION, PROTOCOL_VERSION,
@ -275,26 +275,26 @@ std::size_t axolotl::Session::encrypt(
if (result == std::size_t(-1)) { if (result == std::size_t(-1)) {
last_error = ratchet.last_error; last_error = ratchet.last_error;
ratchet.last_error = axolotl::ErrorCode::SUCCESS; ratchet.last_error = olm::ErrorCode::SUCCESS;
} }
return result; return result;
} }
std::size_t axolotl::Session::decrypt_max_plaintext_length( std::size_t olm::Session::decrypt_max_plaintext_length(
MessageType message_type, MessageType message_type,
std::uint8_t const * message, std::size_t message_length std::uint8_t const * message, std::size_t message_length
) { ) {
std::uint8_t const * message_body; std::uint8_t const * message_body;
std::size_t message_body_length; std::size_t message_body_length;
if (message_type == axolotl::MessageType::MESSAGE) { if (message_type == olm::MessageType::MESSAGE) {
message_body = message; message_body = message;
message_body_length = message_length; message_body_length = message_length;
} else { } else {
axolotl::PreKeyMessageReader reader; olm::PreKeyMessageReader reader;
decode_one_time_key_message(reader, message, message_length); decode_one_time_key_message(reader, message, message_length);
if (!reader.message) { if (!reader.message) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
message_body = reader.message; message_body = reader.message;
@ -307,27 +307,27 @@ std::size_t axolotl::Session::decrypt_max_plaintext_length(
if (result == std::size_t(-1)) { if (result == std::size_t(-1)) {
last_error = ratchet.last_error; last_error = ratchet.last_error;
ratchet.last_error = axolotl::ErrorCode::SUCCESS; ratchet.last_error = olm::ErrorCode::SUCCESS;
} }
return result; return result;
} }
std::size_t axolotl::Session::decrypt( std::size_t olm::Session::decrypt(
axolotl::MessageType message_type, olm::MessageType message_type,
std::uint8_t const * message, std::size_t message_length, std::uint8_t const * message, std::size_t message_length,
std::uint8_t * plaintext, std::size_t max_plaintext_length std::uint8_t * plaintext, std::size_t max_plaintext_length
) { ) {
std::uint8_t const * message_body; std::uint8_t const * message_body;
std::size_t message_body_length; std::size_t message_body_length;
if (message_type == axolotl::MessageType::MESSAGE) { if (message_type == olm::MessageType::MESSAGE) {
message_body = message; message_body = message;
message_body_length = message_length; message_body_length = message_length;
} else { } else {
axolotl::PreKeyMessageReader reader; olm::PreKeyMessageReader reader;
decode_one_time_key_message(reader, message, message_length); decode_one_time_key_message(reader, message, message_length);
if (!reader.message) { if (!reader.message) {
last_error = axolotl::ErrorCode::BAD_MESSAGE_FORMAT; last_error = olm::ErrorCode::BAD_MESSAGE_FORMAT;
return std::size_t(-1); return std::size_t(-1);
} }
message_body = reader.message; message_body = reader.message;
@ -340,7 +340,7 @@ std::size_t axolotl::Session::decrypt(
if (result == std::size_t(-1)) { if (result == std::size_t(-1)) {
last_error = ratchet.last_error; last_error = ratchet.last_error;
ratchet.last_error = axolotl::ErrorCode::SUCCESS; ratchet.last_error = olm::ErrorCode::SUCCESS;
} else { } else {
received_message = true; received_message = true;
} }
@ -348,44 +348,44 @@ std::size_t axolotl::Session::decrypt(
} }
std::size_t axolotl::pickle_length( std::size_t olm::pickle_length(
Session const & value Session const & value
) { ) {
std::size_t length = 0; std::size_t length = 0;
length += axolotl::pickle_length(value.received_message); length += olm::pickle_length(value.received_message);
length += axolotl::pickle_length(value.alice_identity_key.id); length += olm::pickle_length(value.alice_identity_key.id);
length += axolotl::pickle_length(value.alice_identity_key.key); length += olm::pickle_length(value.alice_identity_key.key);
length += axolotl::pickle_length(value.alice_base_key); length += olm::pickle_length(value.alice_base_key);
length += axolotl::pickle_length(value.bob_one_time_key_id); length += olm::pickle_length(value.bob_one_time_key_id);
length += axolotl::pickle_length(value.ratchet); length += olm::pickle_length(value.ratchet);
return length; return length;
} }
std::uint8_t * axolotl::pickle( std::uint8_t * olm::pickle(
std::uint8_t * pos, std::uint8_t * pos,
Session const & value Session const & value
) { ) {
pos = axolotl::pickle(pos, value.received_message); pos = olm::pickle(pos, value.received_message);
pos = axolotl::pickle(pos, value.alice_identity_key.id); pos = olm::pickle(pos, value.alice_identity_key.id);
pos = axolotl::pickle(pos, value.alice_identity_key.key); pos = olm::pickle(pos, value.alice_identity_key.key);
pos = axolotl::pickle(pos, value.alice_base_key); pos = olm::pickle(pos, value.alice_base_key);
pos = axolotl::pickle(pos, value.bob_one_time_key_id); pos = olm::pickle(pos, value.bob_one_time_key_id);
pos = axolotl::pickle(pos, value.ratchet); pos = olm::pickle(pos, value.ratchet);
return pos; return pos;
} }
std::uint8_t const * axolotl::unpickle( std::uint8_t const * olm::unpickle(
std::uint8_t const * pos, std::uint8_t const * end, std::uint8_t const * pos, std::uint8_t const * end,
Session & value Session & value
) { ) {
pos = axolotl::unpickle(pos, end, value.received_message); pos = olm::unpickle(pos, end, value.received_message);
pos = axolotl::unpickle(pos, end, value.alice_identity_key.id); pos = olm::unpickle(pos, end, value.alice_identity_key.id);
pos = axolotl::unpickle(pos, end, value.alice_identity_key.key); pos = olm::unpickle(pos, end, value.alice_identity_key.key);
pos = axolotl::unpickle(pos, end, value.alice_base_key); pos = olm::unpickle(pos, end, value.alice_base_key);
pos = axolotl::unpickle(pos, end, value.bob_one_time_key_id); pos = olm::unpickle(pos, end, value.bob_one_time_key_id);
pos = axolotl::unpickle(pos, end, value.ratchet); pos = olm::unpickle(pos, end, value.ratchet);
return pos; return pos;
} }

269
tests/test_axolotl.cpp
View file

@ -1,269 +0,0 @@
#include "axolotl/axolotl.hh"
#include "unittest.hh"
#include <cstddef>
#include <cstdint>
#include <cstring>
struct MockRandom {
MockRandom(std::uint8_t tag, std::uint8_t offset = 0)
: tag(tag), current(offset) {}
void operator()(
std::uint8_t * bytes, std::size_t length
) {
while (length > 32) {
bytes[0] = tag;
std::memset(bytes + 1, current, 31);
length -= 32;
bytes += 32;
current += 1;
}
if (length) {
bytes[0] = tag;
std::memset(bytes + 1, current, length - 1);
current += 1;
}
}
std::uint8_t tag;
std::uint8_t current;
};
int main() {
{ /** Pickle account test */
TestCase test_case("Pickle account test");
MockRandom mock_random('P');
std::uint8_t account_buffer[::axolotl_account_size()];
::AxolotlAccount *account = ::axolotl_account(account_buffer);
std::uint8_t random[::axolotl_create_account_random_length(account)];
mock_random(random, sizeof(random));
::axolotl_create_account(account, random, sizeof(random));
std::size_t pickle_length = ::axolotl_pickle_account_length(account);
std::uint8_t pickle1[pickle_length];
::axolotl_pickle_account(account, "secret_key", 10, pickle1, pickle_length);
std::uint8_t pickle2[pickle_length];
std::memcpy(pickle2, pickle1, pickle_length);
std::uint8_t account_buffer2[::axolotl_account_size()];
::AxolotlAccount *account2 = ::axolotl_account(account_buffer2);
::axolotl_unpickle_account(account2, "secret_key", 10, pickle2, pickle_length);
assert_equals(pickle_length, ::axolotl_pickle_account_length(account2));
::axolotl_pickle_account(account2, "secret_key", 10, pickle2, pickle_length);
assert_equals(pickle1, pickle2, pickle_length);
}
{ /** Loopback test */
TestCase test_case("Loopback test");
MockRandom mock_random_a('A', 0x00);
MockRandom mock_random_b('B', 0x80);
std::uint8_t a_account_buffer[::axolotl_account_size()];
::AxolotlAccount *a_account = ::axolotl_account(a_account_buffer);
std::uint8_t a_random[::axolotl_create_account_random_length(a_account)];
mock_random_a(a_random, sizeof(a_random));
::axolotl_create_account(a_account, a_random, sizeof(a_random));
std::uint8_t b_account_buffer[::axolotl_account_size()];
::AxolotlAccount *b_account = ::axolotl_account(b_account_buffer);
std::uint8_t b_random[::axolotl_create_account_random_length(b_account)];
mock_random_b(b_random, sizeof(b_random));
::axolotl_create_account(b_account, b_random, sizeof(b_random));
std::uint8_t b_id_keys[::axolotl_account_identity_keys_length(b_account)];
std::uint8_t b_ot_keys[::axolotl_account_one_time_keys_length(b_account)];
::axolotl_account_identity_keys(b_account, b_id_keys, sizeof(b_id_keys));
::axolotl_account_one_time_keys(b_account, b_ot_keys, sizeof(b_ot_keys));
std::uint8_t a_session_buffer[::axolotl_session_size()];
::AxolotlSession *a_session = ::axolotl_session(a_session_buffer);
std::uint8_t a_rand[::axolotl_create_outbound_session_random_length(a_session)];
mock_random_a(a_rand, sizeof(a_rand));
assert_not_equals(std::size_t(-1), ::axolotl_create_outbound_session(
a_session, a_account,
b_id_keys + 14, 43,
::atol((char *)(b_ot_keys + 62)), b_ot_keys + 74, 43,
a_rand, sizeof(a_rand)
));
std::uint8_t plaintext[] = "Hello, World";
std::uint8_t message_1[::axolotl_encrypt_message_length(a_session, 12)];
std::uint8_t a_message_random[::axolotl_encrypt_random_length(a_session)];
mock_random_a(a_message_random, sizeof(a_message_random));
assert_equals(std::size_t(0), ::axolotl_encrypt_message_type(a_session));
assert_not_equals(std::size_t(-1), ::axolotl_encrypt(
a_session,
plaintext, 12,
a_message_random, sizeof(a_message_random),
message_1, sizeof(message_1)
));
std::uint8_t tmp_message_1[sizeof(message_1)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t b_session_buffer[::axolotl_account_size()];
::AxolotlSession *b_session = ::axolotl_session(b_session_buffer);
::axolotl_create_inbound_session(
b_session, b_account, tmp_message_1, sizeof(message_1)
);
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t plaintext_1[::axolotl_decrypt_max_plaintext_length(
b_session, 0, tmp_message_1, sizeof(message_1)
)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
assert_equals(std::size_t(12), ::axolotl_decrypt(
b_session, 0,
tmp_message_1, sizeof(message_1),
plaintext_1, sizeof(plaintext_1)
));
assert_equals(plaintext, plaintext_1, 12);
std::uint8_t message_2[::axolotl_encrypt_message_length(b_session, 12)];
std::uint8_t b_message_random[::axolotl_encrypt_random_length(b_session)];
mock_random_b(b_message_random, sizeof(b_message_random));
assert_equals(std::size_t(1), ::axolotl_encrypt_message_type(b_session));
assert_not_equals(std::size_t(-1), ::axolotl_encrypt(
b_session,
plaintext, 12,
b_message_random, sizeof(b_message_random),
message_2, sizeof(message_2)
));
std::uint8_t tmp_message_2[sizeof(message_2)];
std::memcpy(tmp_message_2, message_2, sizeof(message_2));
std::uint8_t plaintext_2[::axolotl_decrypt_max_plaintext_length(
a_session, 1, tmp_message_2, sizeof(message_2)
)];
std::memcpy(tmp_message_2, message_2, sizeof(message_2));
assert_equals(std::size_t(12), ::axolotl_decrypt(
a_session, 1,
tmp_message_2, sizeof(message_2),
plaintext_2, sizeof(plaintext_2)
));
assert_equals(plaintext, plaintext_2, 12);
std::memcpy(tmp_message_2, message_2, sizeof(message_2));
assert_equals(std::size_t(-1), ::axolotl_decrypt(
a_session, 1,
tmp_message_2, sizeof(message_2),
plaintext_2, sizeof(plaintext_2)
));
}
{ /** More messages test */
TestCase test_case("More messages test");
MockRandom mock_random_a('A', 0x00);
MockRandom mock_random_b('B', 0x80);
std::uint8_t a_account_buffer[::axolotl_account_size()];
::AxolotlAccount *a_account = ::axolotl_account(a_account_buffer);
std::uint8_t a_random[::axolotl_create_account_random_length(a_account)];
mock_random_a(a_random, sizeof(a_random));
::axolotl_create_account(a_account, a_random, sizeof(a_random));
std::uint8_t b_account_buffer[::axolotl_account_size()];
::AxolotlAccount *b_account = ::axolotl_account(b_account_buffer);
std::uint8_t b_random[::axolotl_create_account_random_length(b_account)];
mock_random_b(b_random, sizeof(b_random));
::axolotl_create_account(b_account, b_random, sizeof(b_random));
std::uint8_t b_id_keys[::axolotl_account_identity_keys_length(b_account)];
std::uint8_t b_ot_keys[::axolotl_account_one_time_keys_length(b_account)];
::axolotl_account_identity_keys(b_account, b_id_keys, sizeof(b_id_keys));
::axolotl_account_one_time_keys(b_account, b_ot_keys, sizeof(b_ot_keys));
std::uint8_t a_session_buffer[::axolotl_session_size()];
::AxolotlSession *a_session = ::axolotl_session(a_session_buffer);
std::uint8_t a_rand[::axolotl_create_outbound_session_random_length(a_session)];
mock_random_a(a_rand, sizeof(a_rand));
assert_not_equals(std::size_t(-1), ::axolotl_create_outbound_session(
a_session, a_account,
b_id_keys + 14, 43,
::atol((char *)(b_ot_keys + 62)), b_ot_keys + 74, 43,
a_rand, sizeof(a_rand)
));
std::uint8_t plaintext[] = "Hello, World";
std::uint8_t message_1[::axolotl_encrypt_message_length(a_session, 12)];
std::uint8_t a_message_random[::axolotl_encrypt_random_length(a_session)];
mock_random_a(a_message_random, sizeof(a_message_random));
assert_equals(std::size_t(0), ::axolotl_encrypt_message_type(a_session));
assert_not_equals(std::size_t(-1), ::axolotl_encrypt(
a_session,
plaintext, 12,
a_message_random, sizeof(a_message_random),
message_1, sizeof(message_1)
));
std::uint8_t tmp_message_1[sizeof(message_1)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t b_session_buffer[::axolotl_account_size()];
::AxolotlSession *b_session = ::axolotl_session(b_session_buffer);
::axolotl_create_inbound_session(
b_session, b_account, tmp_message_1, sizeof(message_1)
);
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t plaintext_1[::axolotl_decrypt_max_plaintext_length(
b_session, 0, tmp_message_1, sizeof(message_1)
)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
assert_equals(std::size_t(12), ::axolotl_decrypt(
b_session, 0,
tmp_message_1, sizeof(message_1),
plaintext_1, sizeof(plaintext_1)
));
for (unsigned i = 0; i < 8; ++i) {
{
std::uint8_t msg_a[::axolotl_encrypt_message_length(a_session, 12)];
std::uint8_t rnd_a[::axolotl_encrypt_random_length(a_session)];
mock_random_a(rnd_a, sizeof(rnd_a));
std::size_t type_a = ::axolotl_encrypt_message_type(a_session);
assert_not_equals(std::size_t(-1), ::axolotl_encrypt(
a_session, plaintext, 12, rnd_a, sizeof(rnd_a), msg_a, sizeof(msg_a)
));
std::uint8_t tmp_a[sizeof(msg_a)];
std::memcpy(tmp_a, msg_a, sizeof(msg_a));
std::uint8_t out_a[::axolotl_decrypt_max_plaintext_length(
b_session, type_a, tmp_a, sizeof(tmp_a)
)];
std::memcpy(tmp_a, msg_a, sizeof(msg_a));
assert_equals(std::size_t(12), ::axolotl_decrypt(
b_session, type_a, msg_a, sizeof(msg_a), out_a, sizeof(out_a)
));
}
{
std::uint8_t msg_b[::axolotl_encrypt_message_length(b_session, 12)];
std::uint8_t rnd_b[::axolotl_encrypt_random_length(b_session)];
mock_random_b(rnd_b, sizeof(rnd_b));
std::size_t type_b = ::axolotl_encrypt_message_type(b_session);
assert_not_equals(std::size_t(-1), ::axolotl_encrypt(
b_session, plaintext, 12, rnd_b, sizeof(rnd_b), msg_b, sizeof(msg_b)
));
std::uint8_t tmp_b[sizeof(msg_b)];
std::memcpy(tmp_b, msg_b, sizeof(msg_b));
std::uint8_t out_b[::axolotl_decrypt_max_plaintext_length(
a_session, type_b, tmp_b, sizeof(tmp_b)
)];
std::memcpy(tmp_b, msg_b, sizeof(msg_b));
assert_equals(std::size_t(12), ::axolotl_decrypt(
a_session, type_b, msg_b, sizeof(msg_b), out_b, sizeof(out_b)
));
}
}
}
}

10
tests/test_base64.cpp
View file

@ -1,4 +1,4 @@
#include "axolotl/base64.hh" #include "olm/base64.hh"
#include "unittest.hh" #include "unittest.hh"
int main() { int main() {
@ -10,11 +10,11 @@ std::uint8_t input[] = "Hello World";
std::uint8_t expected_output[] = "SGVsbG8gV29ybGQ"; std::uint8_t expected_output[] = "SGVsbG8gV29ybGQ";
std::size_t input_length = sizeof(input) - 1; std::size_t input_length = sizeof(input) - 1;
std::size_t output_length = axolotl::encode_base64_length(input_length); std::size_t output_length = olm::encode_base64_length(input_length);
assert_equals(std::size_t(15), output_length); assert_equals(std::size_t(15), output_length);
std::uint8_t output[output_length]; std::uint8_t output[output_length];
axolotl::encode_base64(input, input_length, output); olm::encode_base64(input, input_length, output);
assert_equals(expected_output, output, output_length); assert_equals(expected_output, output, output_length);
} }
@ -25,11 +25,11 @@ std::uint8_t input[] = "SGVsbG8gV29ybGQ";
std::uint8_t expected_output[] = "Hello World"; std::uint8_t expected_output[] = "Hello World";
std::size_t input_length = sizeof(input) - 1; std::size_t input_length = sizeof(input) - 1;
std::size_t output_length = axolotl::decode_base64_length(input_length); std::size_t output_length = olm::decode_base64_length(input_length);
assert_equals(std::size_t(11), output_length); assert_equals(std::size_t(11), output_length);
std::uint8_t output[output_length]; std::uint8_t output[output_length];
axolotl::decode_base64(input, input_length, output); olm::decode_base64(input, input_length, output);
assert_equals(expected_output, output, output_length); assert_equals(expected_output, output, output_length);
} }

44
tests/test_crypto.cpp
View file

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/crypto.hh" #include "olm/crypto.hh"
#include "unittest.hh" #include "unittest.hh"
@ -58,25 +58,25 @@ std::uint8_t expected_agreement[32] = {
0x76, 0xF0, 0x9B, 0x3C, 0x1E, 0x16, 0x17, 0x42 0x76, 0xF0, 0x9B, 0x3C, 0x1E, 0x16, 0x17, 0x42
}; };
axolotl::Curve25519KeyPair alice_pair; olm::Curve25519KeyPair alice_pair;
axolotl::generate_key(alice_private, alice_pair); olm::generate_key(alice_private, alice_pair);
assert_equals(alice_private, alice_pair.private_key, 32); assert_equals(alice_private, alice_pair.private_key, 32);
assert_equals(alice_public, alice_pair.public_key, 32); assert_equals(alice_public, alice_pair.public_key, 32);
axolotl::Curve25519KeyPair bob_pair; olm::Curve25519KeyPair bob_pair;
axolotl::generate_key(bob_private, bob_pair); olm::generate_key(bob_private, bob_pair);
assert_equals(bob_private, bob_pair.private_key, 32); assert_equals(bob_private, bob_pair.private_key, 32);
assert_equals(bob_public, bob_pair.public_key, 32); assert_equals(bob_public, bob_pair.public_key, 32);
std::uint8_t actual_agreement[axolotl::CURVE25519_SHARED_SECRET_LENGTH] = {}; std::uint8_t actual_agreement[olm::CURVE25519_SHARED_SECRET_LENGTH] = {};
axolotl::curve25519_shared_secret(alice_pair, bob_pair, actual_agreement); olm::curve25519_shared_secret(alice_pair, bob_pair, actual_agreement);
assert_equals(expected_agreement, actual_agreement, 32); assert_equals(expected_agreement, actual_agreement, 32);
axolotl::curve25519_shared_secret(bob_pair, alice_pair, actual_agreement); olm::curve25519_shared_secret(bob_pair, alice_pair, actual_agreement);
assert_equals(expected_agreement, actual_agreement, 32); assert_equals(expected_agreement, actual_agreement, 32);
@ -90,22 +90,22 @@ std::uint8_t private_key[33] = "This key is a string of 32 bytes";
std::uint8_t message[] = "message"; std::uint8_t message[] = "message";
std::size_t message_length = sizeof(message) - 1; std::size_t message_length = sizeof(message) - 1;
axolotl::Curve25519KeyPair key_pair; olm::Curve25519KeyPair key_pair;
axolotl::generate_key(private_key, key_pair); olm::generate_key(private_key, key_pair);
std::uint8_t signature[64]; std::uint8_t signature[64];
axolotl::curve25519_sign( olm::curve25519_sign(
key_pair, message, message_length, signature key_pair, message, message_length, signature
); );
bool result = axolotl::curve25519_verify( bool result = olm::curve25519_verify(
key_pair, message, message_length, signature key_pair, message, message_length, signature
); );
assert_equals(true, result); assert_equals(true, result);
message[0] = 'n'; message[0] = 'n';
result = axolotl::curve25519_verify( result = olm::curve25519_verify(
key_pair, message, message_length, signature key_pair, message, message_length, signature
); );
assert_equals(false, result); assert_equals(false, result);
@ -116,8 +116,8 @@ assert_equals(false, result);
TestCase test_case("AES Test Case 1"); TestCase test_case("AES Test Case 1");
axolotl::Aes256Key key = {}; olm::Aes256Key key = {};
axolotl::Aes256Iv iv = {}; olm::Aes256Iv iv = {};
std::uint8_t input[16] = {}; std::uint8_t input[16] = {};
std::uint8_t expected[32] = { std::uint8_t expected[32] = {
@ -127,16 +127,16 @@ std::uint8_t expected[32] = {
0x4B, 0xAE, 0xDF, 0xFC, 0x3D, 0x21, 0x4C, 0x38 0x4B, 0xAE, 0xDF, 0xFC, 0x3D, 0x21, 0x4C, 0x38
}; };
std::size_t length = axolotl::aes_encrypt_cbc_length(sizeof(input)); std::size_t length = olm::aes_encrypt_cbc_length(sizeof(input));
assert_equals(std::size_t(32), length); assert_equals(std::size_t(32), length);
std::uint8_t actual[32] = {}; std::uint8_t actual[32] = {};
axolotl::aes_encrypt_cbc(key, iv, input, sizeof(input), actual); olm::aes_encrypt_cbc(key, iv, input, sizeof(input), actual);
assert_equals(expected, actual, 32); assert_equals(expected, actual, 32);
length = axolotl::aes_decrypt_cbc(key, iv, expected, sizeof(expected), actual); length = olm::aes_decrypt_cbc(key, iv, expected, sizeof(expected), actual);
assert_equals(std::size_t(16), length); assert_equals(std::size_t(16), length);
assert_equals(input, actual, length); assert_equals(input, actual, length);
@ -158,7 +158,7 @@ std::uint8_t expected[32] = {
std::uint8_t actual[32]; std::uint8_t actual[32];
axolotl::sha256(input, sizeof(input), actual); olm::sha256(input, sizeof(input), actual);
assert_equals(expected, actual, 32); assert_equals(expected, actual, 32);
@ -179,7 +179,7 @@ std::uint8_t expected[32] = {
std::uint8_t actual[32]; std::uint8_t actual[32];
axolotl::hmac_sha256(input, sizeof(input), input, sizeof(input), actual); olm::hmac_sha256(input, sizeof(input), input, sizeof(input), actual);
assert_equals(expected, actual, 32); assert_equals(expected, actual, 32);
@ -214,7 +214,7 @@ std::uint8_t hmac_expected_output[32] = {
std::uint8_t hmac_actual_output[32] = {}; std::uint8_t hmac_actual_output[32] = {};
axolotl::hmac_sha256( olm::hmac_sha256(
salt, sizeof(salt), salt, sizeof(salt),
input, sizeof(input), input, sizeof(input),
hmac_actual_output hmac_actual_output
@ -233,7 +233,7 @@ std::uint8_t hkdf_expected_output[42] = {
std::uint8_t hkdf_actual_output[42] = {}; std::uint8_t hkdf_actual_output[42] = {};
axolotl::hkdf_sha256( olm::hkdf_sha256(
input, sizeof(input), input, sizeof(input),
salt, sizeof(salt), salt, sizeof(salt),
info, sizeof(info), info, sizeof(info),

6
tests/test_list.cpp
View file

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/list.hh" #include "olm/list.hh"
#include "unittest.hh" #include "unittest.hh"
int main() { int main() {
@ -21,7 +21,7 @@ int main() {
TestCase test_case("List insert"); TestCase test_case("List insert");
axolotl::List<int, 4> test_list; olm::List<int, 4> test_list;
assert_equals(std::size_t(0), test_list.size()); assert_equals(std::size_t(0), test_list.size());
@ -47,7 +47,7 @@ assert_equals(4, test_list[3]);
{ /** List erase test **/ { /** List erase test **/
TestCase test_case("List erase"); TestCase test_case("List erase");
axolotl::List<int, 4> test_list; olm::List<int, 4> test_list;
assert_equals(std::size_t(0), test_list.size()); assert_equals(std::size_t(0), test_list.size());
for (int i = 0; i < 4; ++i) { for (int i = 0; i < 4; ++i) {

12
tests/test_message.cpp
View file

@ -12,7 +12,7 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/message.hh" #include "olm/message.hh"
#include "unittest.hh" #include "unittest.hh"
int main() { int main() {
@ -27,8 +27,8 @@ std::uint8_t hmacsha2[9] = "hmacsha2";
TestCase test_case("Message decode test"); TestCase test_case("Message decode test");
axolotl::MessageReader reader; olm::MessageReader reader;
axolotl::decode_message(reader, message1, 35, 8); olm::decode_message(reader, message1, 35, 8);
assert_equals(std::uint8_t(3), reader.version); assert_equals(std::uint8_t(3), reader.version);
assert_equals(true, reader.has_counter); assert_equals(true, reader.has_counter);
@ -46,13 +46,13 @@ assert_equals(ciphertext, reader.ciphertext, 10);
TestCase test_case("Message encode test"); TestCase test_case("Message encode test");
std::size_t length = axolotl::encode_message_length(1, 10, 10, 8); std::size_t length = olm::encode_message_length(1, 10, 10, 8);
assert_equals(std::size_t(35), length); assert_equals(std::size_t(35), length);
std::uint8_t output[length]; std::uint8_t output[length];
axolotl::MessageWriter writer; olm::MessageWriter writer;
axolotl::encode_message(writer, 3, 1, 10, 10, output); olm::encode_message(writer, 3, 1, 10, 10, output);
std::memcpy(writer.ratchet_key, ratchetkey, 10); std::memcpy(writer.ratchet_key, ratchetkey, 10);
std::memcpy(writer.ciphertext, ciphertext, 10); std::memcpy(writer.ciphertext, ciphertext, 10);

269
tests/test_olm.cpp Normal file
View file

@ -0,0 +1,269 @@
#include "olm/olm.hh"
#include "unittest.hh"
#include <cstddef>
#include <cstdint>
#include <cstring>
struct MockRandom {
MockRandom(std::uint8_t tag, std::uint8_t offset = 0)
: tag(tag), current(offset) {}
void operator()(
std::uint8_t * bytes, std::size_t length
) {
while (length > 32) {
bytes[0] = tag;
std::memset(bytes + 1, current, 31);
length -= 32;
bytes += 32;
current += 1;
}
if (length) {
bytes[0] = tag;
std::memset(bytes + 1, current, length - 1);
current += 1;
}
}
std::uint8_t tag;
std::uint8_t current;
};
int main() {
{ /** Pickle account test */
TestCase test_case("Pickle account test");
MockRandom mock_random('P');
std::uint8_t account_buffer[::olm_account_size()];
::OlmAccount *account = ::olm_account(account_buffer);
std::uint8_t random[::olm_create_account_random_length(account)];
mock_random(random, sizeof(random));
::olm_create_account(account, random, sizeof(random));
std::size_t pickle_length = ::olm_pickle_account_length(account);
std::uint8_t pickle1[pickle_length];
::olm_pickle_account(account, "secret_key", 10, pickle1, pickle_length);
std::uint8_t pickle2[pickle_length];
std::memcpy(pickle2, pickle1, pickle_length);
std::uint8_t account_buffer2[::olm_account_size()];
::OlmAccount *account2 = ::olm_account(account_buffer2);
::olm_unpickle_account(account2, "secret_key", 10, pickle2, pickle_length);
assert_equals(pickle_length, ::olm_pickle_account_length(account2));
::olm_pickle_account(account2, "secret_key", 10, pickle2, pickle_length);
assert_equals(pickle1, pickle2, pickle_length);
}
{ /** Loopback test */
TestCase test_case("Loopback test");
MockRandom mock_random_a('A', 0x00);
MockRandom mock_random_b('B', 0x80);
std::uint8_t a_account_buffer[::olm_account_size()];
::OlmAccount *a_account = ::olm_account(a_account_buffer);
std::uint8_t a_random[::olm_create_account_random_length(a_account)];
mock_random_a(a_random, sizeof(a_random));
::olm_create_account(a_account, a_random, sizeof(a_random));
std::uint8_t b_account_buffer[::olm_account_size()];
::OlmAccount *b_account = ::olm_account(b_account_buffer);
std::uint8_t b_random[::olm_create_account_random_length(b_account)];
mock_random_b(b_random, sizeof(b_random));
::olm_create_account(b_account, b_random, sizeof(b_random));
std::uint8_t b_id_keys[::olm_account_identity_keys_length(b_account)];
std::uint8_t b_ot_keys[::olm_account_one_time_keys_length(b_account)];
::olm_account_identity_keys(b_account, b_id_keys, sizeof(b_id_keys));
::olm_account_one_time_keys(b_account, b_ot_keys, sizeof(b_ot_keys));
std::uint8_t a_session_buffer[::olm_session_size()];
::OlmSession *a_session = ::olm_session(a_session_buffer);
std::uint8_t a_rand[::olm_create_outbound_session_random_length(a_session)];
mock_random_a(a_rand, sizeof(a_rand));
assert_not_equals(std::size_t(-1), ::olm_create_outbound_session(
a_session, a_account,
b_id_keys + 14, 43,
::atol((char *)(b_ot_keys + 62)), b_ot_keys + 74, 43,
a_rand, sizeof(a_rand)
));
std::uint8_t plaintext[] = "Hello, World";
std::uint8_t message_1[::olm_encrypt_message_length(a_session, 12)];
std::uint8_t a_message_random[::olm_encrypt_random_length(a_session)];
mock_random_a(a_message_random, sizeof(a_message_random));
assert_equals(std::size_t(0), ::olm_encrypt_message_type(a_session));
assert_not_equals(std::size_t(-1), ::olm_encrypt(
a_session,
plaintext, 12,
a_message_random, sizeof(a_message_random),
message_1, sizeof(message_1)
));
std::uint8_t tmp_message_1[sizeof(message_1)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t b_session_buffer[::olm_account_size()];
::OlmSession *b_session = ::olm_session(b_session_buffer);
::olm_create_inbound_session(
b_session, b_account, tmp_message_1, sizeof(message_1)
);
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t plaintext_1[::olm_decrypt_max_plaintext_length(
b_session, 0, tmp_message_1, sizeof(message_1)
)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
assert_equals(std::size_t(12), ::olm_decrypt(
b_session, 0,
tmp_message_1, sizeof(message_1),
plaintext_1, sizeof(plaintext_1)
));
assert_equals(plaintext, plaintext_1, 12);
std::uint8_t message_2[::olm_encrypt_message_length(b_session, 12)];
std::uint8_t b_message_random[::olm_encrypt_random_length(b_session)];
mock_random_b(b_message_random, sizeof(b_message_random));
assert_equals(std::size_t(1), ::olm_encrypt_message_type(b_session));
assert_not_equals(std::size_t(-1), ::olm_encrypt(
b_session,
plaintext, 12,
b_message_random, sizeof(b_message_random),
message_2, sizeof(message_2)
));
std::uint8_t tmp_message_2[sizeof(message_2)];
std::memcpy(tmp_message_2, message_2, sizeof(message_2));
std::uint8_t plaintext_2[::olm_decrypt_max_plaintext_length(
a_session, 1, tmp_message_2, sizeof(message_2)
)];
std::memcpy(tmp_message_2, message_2, sizeof(message_2));
assert_equals(std::size_t(12), ::olm_decrypt(
a_session, 1,
tmp_message_2, sizeof(message_2),
plaintext_2, sizeof(plaintext_2)
));
assert_equals(plaintext, plaintext_2, 12);
std::memcpy(tmp_message_2, message_2, sizeof(message_2));
assert_equals(std::size_t(-1), ::olm_decrypt(
a_session, 1,
tmp_message_2, sizeof(message_2),
plaintext_2, sizeof(plaintext_2)
));
}
{ /** More messages test */
TestCase test_case("More messages test");
MockRandom mock_random_a('A', 0x00);
MockRandom mock_random_b('B', 0x80);
std::uint8_t a_account_buffer[::olm_account_size()];
::OlmAccount *a_account = ::olm_account(a_account_buffer);
std::uint8_t a_random[::olm_create_account_random_length(a_account)];
mock_random_a(a_random, sizeof(a_random));
::olm_create_account(a_account, a_random, sizeof(a_random));
std::uint8_t b_account_buffer[::olm_account_size()];
::OlmAccount *b_account = ::olm_account(b_account_buffer);
std::uint8_t b_random[::olm_create_account_random_length(b_account)];
mock_random_b(b_random, sizeof(b_random));
::olm_create_account(b_account, b_random, sizeof(b_random));
std::uint8_t b_id_keys[::olm_account_identity_keys_length(b_account)];
std::uint8_t b_ot_keys[::olm_account_one_time_keys_length(b_account)];
::olm_account_identity_keys(b_account, b_id_keys, sizeof(b_id_keys));
::olm_account_one_time_keys(b_account, b_ot_keys, sizeof(b_ot_keys));
std::uint8_t a_session_buffer[::olm_session_size()];
::OlmSession *a_session = ::olm_session(a_session_buffer);
std::uint8_t a_rand[::olm_create_outbound_session_random_length(a_session)];
mock_random_a(a_rand, sizeof(a_rand));
assert_not_equals(std::size_t(-1), ::olm_create_outbound_session(
a_session, a_account,
b_id_keys + 14, 43,
::atol((char *)(b_ot_keys + 62)), b_ot_keys + 74, 43,
a_rand, sizeof(a_rand)
));
std::uint8_t plaintext[] = "Hello, World";
std::uint8_t message_1[::olm_encrypt_message_length(a_session, 12)];
std::uint8_t a_message_random[::olm_encrypt_random_length(a_session)];
mock_random_a(a_message_random, sizeof(a_message_random));
assert_equals(std::size_t(0), ::olm_encrypt_message_type(a_session));
assert_not_equals(std::size_t(-1), ::olm_encrypt(
a_session,
plaintext, 12,
a_message_random, sizeof(a_message_random),
message_1, sizeof(message_1)
));
std::uint8_t tmp_message_1[sizeof(message_1)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t b_session_buffer[::olm_account_size()];
::OlmSession *b_session = ::olm_session(b_session_buffer);
::olm_create_inbound_session(
b_session, b_account, tmp_message_1, sizeof(message_1)
);
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
std::uint8_t plaintext_1[::olm_decrypt_max_plaintext_length(
b_session, 0, tmp_message_1, sizeof(message_1)
)];
std::memcpy(tmp_message_1, message_1, sizeof(message_1));
assert_equals(std::size_t(12), ::olm_decrypt(
b_session, 0,
tmp_message_1, sizeof(message_1),
plaintext_1, sizeof(plaintext_1)
));
for (unsigned i = 0; i < 8; ++i) {
{
std::uint8_t msg_a[::olm_encrypt_message_length(a_session, 12)];
std::uint8_t rnd_a[::olm_encrypt_random_length(a_session)];
mock_random_a(rnd_a, sizeof(rnd_a));
std::size_t type_a = ::olm_encrypt_message_type(a_session);
assert_not_equals(std::size_t(-1), ::olm_encrypt(
a_session, plaintext, 12, rnd_a, sizeof(rnd_a), msg_a, sizeof(msg_a)
));
std::uint8_t tmp_a[sizeof(msg_a)];
std::memcpy(tmp_a, msg_a, sizeof(msg_a));
std::uint8_t out_a[::olm_decrypt_max_plaintext_length(
b_session, type_a, tmp_a, sizeof(tmp_a)
)];
std::memcpy(tmp_a, msg_a, sizeof(msg_a));
assert_equals(std::size_t(12), ::olm_decrypt(
b_session, type_a, msg_a, sizeof(msg_a), out_a, sizeof(out_a)
));
}
{
std::uint8_t msg_b[::olm_encrypt_message_length(b_session, 12)];
std::uint8_t rnd_b[::olm_encrypt_random_length(b_session)];
mock_random_b(rnd_b, sizeof(rnd_b));
std::size_t type_b = ::olm_encrypt_message_type(b_session);
assert_not_equals(std::size_t(-1), ::olm_encrypt(
b_session, plaintext, 12, rnd_b, sizeof(rnd_b), msg_b, sizeof(msg_b)
));
std::uint8_t tmp_b[sizeof(msg_b)];
std::memcpy(tmp_b, msg_b, sizeof(msg_b));
std::uint8_t out_b[::olm_decrypt_max_plaintext_length(
a_session, type_b, tmp_b, sizeof(tmp_b)
)];
std::memcpy(tmp_b, msg_b, sizeof(msg_b));
assert_equals(std::size_t(12), ::olm_decrypt(
a_session, type_b, msg_b, sizeof(msg_b), out_b, sizeof(out_b)
));
}
}
}
}

36
tests/test_ratchet.cpp
View file

@ -12,37 +12,37 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include "axolotl/ratchet.hh" #include "olm/ratchet.hh"
#include "axolotl/cipher.hh" #include "olm/cipher.hh"
#include "unittest.hh" #include "unittest.hh"
int main() { int main() {
std::uint8_t root_info[] = "Axolotl"; std::uint8_t root_info[] = "Olm";
std::uint8_t ratchet_info[] = "AxolotlRatchet"; std::uint8_t ratchet_info[] = "OlmRatchet";
std::uint8_t message_info[] = "AxolotlMessageKeys"; std::uint8_t message_info[] = "OlmMessageKeys";
axolotl::KdfInfo kdf_info = { olm::KdfInfo kdf_info = {
root_info, sizeof(root_info) - 1, root_info, sizeof(root_info) - 1,
ratchet_info, sizeof(ratchet_info) - 1 ratchet_info, sizeof(ratchet_info) - 1
}; };
axolotl::CipherAesSha256 cipher( olm::CipherAesSha256 cipher(
message_info, sizeof(message_info) - 1 message_info, sizeof(message_info) - 1
); );
std::uint8_t random_bytes[] = "0123456789ABDEF0123456789ABCDEF"; std::uint8_t random_bytes[] = "0123456789ABDEF0123456789ABCDEF";
axolotl::Curve25519KeyPair alice_key; olm::Curve25519KeyPair alice_key;
axolotl::generate_key(random_bytes, alice_key); olm::generate_key(random_bytes, alice_key);
std::uint8_t shared_secret[] = "A secret"; std::uint8_t shared_secret[] = "A secret";
{ /* Send/Receive test case */ { /* Send/Receive test case */
TestCase test_case("Axolotl Send/Receive"); TestCase test_case("Olm Send/Receive");
axolotl::Ratchet alice(kdf_info, cipher); olm::Ratchet alice(kdf_info, cipher);
axolotl::Ratchet bob(kdf_info, cipher); olm::Ratchet bob(kdf_info, cipher);
alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key); alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key);
bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key); bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key);
@ -108,10 +108,10 @@ std::size_t encrypt_length, decrypt_length;
{ /* Out of order test case */ { /* Out of order test case */
TestCase test_case("Axolotl Out of Order"); TestCase test_case("Olm Out of Order");
axolotl::Ratchet alice(kdf_info, cipher); olm::Ratchet alice(kdf_info, cipher);
axolotl::Ratchet bob(kdf_info, cipher); olm::Ratchet bob(kdf_info, cipher);
alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key); alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key);
bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key); bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key);
@ -180,10 +180,10 @@ std::size_t encrypt_length, decrypt_length;
{ /* More messages */ { /* More messages */
TestCase test_case("Axolotl More Messages"); TestCase test_case("Olm More Messages");
axolotl::Ratchet alice(kdf_info, cipher); olm::Ratchet alice(kdf_info, cipher);
axolotl::Ratchet bob(kdf_info, cipher); olm::Ratchet bob(kdf_info, cipher);
alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key); alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key);
bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key); bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key);