ruby_olm 0.1.1

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_ratchet.cpp

@@ -0,0 +1,221 @@
+/* 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.
+ */
+#include "olm/ratchet.hh"
+#include "olm/cipher.h"
+#include "unittest.hh"
+
+
+int main() {
+
+std::uint8_t root_info[] = "Olm";
+std::uint8_t ratchet_info[] = "OlmRatchet";
+std::uint8_t message_info[] = "OlmMessageKeys";
+
+olm::KdfInfo kdf_info = {
+    root_info, sizeof(root_info) - 1,
+    ratchet_info, sizeof(ratchet_info) - 1
+};
+
+_olm_cipher_aes_sha_256 cipher0 = OLM_CIPHER_INIT_AES_SHA_256(message_info);
+_olm_cipher *cipher = OLM_CIPHER_BASE(&cipher0);
+
+std::uint8_t random_bytes[] = "0123456789ABDEF0123456789ABCDEF";
+_olm_curve25519_key_pair alice_key;
+_olm_crypto_curve25519_generate_key(random_bytes, &alice_key);
+
+std::uint8_t shared_secret[] = "A secret";
+
+{ /* Send/Receive test case */
+TestCase test_case("Olm Send/Receive");
+
+olm::Ratchet alice(kdf_info, cipher);
+olm::Ratchet bob(kdf_info, cipher);
+
+alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key);
+bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key.public_key);
+
+std::uint8_t plaintext[] = "Message";
+std::size_t plaintext_length = sizeof(plaintext) - 1;
+
+std::size_t message_length, random_length, output_length;
+std::size_t encrypt_length, decrypt_length;
+{
+    /* Alice sends Bob a message */
+    message_length = alice.encrypt_output_length(plaintext_length);
+    random_length = alice.encrypt_random_length();
+    assert_equals(std::size_t(0), random_length);
+
+    std::uint8_t message[message_length];
+
+    encrypt_length = alice.encrypt(
+        plaintext, plaintext_length,
+        NULL, 0,
+        message, message_length
+    );
+    assert_equals(message_length, encrypt_length);
+
+    output_length = bob.decrypt_max_plaintext_length(message, message_length);
+    std::uint8_t output[output_length];
+    decrypt_length = bob.decrypt(
+        message, message_length,
+        output, output_length
+    );
+    assert_equals(plaintext_length, decrypt_length);
+    assert_equals(plaintext, output, decrypt_length);
+}
+
+
+{
+    /* Bob sends Alice a message */
+    message_length = bob.encrypt_output_length(plaintext_length);
+    random_length = bob.encrypt_random_length();
+    assert_equals(std::size_t(32), random_length);
+
+    std::uint8_t message[message_length];
+    std::uint8_t random[] = "This is a random 32 byte string.";
+
+    encrypt_length = bob.encrypt(
+        plaintext, plaintext_length,
+        random, 32,
+        message, message_length
+    );
+    assert_equals(message_length, encrypt_length);
+
+    output_length = alice.decrypt_max_plaintext_length(message, message_length);
+    std::uint8_t output[output_length];
+    decrypt_length = alice.decrypt(
+        message, message_length,
+        output, output_length
+    );
+    assert_equals(plaintext_length, decrypt_length);
+    assert_equals(plaintext, output, decrypt_length);
+}
+
+} /* Send/receive message test case */
+
+{ /* Out of order test case */
+
+TestCase test_case("Olm Out of Order");
+
+olm::Ratchet alice(kdf_info, cipher);
+olm::Ratchet bob(kdf_info, cipher);
+
+alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key);
+bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key.public_key);
+
+std::uint8_t plaintext_1[] = "First Message";
+std::size_t plaintext_1_length = sizeof(plaintext_1) - 1;
+
+std::uint8_t plaintext_2[] = "Second Messsage. A bit longer than the first.";
+std::size_t plaintext_2_length = sizeof(plaintext_2) - 1;
+
+std::size_t message_1_length, message_2_length, random_length, output_length;
+std::size_t encrypt_length, decrypt_length;
+
+{
+    /* Alice sends Bob two messages and they arrive out of order */
+    message_1_length = alice.encrypt_output_length(plaintext_1_length);
+    random_length = alice.encrypt_random_length();
+    assert_equals(std::size_t(0), random_length);
+
+    std::uint8_t message_1[message_1_length];
+    std::uint8_t random[] = "This is a random 32 byte string.";
+    encrypt_length = alice.encrypt(
+        plaintext_1, plaintext_1_length,
+        random, 32,
+        message_1, message_1_length
+    );
+    assert_equals(message_1_length, encrypt_length);
+
+    message_2_length = alice.encrypt_output_length(plaintext_2_length);
+    random_length = alice.encrypt_random_length();
+    assert_equals(std::size_t(0), random_length);
+
+    std::uint8_t message_2[message_2_length];
+    encrypt_length = alice.encrypt(
+        plaintext_2, plaintext_2_length,
+        NULL, 0,
+        message_2, message_2_length
+    );
+    assert_equals(message_2_length, encrypt_length);
+
+    output_length = bob.decrypt_max_plaintext_length(
+        message_2, message_2_length
+    );
+    std::uint8_t output_1[output_length];
+    decrypt_length = bob.decrypt(
+        message_2, message_2_length,
+        output_1, output_length
+    );
+    assert_equals(plaintext_2_length, decrypt_length);
+    assert_equals(plaintext_2, output_1, decrypt_length);
+
+    output_length = bob.decrypt_max_plaintext_length(
+        message_1, message_1_length
+    );
+    std::uint8_t output_2[output_length];
+    decrypt_length = bob.decrypt(
+        message_1, message_1_length,
+        output_2, output_length
+    );
+
+    assert_equals(plaintext_1_length, decrypt_length);
+    assert_equals(plaintext_1, output_2, decrypt_length);
+}
+
+} /* Out of order test case */
+
+{ /* More messages */
+
+TestCase test_case("Olm More Messages");
+
+olm::Ratchet alice(kdf_info, cipher);
+olm::Ratchet bob(kdf_info, cipher);
+
+alice.initialise_as_alice(shared_secret, sizeof(shared_secret) - 1, alice_key);
+bob.initialise_as_bob(shared_secret, sizeof(shared_secret) - 1, alice_key.public_key);
+
+std::uint8_t plaintext[] = "These 15 bytes";
+assert_equals(std::size_t(15), sizeof(plaintext));
+std::uint8_t random[] = "This is a random 32 byte string";
+
+for (unsigned i = 0; i < 8; ++i) {
+{
+    std::uint8_t msg[alice.encrypt_output_length(sizeof(plaintext))];
+    alice.encrypt(
+        plaintext, 15, random, 32, msg, sizeof(msg)
+    );
+    std::uint8_t output[bob.decrypt_max_plaintext_length(msg, sizeof(msg))];
+    assert_equals(
+        std::size_t(15), bob.decrypt(msg, sizeof(msg), output, sizeof(output))
+    );
+}
+random[31]++;
+{
+    std::uint8_t msg[bob.encrypt_output_length(sizeof(plaintext))];
+    bob.encrypt(
+        plaintext, 15, random, 32, msg, sizeof(msg)
+    );
+    std::uint8_t output[alice.decrypt_max_plaintext_length(msg, sizeof(msg))];
+    assert_equals(
+        std::size_t(15), alice.decrypt(msg, sizeof(msg), output, sizeof(output))
+    );
+}
+random[31]++;
+}
+
+}
+
+}

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_session.cpp

