From 122867c45c7f41b82a550a9665d34b7dda1c3ffa Mon Sep 17 00:00:00 2001
From: David Baker <dave@matrix.org>
Date: Fri, 21 Sep 2018 16:01:51 +0100
Subject: WebAssembly support!

Quite a lot going on in this PR:
 * Updates to support recent emscripten, switching to WASM which is now the default
 * Use emscripten's MODULARIZE option rather than wrapping it ourself, since doing
   so in pre-post js doesn't work anymore.
 * Most changes are moving the emscripten runtime functions to top-level
   calls rather than in the Module object.
 * Get rid of duplicated NULL_BYTE_PADDING_LENGTH
 * Fix ciphertext_length used without being declared
 * Fix things that caused the closure compiler to error, eg. using
   OLM_OPTIONS without a declaration.
 * Wait until module is inited to do OLM_ERROR = olm_error()

The main BREAKING CHANGE here is that the module now needs to initialise
asyncronously (because it has to load the wasm file). require()ing olm
now gives a function which needs to be called to create an instance.
The resulting object has a promise-like then() method that can be used
to detect when the module is ready. (We could use MODULARIZE_INSTANCE
to return the module directly as before, rather than the function,
but then we don't get the .then() method).
---
 javascript/test/megolm.spec.js |  7 +++++--
 javascript/test/olm.spec.js    | 10 ++++++++--
 javascript/test/pk.spec.js     |  8 ++++++--
 3 files changed, 19 insertions(+), 6 deletions(-)

(limited to 'javascript/test')

diff --git a/javascript/test/megolm.spec.js b/javascript/test/megolm.spec.js
index 8f9d24a..9d5eb72 100644
--- a/javascript/test/megolm.spec.js
+++ b/javascript/test/megolm.spec.js
@@ -16,12 +16,15 @@ limitations under the License.
 
 "use strict";
 
-var Olm = require('../olm');
+var Olm = require('../olm')();
 
 describe("megolm", function() {
     var aliceSession, bobSession;
 
-    beforeEach(function() {
+    beforeEach(function(done) {
+        Olm.then(function() {
+            done();
+        });
         aliceSession = new Olm.OutboundGroupSession();
         bobSession = new Olm.InboundGroupSession();
     });
diff --git a/javascript/test/olm.spec.js b/javascript/test/olm.spec.js
index b7cc3ae..94fa87b 100644
--- a/javascript/test/olm.spec.js
+++ b/javascript/test/olm.spec.js
@@ -16,7 +16,7 @@ limitations under the License.
 
 "use strict";
 
-var Olm = require('../olm');
+var Olm = require('../olm')();
 
 if (!Object.keys) {
     Object.keys = function(o) {
@@ -30,7 +30,13 @@ describe("olm", function() {
     var aliceAccount, bobAccount;
     var aliceSession, bobSession;
 
-    beforeEach(function() {
+    beforeEach(function(done) {
+        // This should really be in a beforeAll, but jasmine-node
+        // doesn't support that
+        Olm.then(function() {
+            done();
+        });
+
         aliceAccount = new Olm.Account();
         bobAccount = new Olm.Account();
         aliceSession = new Olm.Session();
diff --git a/javascript/test/pk.spec.js b/javascript/test/pk.spec.js
index aec90ac..9f7dbfd 100644
--- a/javascript/test/pk.spec.js
+++ b/javascript/test/pk.spec.js
@@ -16,7 +16,7 @@ limitations under the License.
 
 "use strict";
 
-var Olm = require('../olm');
+var Olm = require('../olm')();
 
 if (!Object.keys) {
     Object.keys = function(o) {
@@ -29,7 +29,11 @@ if (!Object.keys) {
 describe("pk", function() {
     var encryption, decryption;
 
-    beforeEach(function() {
+    beforeEach(function(done) {
+        Olm.then(function() {
+            done();
+        });
+
         encryption = new Olm.PkEncryption();
         decryption = new Olm.PkDecryption();
     });
-- 
cgit v1.2.3-70-g09d2


From 263b94428a24caaa5b899ed7f73b896620e6cdf4 Mon Sep 17 00:00:00 2001
From: David Baker <dave@matrix.org>
Date: Tue, 25 Sep 2018 17:13:29 +0100
Subject: Another day, another interface

Change the interface again, hopefully this time a bit more normal.
Now we wrap the emscripten module completely and just expose the
high level objects.

The olm library export is now imported as normal (ie. returns
a module rather than a function returning a module) but has an
`init` method which *must* be called. This returns a promise
which resolves when the module is ready. It also rejects if the
module failed to set up, unlike before (and unlike the
promise-not-a-promise that emscripten returns).

Generally catch failures to init the module.
---
 Makefile                       | 28 +++++++++++++++++++++++++++-
 javascript/externs.js          |  3 +++
 javascript/olm_post.js         | 30 +++++++-----------------------
 javascript/olm_pre.js          |  1 -
 javascript/olm_prefix.js       |  3 +++
 javascript/olm_suffix.js       | 23 +++++++++++++++++++++++
 javascript/test/megolm.spec.js | 10 ++++++----
 javascript/test/olm.spec.js    | 16 +++++++++-------
 javascript/test/pk.spec.js     | 10 +++++-----
 9 files changed, 83 insertions(+), 41 deletions(-)
 create mode 100644 javascript/olm_prefix.js
 create mode 100644 javascript/olm_suffix.js

(limited to 'javascript/test')

diff --git a/Makefile b/Makefile
index dcd5cc1..d99c8fc 100644
--- a/Makefile
+++ b/Makefile
@@ -41,11 +41,22 @@ FUZZER_BINARIES := $(addprefix $(BUILD_DIR)/,$(basename $(FUZZER_SOURCES)))
 FUZZER_DEBUG_BINARIES := $(patsubst $(BUILD_DIR)/fuzzers/fuzz_%,$(BUILD_DIR)/fuzzers/debug_%,$(FUZZER_BINARIES))
 TEST_BINARIES := $(patsubst tests/%,$(BUILD_DIR)/tests/%,$(basename $(TEST_SOURCES)))
 JS_OBJECTS := $(addprefix $(BUILD_DIR)/javascript/,$(OBJECTS))
+
+# pre & post are the js-pre/js-post options to emcc.
+# They are injected inside the modularised code and
+# processed by the optimiser.
 JS_PRE := $(wildcard javascript/*pre.js)
 JS_POST := javascript/olm_outbound_group_session.js \
     javascript/olm_inbound_group_session.js \
     javascript/olm_pk.js \
     javascript/olm_post.js
+
+# The prefix & suffix are just added onto the start & end
+# of what comes out emcc, so are outside of the modularised
+# code and not seen by the opimiser.
+JS_PREFIX := javascript/olm_prefix.js
+JS_SUFFIX := javascript/olm_suffix.js
+
 DOCS := tracing/README.html \
     docs/megolm.html \
     docs/olm.html \
@@ -67,6 +78,15 @@ EMCCFLAGS = --closure 1 --memory-init-file 0 -s NO_FILESYSTEM=1 -s INVOKE_RUN=0
 # longer needed.
 EMCCFLAGS += -s NO_BROWSER=1
 
+# Olm generally doesn't need a lot of memory to encrypt / decrypt its usual
+# payloads (ie. Matrix messages), but we do need about 128K of heap to encrypt
+# a 64K event (enough to store the ciphertext and the plaintext, bearing in
+# mind that the plaintext can only be 48K because base64). We also have about
+# 36K of statics. So let's have 256K of memory.
+# (This can't be changed by the app with wasm since it's baked into the wasm).
+EMCCFLAGS += -s TOTAL_STACK=65536 -s TOTAL_MEMORY=262144
+
+
 EMCC.c = $(EMCC) $(CFLAGS) $(CPPFLAGS) -c
 EMCC.cc = $(EMCC) $(CXXFLAGS) $(CPPFLAGS) -c
 EMCC_LINK = $(EMCC) $(LDFLAGS) $(EMCCFLAGS)
@@ -147,13 +167,19 @@ $(STATIC_RELEASE_TARGET): $(RELEASE_OBJECTS)
 js: $(JS_TARGET)
 .PHONY: js
 
-$(JS_TARGET): $(JS_OBJECTS) $(JS_PRE) $(JS_POST) $(JS_EXPORTED_FUNCTIONS)
+# Note that the output file we give to emcc determines the name of the
+# wasm file baked into the js, hence messing around outputting to olm.js
+# and then renaming it.
+$(JS_TARGET): $(JS_OBJECTS) $(JS_PRE) $(JS_POST) $(JS_EXPORTED_FUNCTIONS) $(JS_PREFIX) $(JS_SUFFIX)
 	EMCC_CLOSURE_ARGS="--externs $(JS_EXTERNS)" $(EMCC_LINK) \
                $(foreach f,$(JS_PRE),--pre-js $(f)) \
                $(foreach f,$(JS_POST),--post-js $(f)) \
                -s "EXPORTED_FUNCTIONS=@$(JS_EXPORTED_FUNCTIONS)" \
                -s "EXTRA_EXPORTED_RUNTIME_METHODS=$(JS_EXTRA_EXPORTED_RUNTIME_METHODS)" \
                $(JS_OBJECTS) -o $@
+	       mv $@ javascript/olmtmp.js
+	       cat $(JS_PREFIX) javascript/olmtmp.js $(JS_SUFFIX) > $@
+	       rm javascript/olmtmp.js
 
 build_tests: $(TEST_BINARIES)
 
diff --git a/javascript/externs.js b/javascript/externs.js
index 8ec5b02..752e937 100644
--- a/javascript/externs.js
+++ b/javascript/externs.js
@@ -1 +1,4 @@
 var OLM_OPTIONS;
+var olm_exports;
+var onInitSuccess;
+var onInitFail;
diff --git a/javascript/olm_post.js b/javascript/olm_post.js
index 071021c..9e0294a 100644
--- a/javascript/olm_post.js
+++ b/javascript/olm_post.js
@@ -464,27 +464,11 @@ olm_exports["get_library_version"] = restore_stack(function() {
     ];
 });
 
-// export the olm functions into the environment.
-//
-// make sure that we do this *after* populating olm_exports, so that we don't
-// get a half-built window.Olm if there is an exception.
-
-if (typeof module !== 'undefined' && module.exports) {
-    // node / browserify
-    for (var olm_export in olm_exports) {
-        if (olm_exports.hasOwnProperty(olm_export)) {
-            Module[olm_export] = olm_exports[olm_export];
-        }
-    }
-}
-
-if (typeof(window) !== 'undefined') {
-    // We've been imported directly into a browser. Define the global 'Olm' object.
-    // (we do this even if module.exports was defined, because it's useful to have
-    // Olm in the global scope for browserified and webpacked apps.)
-    window["Olm"] = olm_exports;
-}
-
-Module.then(function() {
+Module['onRuntimeInitialized'] = function() {
     OLM_ERROR = Module['_olm_error']();
-});
+    if (onInitSuccess) onInitSuccess();
+};
+
+Module['onAbort'] = function(err) {
+    if (onInitFail) onInitFail(err);
+};
diff --git a/javascript/olm_pre.js b/javascript/olm_pre.js
index 673b868..4feff97 100644
--- a/javascript/olm_pre.js
+++ b/javascript/olm_pre.js
@@ -1,4 +1,3 @@
-var olm_exports = {};
 var get_random_values;
 
 if (typeof(window) !== 'undefined') {
diff --git a/javascript/olm_prefix.js b/javascript/olm_prefix.js
new file mode 100644
index 0000000..b33dfe9
--- /dev/null
+++ b/javascript/olm_prefix.js
@@ -0,0 +1,3 @@
+var olm_exports = {};
+var onInitSuccess;
+var onInitFail;
diff --git a/javascript/olm_suffix.js b/javascript/olm_suffix.js
new file mode 100644
index 0000000..023c0a5
--- /dev/null
+++ b/javascript/olm_suffix.js
@@ -0,0 +1,23 @@
+olm_exports['init'] = function() {
+    return new Promise(function(resolve, reject) {
+        onInitSuccess = function() {
+            resolve();
+        };
+        onInitFail = function(err) {
+            reject(err);
+        };
+        Module();
+    });
+};
+
+if (typeof(window) !== 'undefined') {
+    // We've been imported directly into a browser. Define the global 'Olm' object.
+    // (we do this even if module.exports was defined, because it's useful to have
+    // Olm in the global scope for browserified and webpacked apps.)
+    window["Olm"] = olm_exports;
+}
+
+// Emscripten sets the module exports to be its module
+// with wrapped c functions. Clobber it with our higher
+// level wrapper class.
+module.exports = olm_exports;
diff --git a/javascript/test/megolm.spec.js b/javascript/test/megolm.spec.js
index 9d5eb72..241d4bd 100644
--- a/javascript/test/megolm.spec.js
+++ b/javascript/test/megolm.spec.js
@@ -1,5 +1,6 @@
 /*
 Copyright 2016 OpenMarket Ltd
+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.
@@ -16,17 +17,18 @@ limitations under the License.
 
 "use strict";
 
-var Olm = require('../olm')();
+var Olm = require('../olm');
 
 describe("megolm", function() {
     var aliceSession, bobSession;
 
     beforeEach(function(done) {
-        Olm.then(function() {
+        Olm.init().then(function() {
+            aliceSession = new Olm.OutboundGroupSession();
+            bobSession = new Olm.InboundGroupSession();
+
             done();
         });
-        aliceSession = new Olm.OutboundGroupSession();
-        bobSession = new Olm.InboundGroupSession();
     });
 
     afterEach(function() {
diff --git a/javascript/test/olm.spec.js b/javascript/test/olm.spec.js
index 94fa87b..77dd712 100644
--- a/javascript/test/olm.spec.js
+++ b/javascript/test/olm.spec.js
@@ -1,5 +1,6 @@
 /*
 Copyright 2016 OpenMarket Ltd
+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.
@@ -16,7 +17,7 @@ limitations under the License.
 
 "use strict";
 
-var Olm = require('../olm')();
+var Olm = require('../olm');
 
 if (!Object.keys) {
     Object.keys = function(o) {
@@ -33,14 +34,15 @@ describe("olm", function() {
     beforeEach(function(done) {
         // This should really be in a beforeAll, but jasmine-node
         // doesn't support that
-        Olm.then(function() {
+        debugger;
+        Olm.init().then(function() {
+            aliceAccount = new Olm.Account();
+            bobAccount = new Olm.Account();
+            aliceSession = new Olm.Session();
+            bobSession = new Olm.Session();
+
             done();
         });
-
-        aliceAccount = new Olm.Account();
-        bobAccount = new Olm.Account();
-        aliceSession = new Olm.Session();
-        bobSession = new Olm.Session();
     });
 
     afterEach(function() {
diff --git a/javascript/test/pk.spec.js b/javascript/test/pk.spec.js
index 9f7dbfd..007882f 100644
--- a/javascript/test/pk.spec.js
+++ b/javascript/test/pk.spec.js
@@ -16,7 +16,7 @@ limitations under the License.
 
 "use strict";
 
-var Olm = require('../olm')();
+var Olm = require('../olm');
 
 if (!Object.keys) {
     Object.keys = function(o) {
@@ -30,12 +30,12 @@ describe("pk", function() {
     var encryption, decryption;
 
     beforeEach(function(done) {
-        Olm.then(function() {
+        Olm.init().then(function() {
+            encryption = new Olm.PkEncryption();
+            decryption = new Olm.PkDecryption();
+
             done();
         });
-
-        encryption = new Olm.PkEncryption();
-        decryption = new Olm.PkDecryption();
     });
 
     afterEach(function () {
-- 
cgit v1.2.3-70-g09d2


From 0346145a813cfb719fdf218956cb2f29030134a8 Mon Sep 17 00:00:00 2001
From: David Baker <dave@matrix.org>
Date: Tue, 2 Oct 2018 12:02:56 +0100
Subject: Work with PkDecryption keys by their private keys

Change interface to allow the app to get the private part of the
key and instantiate a decryption object from just the private part
of the key.

Changes the function generating a key from random bytes to be
initialising a key with a private key (because it's exactly the
same thing). Exports & imports private key parts as ArrayBuffer at
JS level rather than base64 assuming we are moving that way in
general.
---
 include/olm/error.h        |  7 +++++++
 include/olm/pk.h           | 41 ++++++++++++++++++++++++++++++-----------
 javascript/olm_pk.js       | 32 ++++++++++++++++++++++++++++++--
 javascript/test/pk.spec.js | 14 ++++++++++++++
 src/error.c                |  1 +
 src/pk.cpp                 | 29 +++++++++++++++++++++++------
 tests/test_pk.cpp          |  9 +++++++--
 7 files changed, 112 insertions(+), 21 deletions(-)

(limited to 'javascript/test')

diff --git a/include/olm/error.h b/include/olm/error.h
index 9d44a94..ee2187c 100644
--- a/include/olm/error.h
+++ b/include/olm/error.h
@@ -51,6 +51,13 @@ enum OlmErrorCode {
      */
     OLM_BAD_SIGNATURE = 14,
 
+    OLM_INPUT_BUFFER_TOO_SMALL = 15,
+
+    // Not an error code, just here to pad out the enum past 16 because
+    // otherwise the compiler warns about a redunant check. If you're
+    // adding an error code, replace this one!
+    OLM_ERROR_NOT_INVENTED_YET = 16,
+
     /* remember to update the list of string constants in error.c when updating
      * this list. */
 };
diff --git a/include/olm/pk.h b/include/olm/pk.h
index 1f3f9ff..5e779ce 100644
--- a/include/olm/pk.h
+++ b/include/olm/pk.h
@@ -76,7 +76,7 @@ size_t olm_pk_encrypt_random_length(
  * ciphertext, mac, or ephemeral_key buffers were too small then
  * olm_pk_encryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL". If there
  * weren't enough random bytes then olm_pk_encryption_last_error() will be
- * "NOT_ENOUGH_RANDOM". */
+ * "OLM_INPUT_BUFFER_TOO_SMALL". */
 size_t olm_pk_encrypt(
     OlmPkEncryption *encryption,
     void const * plaintext, size_t plaintext_length,
@@ -108,18 +108,24 @@ size_t olm_clear_pk_decryption(
     OlmPkDecryption *decryption
 );
 
-/** The number of random bytes needed to generate a new key. */
-size_t olm_pk_generate_key_random_length(void);
-
-/** Generate a new key to use for decrypting messages. The associated public
- * key will be written to the pubkey buffer. Returns olm_error() on failure. If
- * the pubkey buffer is too small then olm_pk_decryption_last_error() will be
- * "OUTPUT_BUFFER_TOO_SMALL". If there weren't enough random bytes then
- * olm_pk_decryption_last_error() will be "NOT_ENOUGH_RANDOM". */
-size_t olm_pk_generate_key(
+/** Get the number of bytes required to store an olm private key
+ */
+size_t olm_pk_private_key_length();
+
+/** Initialise the key from the private part of a key as returned by
+ * olm_pk_get_private_key(). The associated public key will be written to the
+ * pubkey buffer. Returns olm_error() on failure. If the pubkey buffer is too
+ * small then olm_pk_decryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL".
+ * If the private key was not long enough then olm_pk_decryption_last_error()
+ * will be "OLM_INPUT_BUFFER_TOO_SMALL".
+ *
+ * Note that the pubkey is a base64 encoded string, but the private key is
+ * an unencoded byte array
+ */
+size_t olm_pk_key_from_private(
     OlmPkDecryption * decryption,
     void * pubkey, size_t pubkey_length,
-    void * random, size_t random_length
+    void * privkey, size_t privkey_length
 );
 
 /** Returns the number of bytes needed to store a decryption object. */
@@ -171,6 +177,19 @@ size_t olm_pk_decrypt(
     void * plaintext, size_t max_plaintext_length
 );
 
+/**
+ * Get the private key for an OlmDecryption object as an unencoded byte array
+ * private_key must be a pointer to a buffer of at least
+ * olm_pk_private_key_length() bytes and this length must be passed in
+ * private_key_length. If the given buffer is too small, returns olm_error()
+ * and olm_pk_encryption_last_error() will be "OUTPUT_BUFFER_TOO_SMALL".
+ * Returns the number of bytes written.
+ */
+size_t olm_pk_get_private_key(
+    OlmPkDecryption * decryption,
+    void *private_key, size_t private_key_length
+);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/javascript/olm_pk.js b/javascript/olm_pk.js
index 25e0fee..2212470 100644
--- a/javascript/olm_pk.js
+++ b/javascript/olm_pk.js
@@ -118,16 +118,32 @@ PkDecryption.prototype['free'] = function() {
     free(this.ptr);
 }
 
+PkDecryption.prototype['init_with_private_key'] = restore_stack(function (private_key) {
+    var private_key_buffer = stack(private_key.length);
+    Module['HEAPU8'].set(private_key, private_key_buffer);
+
+    var pubkey_length = pk_decryption_method(
+        Module['_olm_pk_key_length']
+    )();
+    var pubkey_buffer = stack(pubkey_length + NULL_BYTE_PADDING_LENGTH);
+    pk_decryption_method(Module['_olm_pk_key_from_private'])(
+        this.ptr,
+        pubkey_buffer, pubkey_length,
+        private_key_buffer, private_key.length
+    );
+    return Pointer_stringify(pubkey_buffer);
+});
+
 PkDecryption.prototype['generate_key'] = restore_stack(function () {
     var random_length = pk_decryption_method(
-        Module['_olm_pk_generate_key_random_length']
+        Module['_olm_pk_private_key_length']
     )();
     var random_buffer = random_stack(random_length);
     var pubkey_length = pk_encryption_method(
         Module['_olm_pk_key_length']
     )();
     var pubkey_buffer = stack(pubkey_length + NULL_BYTE_PADDING_LENGTH);
-    pk_decryption_method(Module['_olm_pk_generate_key'])(
+    pk_decryption_method(Module['_olm_pk_key_from_private'])(
         this.ptr,
         pubkey_buffer, pubkey_length,
         random_buffer, random_length
@@ -135,6 +151,18 @@ PkDecryption.prototype['generate_key'] = restore_stack(function () {
     return Pointer_stringify(pubkey_buffer);
 });
 
+PkDecryption.prototype['get_private_key'] = restore_stack(function () {
+    var privkey_length = pk_encryption_method(
+        Module['_olm_pk_private_key_length']
+    )();
+    var privkey_buffer  = stack(privkey_length);
+    pk_decryption_method(Module['_olm_pk_get_private_key'])(
+        this.ptr,
+        privkey_buffer, privkey_length
+    );
+    return new Uint8Array(Module['HEAPU8'].buffer, privkey_buffer, privkey_length);
+});
+
 PkDecryption.prototype['pickle'] = restore_stack(function (key) {
     var key_array = array_from_string(key);
     var pickle_length = pk_decryption_method(
diff --git a/javascript/test/pk.spec.js b/javascript/test/pk.spec.js
index 007882f..d155cf5 100644
--- a/javascript/test/pk.spec.js
+++ b/javascript/test/pk.spec.js
@@ -49,6 +49,20 @@ describe("pk", function() {
         }
     });
 
+    it('should import & export keys from private parts', function () {
+        var alice_private = new Uint8Array([
+            0x77, 0x07, 0x6D, 0x0A, 0x73, 0x18, 0xA5, 0x7D,
+            0x3C, 0x16, 0xC1, 0x72, 0x51, 0xB2, 0x66, 0x45,
+            0xDF, 0x4C, 0x2F, 0x87, 0xEB, 0xC0, 0x99, 0x2A,
+            0xB1, 0x77, 0xFB, 0xA5, 0x1D, 0xB9, 0x2C, 0x2A
+        ]);
+        var alice_public = decryption.init_with_private_key(alice_private);
+        expect(alice_public).toEqual("hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo");
+
+        var alice_private_out = decryption.get_private_key();
+        expect(alice_private_out).toEqual(alice_private);
+    });
+
     it('should encrypt and decrypt', function () {
         var TEST_TEXT='têst1';
         var pubkey = decryption.generate_key();
diff --git a/src/error.c b/src/error.c
index f541a93..5147b5c 100644
--- a/src/error.c
+++ b/src/error.c
@@ -31,6 +31,7 @@ static const char * ERRORS[] = {
     "UNKNOWN_MESSAGE_INDEX",
     "BAD_LEGACY_ACCOUNT_PICKLE",
     "BAD_SIGNATURE",
+    "OLM_INPUT_BUFFER_TOO_SMALL",
 };
 
 const char * _olm_error_to_string(enum OlmErrorCode error)
diff --git a/src/pk.cpp b/src/pk.cpp
index e646dc4..20ab991 100644
--- a/src/pk.cpp
+++ b/src/pk.cpp
@@ -176,7 +176,7 @@ size_t olm_clear_pk_decryption(
     return sizeof(OlmPkDecryption);
 }
 
-size_t olm_pk_generate_key_random_length(void) {
+size_t olm_pk_private_key_length(void) {
     return CURVE25519_KEY_LENGTH;
 }
 
@@ -184,23 +184,23 @@ size_t olm_pk_key_length(void) {
     return olm::encode_base64_length(CURVE25519_KEY_LENGTH);
 }
 
-size_t olm_pk_generate_key(
+size_t olm_pk_key_from_private(
     OlmPkDecryption * decryption,
     void * pubkey, size_t pubkey_length,
-    void * random, size_t random_length
+    void * privkey, size_t privkey_length
 ) {
     if (pubkey_length < olm_pk_key_length()) {
         decryption->last_error =
             OlmErrorCode::OLM_OUTPUT_BUFFER_TOO_SMALL;
         return std::size_t(-1);
     }
-    if (random_length < olm_pk_generate_key_random_length()) {
+    if (privkey_length < olm_pk_private_key_length()) {
         decryption->last_error =
-            OlmErrorCode::OLM_NOT_ENOUGH_RANDOM;
+            OlmErrorCode::OLM_INPUT_BUFFER_TOO_SMALL;
         return std::size_t(-1);
     }
 
-    _olm_crypto_curve25519_generate_key((uint8_t *) random, &decryption->key_pair);
+    _olm_crypto_curve25519_generate_key((uint8_t *) privkey, &decryption->key_pair);
     olm::encode_base64((const uint8_t *)decryption->key_pair.public_key.public_key, CURVE25519_KEY_LENGTH, (uint8_t *)pubkey);
     return 0;
 }
@@ -352,4 +352,21 @@ size_t olm_pk_decrypt(
     }
 }
 
+size_t olm_pk_get_private_key(
+    OlmPkDecryption * decryption,
+    void *private_key, size_t private_key_length
+) {
+    if (private_key_length < olm_pk_private_key_length()) {
+        decryption->last_error =
+            OlmErrorCode::OLM_OUTPUT_BUFFER_TOO_SMALL;
+        return std::size_t(-1);
+    }
+    std::memcpy(
+        private_key,
+        decryption->key_pair.private_key.private_key,
+        olm_pk_private_key_length()
+    );
+    return olm_pk_private_key_length();
+}
+
 }
diff --git a/tests/test_pk.cpp b/tests/test_pk.cpp
index ee12603..42cc8c9 100644
--- a/tests/test_pk.cpp
+++ b/tests/test_pk.cpp
@@ -36,7 +36,7 @@ const std::uint8_t *bob_public = (std::uint8_t *) "3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbe
 
 std::uint8_t pubkey[::olm_pk_key_length()];
 
-olm_pk_generate_key(
+olm_pk_key_from_private(
     decryption,
     pubkey, sizeof(pubkey),
     alice_private, sizeof(alice_private)
@@ -44,6 +44,11 @@ olm_pk_generate_key(
 
 assert_equals(alice_public, pubkey, olm_pk_key_length());
 
+uint8_t *alice_private_back_out = (uint8_t *)malloc(olm_pk_private_key_length());
+olm_pk_get_private_key(decryption, alice_private_back_out, olm_pk_private_key_length());
+assert_equals(alice_private, alice_private_back_out, olm_pk_private_key_length());
+free(alice_private_back_out);
+
 std::uint8_t encryption_buffer[olm_pk_encryption_size()];
 OlmPkEncryption *encryption = olm_pk_encryption(encryption_buffer);
 
@@ -105,7 +110,7 @@ const std::uint8_t *alice_public = (std::uint8_t *) "hSDwCYkwp1R0i33ctD73Wg2/Og0
 
 std::uint8_t pubkey[olm_pk_key_length()];
 
-olm_pk_generate_key(
+olm_pk_key_from_private(
     decryption,
     pubkey, sizeof(pubkey),
     alice_private, sizeof(alice_private)
-- 
cgit v1.2.3-70-g09d2


From bad14db8dadac46fef2c1c7094c92831b4bed0fb Mon Sep 17 00:00:00 2001
From: Hubert Chathi <hubert@uhoreg.ca>
Date: Mon, 9 Jul 2018 23:35:40 -0400
Subject: remove unneeded polyfill

---
 javascript/test/pk.spec.js | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'javascript/test')

diff --git a/javascript/test/pk.spec.js b/javascript/test/pk.spec.js
index aec90ac..0b27470 100644
--- a/javascript/test/pk.spec.js
+++ b/javascript/test/pk.spec.js
@@ -18,14 +18,6 @@ limitations under the License.
 
 var Olm = require('../olm');
 
-if (!Object.keys) {
-    Object.keys = function(o) {
-        var k=[], p;
-        for (p in o) if (Object.prototype.hasOwnProperty.call(o,p)) k.push(p);
-        return k;
-    }
-}
-
 describe("pk", function() {
     var encryption, decryption;
 
-- 
cgit v1.2.3-70-g09d2