From ebc156e7c272e08e375c3e704651b179541e078b Mon Sep 17 00:00:00 2001 From: Hubert Chathi Date: Mon, 8 Apr 2019 15:54:02 -0400 Subject: re-add null termination in javascript because older versions of emscripten don't support the length argument to UTF8ToString. --- javascript/olm_inbound_group_session.js | 15 +++++++++++---- javascript/olm_outbound_group_session.js | 15 +++++++++++---- javascript/olm_pk.js | 32 ++++++++++++++++++++++---------- javascript/olm_post.js | 32 +++++++++++++++++++++++--------- javascript/olm_pre.js | 8 ++++++++ javascript/olm_sas.js | 6 +++--- 6 files changed, 78 insertions(+), 30 deletions(-) (limited to 'javascript') diff --git a/javascript/olm_inbound_group_session.js b/javascript/olm_inbound_group_session.js index 4aa3201..423d2b1 100644 --- a/javascript/olm_inbound_group_session.js +++ b/javascript/olm_inbound_group_session.js @@ -28,7 +28,7 @@ InboundGroupSession.prototype['pickle'] = restore_stack(function(key) { Module['_olm_pickle_inbound_group_session_length'] )(this.ptr); var key_buffer = stack(key_array); - var pickle_buffer = stack(pickle_length); + var pickle_buffer = stack(pickle_length + NULL_BYTE_PADDING_LENGTH); try { inbound_group_session_method(Module['_olm_pickle_inbound_group_session'])( this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length @@ -112,7 +112,7 @@ InboundGroupSession.prototype['decrypt'] = restore_stack(function( // caculating the length destroys the input buffer, so we need to re-copy it. writeAsciiToMemory(message, message_buffer, true); - plaintext_buffer = malloc(max_plaintext_length); + plaintext_buffer = malloc(max_plaintext_length + NULL_BYTE_PADDING_LENGTH); var message_index = stack(4); plaintext_length = inbound_group_session_method( @@ -124,6 +124,13 @@ InboundGroupSession.prototype['decrypt'] = restore_stack(function( message_index ); + // UTF8ToString requires a null-terminated argument, so add the + // null terminator. + setValue( + plaintext_buffer+plaintext_length, + 0, "i8" + ); + return { "plaintext": UTF8ToString(plaintext_buffer, plaintext_length), "message_index": getValue(message_index, "i32") @@ -144,7 +151,7 @@ InboundGroupSession.prototype['session_id'] = restore_stack(function() { var length = inbound_group_session_method( Module['_olm_inbound_group_session_id_length'] )(this.ptr); - var session_id = stack(length); + var session_id = stack(length + NULL_BYTE_PADDING_LENGTH); inbound_group_session_method(Module['_olm_inbound_group_session_id'])( this.ptr, session_id, length ); @@ -161,7 +168,7 @@ InboundGroupSession.prototype['export_session'] = restore_stack(function(message var key_length = inbound_group_session_method( Module['_olm_export_inbound_group_session_length'] )(this.ptr); - var key = stack(key_length); + var key = stack(key_length + NULL_BYTE_PADDING_LENGTH); outbound_group_session_method(Module['_olm_export_inbound_group_session'])( this.ptr, key, key_length, message_index ); diff --git a/javascript/olm_outbound_group_session.js b/javascript/olm_outbound_group_session.js index e4427cc..e4852c1 100644 --- a/javascript/olm_outbound_group_session.js +++ b/javascript/olm_outbound_group_session.js @@ -28,7 +28,7 @@ OutboundGroupSession.prototype['pickle'] = restore_stack(function(key) { Module['_olm_pickle_outbound_group_session_length'] )(this.ptr); var key_buffer = stack(key_array); - var pickle_buffer = stack(pickle_length); + var pickle_buffer = stack(pickle_length + NULL_BYTE_PADDING_LENGTH); try { outbound_group_session_method(Module['_olm_pickle_outbound_group_session'])( this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length @@ -86,13 +86,20 @@ OutboundGroupSession.prototype['encrypt'] = function(plaintext) { plaintext_buffer = malloc(plaintext_length + 1); stringToUTF8(plaintext, plaintext_buffer, plaintext_length + 1); - message_buffer = malloc(message_length); + message_buffer = malloc(message_length + NULL_BYTE_PADDING_LENGTH); outbound_group_session_method(Module['_olm_group_encrypt'])( this.ptr, plaintext_buffer, plaintext_length, message_buffer, message_length ); + // UTF8ToString requires a null-terminated argument, so add the + // null terminator. + setValue( + message_buffer+message_length, + 0, "i8" + ); + return UTF8ToString(message_buffer, message_length); } finally { if (plaintext_buffer !== undefined) { @@ -110,7 +117,7 @@ OutboundGroupSession.prototype['session_id'] = restore_stack(function() { var length = outbound_group_session_method( Module['_olm_outbound_group_session_id_length'] )(this.ptr); - var session_id = stack(length); + var session_id = stack(length + NULL_BYTE_PADDING_LENGTH); outbound_group_session_method(Module['_olm_outbound_group_session_id'])( this.ptr, session_id, length ); @@ -121,7 +128,7 @@ OutboundGroupSession.prototype['session_key'] = restore_stack(function() { var key_length = outbound_group_session_method( Module['_olm_outbound_group_session_key_length'] )(this.ptr); - var key = stack(key_length); + var key = stack(key_length + NULL_BYTE_PADDING_LENGTH); outbound_group_session_method(Module['_olm_outbound_group_session_key'])( this.ptr, key, key_length ); diff --git a/javascript/olm_pk.js b/javascript/olm_pk.js index 8e99494..4690b90 100644 --- a/javascript/olm_pk.js +++ b/javascript/olm_pk.js @@ -45,11 +45,11 @@ PkEncryption.prototype['encrypt'] = restore_stack(function( var ciphertext_length = pk_encryption_method( Module['_olm_pk_ciphertext_length'] )(this.ptr, plaintext_length); - ciphertext_buffer = malloc(ciphertext_length); + ciphertext_buffer = malloc(ciphertext_length + NULL_BYTE_PADDING_LENGTH); var mac_length = pk_encryption_method( Module['_olm_pk_mac_length'] )(this.ptr); - var mac_buffer = stack(mac_length); + var mac_buffer = stack(mac_length + NULL_BYTE_PADDING_LENGTH); setValue( mac_buffer + mac_length, 0, "i8" @@ -57,7 +57,7 @@ PkEncryption.prototype['encrypt'] = restore_stack(function( var ephemeral_length = pk_encryption_method( Module['_olm_pk_key_length'] )(); - var ephemeral_buffer = stack(ephemeral_length); + var ephemeral_buffer = stack(ephemeral_length + NULL_BYTE_PADDING_LENGTH); setValue( ephemeral_buffer + ephemeral_length, 0, "i8" @@ -70,6 +70,12 @@ PkEncryption.prototype['encrypt'] = restore_stack(function( ephemeral_buffer, ephemeral_length, random, random_length ); + // UTF8ToString requires a null-terminated argument, so add the + // null terminator. + setValue( + ciphertext_buffer + ciphertext_length, + 0, "i8" + ); return { "ciphertext": UTF8ToString(ciphertext_buffer, ciphertext_length), "mac": UTF8ToString(mac_buffer, mac_length), @@ -123,7 +129,7 @@ PkDecryption.prototype['init_with_private_key'] = restore_stack(function (privat var pubkey_length = pk_decryption_method( Module['_olm_pk_key_length'] )(); - var pubkey_buffer = stack(pubkey_length); + var pubkey_buffer = stack(pubkey_length + NULL_BYTE_PADDING_LENGTH); try { pk_decryption_method(Module['_olm_pk_key_from_private'])( this.ptr, @@ -145,7 +151,7 @@ PkDecryption.prototype['generate_key'] = restore_stack(function () { var pubkey_length = pk_decryption_method( Module['_olm_pk_key_length'] )(); - var pubkey_buffer = stack(pubkey_length); + var pubkey_buffer = stack(pubkey_length + NULL_BYTE_PADDING_LENGTH); try { pk_decryption_method(Module['_olm_pk_key_from_private'])( this.ptr, @@ -184,7 +190,7 @@ PkDecryption.prototype['pickle'] = restore_stack(function (key) { Module['_olm_pickle_pk_decryption_length'] )(this.ptr); var key_buffer = stack(key_array); - var pickle_buffer = stack(pickle_length); + var pickle_buffer = stack(pickle_length + NULL_BYTE_PADDING_LENGTH); try { pk_decryption_method(Module['_olm_pickle_pk_decryption'])( this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length @@ -207,7 +213,7 @@ PkDecryption.prototype['unpickle'] = restore_stack(function (key, pickle) { var ephemeral_length = pk_decryption_method( Module["_olm_pk_key_length"] )(); - var ephemeral_buffer = stack(ephemeral_length); + var ephemeral_buffer = stack(ephemeral_length + NULL_BYTE_PADDING_LENGTH); try { pk_decryption_method(Module['_olm_unpickle_pk_decryption'])( this.ptr, key_buffer, key_array.length, pickle_buffer, @@ -239,7 +245,7 @@ PkDecryption.prototype['decrypt'] = restore_stack(function ( this.ptr, ciphertext_length ); - plaintext_buffer = malloc(plaintext_max_length); + plaintext_buffer = malloc(plaintext_max_length + NULL_BYTE_PADDING_LENGTH); var plaintext_length = pk_decryption_method(Module['_olm_pk_decrypt'])( this.ptr, ephemeralkey_buffer, ephemeralkey_array.length, @@ -247,6 +253,12 @@ PkDecryption.prototype['decrypt'] = restore_stack(function ( ciphertext_buffer, ciphertext_length, plaintext_buffer, plaintext_max_length ); + // UTF8ToString requires a null-terminated argument, so add the + // null terminator. + setValue( + plaintext_buffer + plaintext_length, + 0, "i8" + ); return UTF8ToString(plaintext_buffer, plaintext_length); } finally { if (plaintext_buffer !== undefined) { @@ -292,7 +304,7 @@ PkSigning.prototype['init_with_seed'] = restore_stack(function (seed) { var pubkey_length = pk_signing_method( Module['_olm_pk_signing_public_key_length'] )(); - var pubkey_buffer = stack(pubkey_length); + var pubkey_buffer = stack(pubkey_length + NULL_BYTE_PADDING_LENGTH); try { pk_signing_method(Module['_olm_pk_signing_key_from_seed'])( this.ptr, @@ -333,7 +345,7 @@ PkSigning.prototype['sign'] = restore_stack(function (message) { var sig_length = pk_signing_method( Module['_olm_pk_signature_length'] )(); - var sig_buffer = stack(sig_length); + var sig_buffer = stack(sig_length + NULL_BYTE_PADDING_LENGTH); pk_signing_method(Module['_olm_pk_sign'])( this.ptr, message_buffer, message_length, diff --git a/javascript/olm_post.js b/javascript/olm_post.js index 8460893..ad058d9 100644 --- a/javascript/olm_post.js +++ b/javascript/olm_post.js @@ -77,7 +77,7 @@ Account.prototype['identity_keys'] = restore_stack(function() { var keys_length = account_method( Module['_olm_account_identity_keys_length'] )(this.ptr); - var keys = stack(keys_length); + var keys = stack(keys_length + NULL_BYTE_PADDING_LENGTH); account_method(Module['_olm_account_identity_keys'])( this.ptr, keys, keys_length ); @@ -90,7 +90,7 @@ Account.prototype['sign'] = restore_stack(function(message) { )(this.ptr); var message_array = array_from_string(message); var message_buffer = stack(message_array); - var signature_buffer = stack(signature_length); + var signature_buffer = stack(signature_length + NULL_BYTE_PADDING_LENGTH); try { account_method(Module['_olm_account_sign'])( this.ptr, @@ -111,7 +111,7 @@ Account.prototype['one_time_keys'] = restore_stack(function() { var keys_length = account_method( Module['_olm_account_one_time_keys_length'] )(this.ptr); - var keys = stack(keys_length); + var keys = stack(keys_length + NULL_BYTE_PADDING_LENGTH); account_method(Module['_olm_account_one_time_keys'])( this.ptr, keys, keys_length ); @@ -152,7 +152,7 @@ Account.prototype['pickle'] = restore_stack(function(key) { Module['_olm_pickle_account_length'] )(this.ptr); var key_buffer = stack(key_array); - var pickle_buffer = stack(pickle_length); + var pickle_buffer = stack(pickle_length + NULL_BYTE_PADDING_LENGTH); try { account_method(Module['_olm_pickle_account'])( this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length @@ -216,7 +216,7 @@ Session.prototype['pickle'] = restore_stack(function(key) { Module['_olm_pickle_session_length'] )(this.ptr); var key_buffer = stack(key_array); - var pickle_buffer = stack(pickle_length); + var pickle_buffer = stack(pickle_length + NULL_BYTE_PADDING_LENGTH); try { session_method(Module['_olm_pickle_session'])( this.ptr, key_buffer, key_array.length, pickle_buffer, pickle_length @@ -316,7 +316,7 @@ Session.prototype['create_inbound_from'] = restore_stack(function( Session.prototype['session_id'] = restore_stack(function() { var id_length = session_method(Module['_olm_session_id_length'])(this.ptr); - var id_buffer = stack(id_length); + var id_buffer = stack(id_length + NULL_BYTE_PADDING_LENGTH); session_method(Module['_olm_session_id'])( this.ptr, id_buffer, id_length ); @@ -378,7 +378,7 @@ Session.prototype['encrypt'] = restore_stack(function( plaintext_buffer = malloc(plaintext_length + 1); stringToUTF8(plaintext, plaintext_buffer, plaintext_length + 1); - message_buffer = malloc(message_length); + message_buffer = malloc(message_length + NULL_BYTE_PADDING_LENGTH); session_method(Module['_olm_encrypt'])( this.ptr, @@ -387,6 +387,13 @@ Session.prototype['encrypt'] = restore_stack(function( message_buffer, message_length ); + // UTF8ToString requires a null-terminated argument, so add the + // null terminator. + setValue( + message_buffer+message_length, + 0, "i8" + ); + return { "type": message_type, "body": UTF8ToString(message_buffer, message_length), @@ -423,7 +430,7 @@ Session.prototype['decrypt'] = restore_stack(function( // caculating the length destroys the input buffer, so we need to re-copy it. writeAsciiToMemory(message, message_buffer, true); - plaintext_buffer = malloc(max_plaintext_length); + plaintext_buffer = malloc(max_plaintext_length + NULL_BYTE_PADDING_LENGTH); var plaintext_length = session_method(Module["_olm_decrypt"])( this.ptr, message_type, @@ -431,6 +438,13 @@ Session.prototype['decrypt'] = restore_stack(function( plaintext_buffer, max_plaintext_length ); + // UTF8ToString requires a null-terminated argument, so add the + // null terminator. + setValue( + plaintext_buffer+plaintext_length, + 0, "i8" + ); + return UTF8ToString(plaintext_buffer, plaintext_length); } finally { if (message_buffer !== undefined) { @@ -473,7 +487,7 @@ Utility.prototype['sha256'] = restore_stack(function(input) { var output_length = utility_method(Module['_olm_sha256_length'])(this.ptr); var input_array = array_from_string(input); var input_buffer = stack(input_array); - var output_buffer = stack(output_length); + var output_buffer = stack(output_length + NULL_BYTE_PADDING_LENGTH); try { utility_method(Module['_olm_sha256'])( this.ptr, diff --git a/javascript/olm_pre.js b/javascript/olm_pre.js index 7153f7a..314d7da 100644 --- a/javascript/olm_pre.js +++ b/javascript/olm_pre.js @@ -30,6 +30,14 @@ if (typeof(OLM_OPTIONS) !== 'undefined') { } } +/* The 'length' argument to Pointer_stringify doesn't work if the input + * includes characters >= 128, which makes Pointer_stringify unreliable. We + * could use it on strings which are known to be ascii, but that seems + * dangerous. Instead we add a NULL character to all of our strings and just + * use UTF8ToString. + */ +var NULL_BYTE_PADDING_LENGTH = 1; + Module['onRuntimeInitialized'] = function() { OLM_ERROR = Module['_olm_error'](); olm_exports["PRIVATE_KEY_LENGTH"] = Module['_olm_pk_private_key_length'](); diff --git a/javascript/olm_sas.js b/javascript/olm_sas.js index a01cc07..5cf3fb0 100644 --- a/javascript/olm_sas.js +++ b/javascript/olm_sas.js @@ -28,7 +28,7 @@ SAS.prototype['free'] = function() { SAS.prototype['get_pubkey'] = restore_stack(function() { var pubkey_length = sas_method(Module['_olm_sas_pubkey_length'])(this.ptr); - var pubkey_buffer = stack(pubkey_length); + var pubkey_buffer = stack(pubkey_length + NULL_BYTE_PADDING_LENGTH); sas_method(Module['_olm_sas_get_pubkey'])(this.ptr, pubkey_buffer, pubkey_length); return UTF8ToString(pubkey_buffer, pubkey_length); }); @@ -66,7 +66,7 @@ SAS.prototype['calculate_mac'] = restore_stack(function(input, info) { var info_array = array_from_string(info); var info_buffer = stack(info_array); var mac_length = sas_method(Module['_olm_sas_mac_length'])(this.ptr); - var mac_buffer = stack(mac_length); + var mac_buffer = stack(mac_length + NULL_BYTE_PADDING_LENGTH); sas_method(Module['_olm_sas_calculate_mac'])( this.ptr, input_buffer, input_array.length, @@ -89,5 +89,5 @@ SAS.prototype['calculate_mac_long_kdf'] = restore_stack(function(input, info) { info_buffer, info_array.length, mac_buffer, mac_length ); - return Pointer_stringify(mac_buffer); + return UTF8ToString(mac_buffer, mac_length); }); -- cgit v1.2.3