@@ -0,0 +1,144 @@
+#include "olm/session.hh"
+#include "olm/pickle_encoding.h"
+
+#include "unittest.hh"
+
+/* decode into a buffer, which is returned */
+std::uint8_t *decode_hex(
+    const char * input
+) {
+    static std::uint8_t buf[256];
+    std::uint8_t *p = buf;
+    while (*input != '\0') {
+        char high = *(input++);
+        char low = *(input++);
+        if (high >= 'a') high -= 'a' - ('9' + 1);
+        if (low >= 'a') low -= 'a' - ('9' + 1);
+        uint8_t value = ((high - '0') << 4) | (low - '0');
+        *p++ = value;
+    }
+    return buf;
+}
+
+void check_session(const olm::Session &session) {
+    assert_equals(
+        decode_hex("49d640dc96b80176694af69fc4b8ca9fac49aecbd697d01fd8bee1ed2693b6c9"),
+        session.ratchet.root_key, 32
+    );
+
+    assert_equals(
+        std::size_t(1),
+        session.ratchet.sender_chain.size()
+    );
+
+    assert_equals(
+        decode_hex("f77a03eaa9b301fa7d2a5aa6b50286906de12cc96044f526dbbcb12839ad7003"),
+        session.ratchet.sender_chain[0].ratchet_key.public_key.public_key, 32
+    );
+
+    assert_equals(
+        decode_hex("d945c6ed4c7c277117adf11fb133a7936d287afe97c0b3ac989644b4490d4f31"),
+        session.ratchet.sender_chain[0].ratchet_key.private_key.private_key, 32
+    );
+
+    assert_equals(
+        std::uint32_t(0),
+        session.ratchet.sender_chain[0].chain_key.index
+    );
+
+    assert_equals(
+        std::size_t(0),
+        session.ratchet.receiver_chains.size()
+    );
+
+    assert_equals(
+        std::size_t(0),
+        session.ratchet.skipped_message_keys.size()
+    );
+
+    assert_equals(OLM_SUCCESS, session.last_error);
+    assert_equals(false, session.received_message);
+
+    assert_equals(
+        decode_hex("7326b58623a3f7bd8da11a1bab51f432c02a7430241b326e9fc8916a21eb257e"),
+        session.alice_identity_key.public_key, 32
+    );
+
+    assert_equals(
+        decode_hex("0ab4b30bde20bd374ceccc72861660f0fd046f7516900796c3e5de41c598316c"),
+        session.alice_base_key.public_key, 32
+    );
+
+    assert_equals(
+        decode_hex("585dba930b10d90d81702c715f4085d07c42b0cd2d676010bb6086c86c4cc618"),
+        session.bob_one_time_key.public_key, 32
+    );
+}
+
+int main() {
+
+{
+    TestCase test_case("V1 session pickle");
+
+    const uint8_t *PICKLE_KEY=(uint8_t *)"secret_key";
+    uint8_t pickled[] =
+        "wkEpwMgiAqD7B1/Lw2cKYYDcUZVOd9QHes7ZroWxr/Rp/nWEAySgRsIu/a54YhO67rwitr"
+        "Lpos7tFxxK9IZ7pKB1qrR1coVWIt78V9lp9WgmBAvxHBSY+tu1lkL/JjLi963/yFdPancZ"
+        "+WHMVfaKlV3gWGpo7EfNK6qAOxI1Ea/eCsE2sYrsHEDvLLGlKAA9E56rmmoe2w6TKzsQjs"
+        "ZM2/XT2eJ82EgMO9pL02iLElXWmGNv72Ut7DouR0pQIT50HIEEKcFxYcoTb3WCfJD76Coe"
+        "sE4kx+TA6d45Xu1bwQNNkTGF+nCCu/GmKY+sECXbz9U6WhxG0YdF9Z4T8YkWYAgpKNS0FW"
+        "RV";
+    size_t pickle_len = _olm_enc_input(
+        PICKLE_KEY, strlen((char *)PICKLE_KEY),
+        pickled, strlen((char *)pickled), NULL
+    );
+
+    olm::Session session;
+    const uint8_t *unpickle_res = olm::unpickle(pickled, pickled+sizeof(pickled), session);
+    assert_equals(
+        pickle_len, (size_t)(unpickle_res - pickled)
+    );
+
+    check_session(session);
+
+#if 0
+    size_t rawlen = olm::pickle_length(session);
+    uint8_t *r1 = _olm_enc_output_pos(pickled, rawlen);
+    olm::pickle(r1, session);
+    _olm_enc_output(
+        PICKLE_KEY, strlen((char *)PICKLE_KEY),
+        pickled, rawlen);
+    printf("%s\n", pickled);
+#endif
+}
+
+{
+    TestCase test_case("V2 session pickle");
+
+    const uint8_t *PICKLE_KEY=(uint8_t *)"secret_key";
+    uint8_t pickled[] =
+        "m+DS/q34MXpw2xp50ZD0B7val1mlMpQXo0mx+VPje0weFYRRuuZQBdJgcFPEpi2MVSpA4c"
+        "qgqHyj2/bU7/lz+BXkEBrCFVx0BJidxXfOLDW4TNtRhLS1YHJNGP8GvTg1+dCytBTLsCdm"
+        "5f945Eq1U/pY3Cg96YTUufFP6EYrfRoDbAsRHc+h+wKKftQv+W44yUmRhcCemGHtpxk3UQ"
+        "AMCI7EBv9BvveyZMy3p9qZ3xvFK34Hef+R7gjtFycz7Nk/4UF46sT3cTmUlXz9iFW4uz2F"
+        "rTI1Wjym+l0DadsbSpHSUjmp9zt4qRP2UjwfZ5QNLv+cdObIfqFsiThGu/PlKigdF4SLHr"
+        "nG";
+
+    size_t pickle_len = _olm_enc_input(
+        PICKLE_KEY, strlen((char *)PICKLE_KEY),
+        pickled, strlen((char *)pickled), NULL
+    );
+
+    olm::Session session;
+    const uint8_t *unpickle_res = olm::unpickle(pickled, pickled+sizeof(pickled), session);
+    assert_equals(
+        pickle_len, (size_t)(unpickle_res - pickled)
+    );
+
+    check_session(session);
+}
+
+
+
+return 0;
+}

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMAccount.h

