From a2f0c93a93f6914291954b08a7518b4f17561c11 Mon Sep 17 00:00:00 2001 From: Richard van der Hoff Date: Fri, 6 Jan 2017 17:40:39 +0000 Subject: Implement importing group session data olm_import_inbound_group_session, which reads the format written by olm_export_inbound_group_session to initialise a group session. --- include/olm/inbound_group_session.h | 20 +++++++++++++++++- javascript/olm_inbound_group_session.js | 9 +++++++++ python/.gitignore | 1 + python/olm/__main__.py | 26 ++++++++++++++++++++++++ python/olm/inbound_group_session.py | 10 +++++++++ python/test_olm.sh | 13 ++++++++---- src/inbound_group_session.c | 36 ++++++++++++++++++++++++++++----- 7 files changed, 105 insertions(+), 10 deletions(-) diff --git a/include/olm/inbound_group_session.h b/include/olm/inbound_group_session.h index d47af8a..739a89b 100644 --- a/include/olm/inbound_group_session.h +++ b/include/olm/inbound_group_session.h @@ -85,7 +85,8 @@ size_t olm_unpickle_inbound_group_session( /** - * Start a new inbound group session, based on the parameters supplied. + * Start a new inbound group session, from a key exported from + * olm_outbound_group_session_key * * Returns olm_error() on failure. On failure last_error will be set with an * error code. The last_error will be: @@ -99,6 +100,23 @@ size_t olm_init_inbound_group_session( uint8_t const * session_key, size_t session_key_length ); +/** + * Import an inbound group session, from a previous export. + * + * Returns olm_error() on failure. On failure last_error will be set with an + * error code. The last_error will be: + * + * * OLM_INVALID_BASE64 if the session_key is not valid base64 + * * OLM_BAD_SESSION_KEY if the session_key is invalid + */ +size_t olm_import_inbound_group_session( + OlmInboundGroupSession *session, + /* base64-encoded keys; note that it will be overwritten with the base64-decoded + data. */ + uint8_t const * session_key, size_t session_key_length +); + + /** * Get an upper bound on the number of bytes of plain-text the decrypt method * will write for a given input message length. The actual size could be diff --git a/javascript/olm_inbound_group_session.js b/javascript/olm_inbound_group_session.js index 8721a10..6bc745d 100644 --- a/javascript/olm_inbound_group_session.js +++ b/javascript/olm_inbound_group_session.js @@ -61,6 +61,15 @@ InboundGroupSession.prototype['create'] = restore_stack(function(session_key) { ); }); +InboundGroupSession.prototype['import_session'] = restore_stack(function(session_key) { + var key_array = array_from_string(session_key); + var key_buffer = stack(key_array); + + inbound_group_session_method(Module['_olm_import_inbound_group_session'])( + this.ptr, key_buffer, key_array.length + ); +}); + InboundGroupSession.prototype['decrypt'] = restore_stack(function( message ) { diff --git a/python/.gitignore b/python/.gitignore index b8ca4f7..a3d197d 100644 --- a/python/.gitignore +++ b/python/.gitignore @@ -2,3 +2,4 @@ /*.account /*.session /*.group_session +/group_message diff --git a/python/olm/__main__.py b/python/olm/__main__.py index f195591..5f78f76 100755 --- a/python/olm/__main__.py +++ b/python/olm/__main__.py @@ -268,6 +268,19 @@ def build_arg_parser(): default=sys.stdin) inbound_group.set_defaults(func=do_inbound_group) + import_inbound_group = commands.add_parser( + "import_inbound_group", + help="Create an inbound group session based an exported inbound group" + ) + import_inbound_group.add_argument("session_file", help="Local inbound group session file") + import_inbound_group.add_argument( + "export_file", + help="File to read credentials from (default stdin)", + type=argparse.FileType('r'), nargs='?', + default=sys.stdin, + ) + import_inbound_group.set_defaults(func=do_import_inbound_group) + group_decrypt = commands.add_parser("group_decrypt", help="Decrypt a group message") group_decrypt.add_argument("session_file", help="Local inbound group session file") group_decrypt.add_argument("message_file", help="Message file (default stdin)", @@ -345,6 +358,19 @@ def do_inbound_group(args): with open(args.session_file, "wb") as f: f.write(session.pickle(args.key)) +def do_import_inbound_group(args): + if os.path.exists(args.session_file): + sys.stderr.write("Session %r file already exists\n" % ( + args.session_file, + )) + sys.exit(1) + data = args.export_file.read().translate(None, "\r\n") + + session = InboundGroupSession() + session.import_session(data) + with open(args.session_file, "wb") as f: + f.write(session.pickle(args.key)) + def do_group_decrypt(args): session = InboundGroupSession() session.unpickle(args.key, read_base64_file(args.session_file)) diff --git a/python/olm/inbound_group_session.py b/python/olm/inbound_group_session.py index 67906b2..4390b34 100644 --- a/python/olm/inbound_group_session.py +++ b/python/olm/inbound_group_session.py @@ -36,6 +36,10 @@ inbound_group_session_function( lib.olm_init_inbound_group_session, c_void_p, c_size_t ) +inbound_group_session_function( + lib.olm_import_inbound_group_session, c_void_p, c_size_t +) + inbound_group_session_function( lib.olm_group_decrypt_max_plaintext_length, c_void_p, c_size_t ) @@ -83,6 +87,12 @@ class InboundGroupSession(object): self.ptr, key_buffer, len(session_key) ) + def import_session(self, session_key): + key_buffer = create_string_buffer(session_key) + lib.olm_import_inbound_group_session( + self.ptr, key_buffer, len(session_key) + ) + def decrypt(self, message): message_buffer = create_string_buffer(message) max_plaintext_length = lib.olm_group_decrypt_max_plaintext_length( diff --git a/python/test_olm.sh b/python/test_olm.sh index 989e166..7c90daf 100755 --- a/python/test_olm.sh +++ b/python/test_olm.sh @@ -10,10 +10,11 @@ ALICE_GROUP_SESSION=alice.group_session BOB_ACCOUNT=bob.account BOB_SESSION=bob.session BOB_GROUP_SESSION=bob.group_session +CHARLIE_GROUP_SESSION=charlie.group_session -rm $ALICE_ACCOUNT $BOB_ACCOUNT -rm $ALICE_SESSION $BOB_SESSION -rm $ALICE_GROUP_SESSION $BOB_GROUP_SESSION +rm -f $ALICE_ACCOUNT $BOB_ACCOUNT +rm -f $ALICE_SESSION $BOB_SESSION +rm -f $ALICE_GROUP_SESSION $BOB_GROUP_SESSION $CHARLIE_GROUP_SESSION $OLM create_account $ALICE_ACCOUNT $OLM create_account $BOB_ACCOUNT @@ -31,4 +32,8 @@ echo "Hello world" | $OLM encrypt $ALICE_SESSION - - | $OLM inbound $BOB_ACCOUNT $OLM outbound_group $ALICE_GROUP_SESSION $OLM group_credentials $ALICE_GROUP_SESSION | $OLM inbound_group $BOB_GROUP_SESSION -echo "Hello group" | $OLM group_encrypt $ALICE_GROUP_SESSION - - | $OLM group_decrypt $BOB_GROUP_SESSION +echo "Hello group" | $OLM group_encrypt $ALICE_GROUP_SESSION - group_message +$OLM group_decrypt $BOB_GROUP_SESSION group_message + +$OLM export_inbound_group $BOB_GROUP_SESSION | $OLM import_inbound_group $CHARLIE_GROUP_SESSION +$OLM group_decrypt $CHARLIE_GROUP_SESSION group_message diff --git a/src/inbound_group_session.c b/src/inbound_group_session.c index 122c26c..be0984c 100644 --- a/src/inbound_group_session.c +++ b/src/inbound_group_session.c @@ -79,15 +79,17 @@ size_t olm_clear_inbound_group_session( (1 + 4 + MEGOLM_RATCHET_LENGTH + ED25519_PUBLIC_KEY_LENGTH\ + ED25519_SIGNATURE_LENGTH) -/** init the session keys from the un-base64-ed session keys */ static size_t _init_group_session_keys( OlmInboundGroupSession *session, - const uint8_t *key_buf + const uint8_t *key_buf, + int export_format ) { + const uint8_t expected_version = + (export_format ? SESSION_EXPORT_VERSION : SESSION_KEY_VERSION); const uint8_t *ptr = key_buf; size_t version = *ptr++; - if (version != SESSION_KEY_VERSION) { + if (version != expected_version) { session->last_error = OLM_BAD_SESSION_KEY; return (size_t)-1; } @@ -107,7 +109,7 @@ static size_t _init_group_session_keys( ); ptr += ED25519_PUBLIC_KEY_LENGTH; - if (!_olm_crypto_ed25519_verify( + if (!export_format && !_olm_crypto_ed25519_verify( &session->signing_key, key_buf, ptr - key_buf, ptr )) { session->last_error = OLM_BAD_SIGNATURE; @@ -135,11 +137,35 @@ size_t olm_init_inbound_group_session( } _olm_decode_base64(session_key, session_key_length, key_buf); - result = _init_group_session_keys(session, key_buf); + result = _init_group_session_keys(session, key_buf, 0); _olm_unset(key_buf, SESSION_KEY_RAW_LENGTH); return result; } +size_t olm_import_inbound_group_session( + OlmInboundGroupSession *session, + const uint8_t * session_key, size_t session_key_length +) { + uint8_t key_buf[SESSION_EXPORT_RAW_LENGTH]; + size_t raw_length = _olm_decode_base64_length(session_key_length); + size_t result; + + if (raw_length == (size_t)-1) { + session->last_error = OLM_INVALID_BASE64; + return (size_t)-1; + } + + if (raw_length != SESSION_EXPORT_RAW_LENGTH) { + session->last_error = OLM_BAD_SESSION_KEY; + return (size_t)-1; + } + + _olm_decode_base64(session_key, session_key_length, key_buf); + result = _init_group_session_keys(session, key_buf, 1); + _olm_unset(key_buf, SESSION_EXPORT_RAW_LENGTH); + return result; +} + static size_t raw_pickle_length( const OlmInboundGroupSession *session ) { -- cgit v1.2.3