@@ -0,0 +1,51 @@
+/*
+ Copyright 2016 Chris Ballinger
+ Copyright 2016 OpenMarket Ltd
+ Copyright 2016 Vector Creations Ltd
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import "OLMSerializable.h"
+
+@class OLMSession;
+
+@interface OLMAccount : NSObject <OLMSerializable, NSSecureCoding>
+
+/** Creates new account */
+- (instancetype) initNewAccount;
+
+/** public identity keys. base64 encoded in "curve25519" and "ed25519" keys */
+- (NSDictionary*) identityKeys;
+
+/** signs message with ed25519 key for account */
+- (NSString*) signMessage:(NSData*)messageData;
+
+/** Public parts of the unpublished one time keys for the account */
+- (NSDictionary*) oneTimeKeys;
+
+- (BOOL) removeOneTimeKeysForSession:(OLMSession*)session;
+
+/** Marks the current set of one time keys as being published. */
+- (void) markOneTimeKeysAsPublished;
+
+/** The largest number of one time keys this account can store. */
+- (NSUInteger) maxOneTimeKeys;
+
+/** Generates a number of new one time keys. If the total number of keys stored
+ * by this account exceeds -maxOneTimeKeys then the old keys are
+ * discarded. */
+- (void) generateOneTimeKeys:(NSUInteger)numberOfKeys;
+
+@end

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMAccount_Private.h

@@ -0,0 +1,25 @@
+/*
+ Copyright 2016 Chris Ballinger
+ Copyright 2016 OpenMarket Ltd
+ Copyright 2016 Vector Creations 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.
+ */
+
+#include "olm/olm.h"
+
+@interface OLMAccount()
+
+@property (nonatomic) OlmAccount *account;
+
+@end

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMInboundGroupSession.h

@@ -0,0 +1,38 @@
+/*
+ Copyright 2016 OpenMarket Ltd
+ Copyright 2016 Vector Creations Ltd
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import "OLMSerializable.h"
+
+@interface OLMInboundGroupSession : NSObject <OLMSerializable, NSSecureCoding>
+
+- (instancetype)initInboundGroupSessionWithSessionKey:(NSString*)sessionKey error:(NSError**)error;
+
+- (instancetype)initInboundGroupSessionWithImportedSession:(NSString*)sessionKey error:(NSError**)error;
+
+- (NSString*)sessionIdentifier;
+
+/** base64 ciphertext -> UTF-8 plaintext */
+- (NSString*)decryptMessage:(NSString*)message messageIndex:(NSUInteger*)messageIndex error:(NSError**)error;
+
+- (NSUInteger)firstKnownIndex;
+
+- (BOOL)isVerified;
+
+- (NSString*)exportSessionAtMessageIndex:(NSUInteger)messageIndex error:(NSError**)error;
+
+@end

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMKit.h

@@ -0,0 +1,37 @@
+/*
+ Copyright 2016 Chris Ballinger
+ Copyright 2016 OpenMarket Ltd
+ Copyright 2016 Vector Creations Ltd
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+// In this header, you should import all the public headers of your framework using statements like #import <OLMKit/PublicHeader.h>
+
+#import <OLMKit/OLMAccount.h>
+#import <OLMKit/OLMSession.h>
+#import <OLMKit/OLMMessage.h>
+#import <OLMKit/OLMUtility.h>
+#import <OLMKit/OLMInboundGroupSession.h>
+#import <OLMKit/OLMOutboundGroupSession.h>
+#import <OLMKit/OLMPkEncryption.h>
+#import <OLMKit/OLMPkDecryption.h>
+
+@interface OLMKit : NSObject
+
+//! Project version string for OLMKit, the same as libolm.
++ (NSString*)versionString;
+
+@end

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMMessage.h

@@ -0,0 +1,38 @@
+/*
+ Copyright 2016 Chris Ballinger
+ Copyright 2016 OpenMarket Ltd
+ Copyright 2016 Vector Creations Ltd
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*
+ from olm.hh
+ static const size_t OLM_MESSAGE_TYPE_PRE_KEY = 0;
+ static const size_t OLM_MESSAGE_TYPE_MESSAGE = 1;
+ */
+typedef NS_ENUM(NSInteger, OLMMessageType) {
+    OLMMessageTypePreKey = 0,
+    OLMMessageTypeMessage = 1
+};
+
+@interface OLMMessage : NSObject
+
+@property (nonatomic, copy, readonly, nonnull) NSString *ciphertext;
+@property (readonly) OLMMessageType type;
+
+- (nullable instancetype) initWithCiphertext:(nonnull NSString*)ciphertext type:(OLMMessageType)type;
+
+@end

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMOutboundGroupSession.h

@@ -0,0 +1,32 @@
+/*
+ Copyright 2016 OpenMarket Ltd
+ Copyright 2016 Vector Creations Ltd
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import "OLMSerializable.h"
+
+@interface OLMOutboundGroupSession : NSObject <OLMSerializable, NSSecureCoding>
+
+- (instancetype) initOutboundGroupSession;
+
+- (NSString*)sessionIdentifier;
+- (NSUInteger)messageIndex;
+- (NSString*)sessionKey;
+
+/** UTF-8 plaintext -> base64 ciphertext */
+- (NSString*)encryptMessage:(NSString*)message error:(NSError**)error;
+
+@end

data/ext/ruby_olm/ext_lib_olm/olm/xcode/OLMKit/OLMPkDecryption.h

@@ -0,0 +1,71 @@
+/*
+ Copyright 2018 New Vector Ltd
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "OLMSerializable.h"
+#import "OLMPkMessage.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface OLMPkDecryption : NSObject <OLMSerializable, NSSecureCoding>
+
+/**
+ Initialise the key from the private part of a key as returned by `privateKey`.
+
+ Note that the pubkey is a base64 encoded string, but the private key is
+ an unencoded byte array.
+
+ @param privateKey the private key part.
+ @param error the error if any.
+ @return the associated public key.
+ */
+- (NSString *)setPrivateKey:(NSData*)privateKey error:(NSError* _Nullable *)error;
+
+/**
+ Generate a new key to use for decrypting messages.
+
+ @param error the error if any.
+ @return the public part of the generated key.
+ */
+- (NSString *)generateKey:(NSError* _Nullable *)error;
+
+/**
+ Get the private key.
+
+ @return the private key;
+ */
+- (NSData *)privateKey;
+
+/**
+ Decrypt a ciphertext.
+
+ @param message the cipher message to decrypt.
+ @param error the error if any.
+ @return the decrypted message.
+ */
+- (NSString *)decryptMessage:(OLMPkMessage*)message error:(NSError* _Nullable *)error;
+
+/**
+ Private key length.
+
+ @return the length in bytes.
+ */
++ (NSUInteger)privateKeyLength;
+
+@end
+
+NS_ASSUME_NONNULL_END