From 1f7b19512cfa7e1b153b99d6a2b40bad82a5496e Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Thu, 26 Apr 2018 17:13:34 +0200
Subject: js: created TestExtension and smaller fixes

--

* Extensions:

  - Moved testapplication to Demoextension
  - Created BrowserTestExtension.
    Includes mocha and chai. For running tests that cannot be run
    outside a WebExtension

  Both Extensions can be found zipped in build/extensions after
  running build_extensions.sh

* Code changes:
  - src/Config: Place for the configuration
  - small fixes raised during testing in Keyring.js, Message.js,
  - src/gpgmejs_openpgpjs.js don't offer direct GpgME object to the
    outside, as it only causes confusion
  - index.js init() now checks the config for validity

* Tests:
  - Reordered tests in test/.
  - Input values are now in a separate file which may be of use for
    bulk testing

* moved the build directory from dist to build
---
 lang/js/BrowserTestExtension/browsertest.html | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 lang/js/BrowserTestExtension/browsertest.html

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
new file mode 100644
index 00000000..d2c6396f
--- /dev/null
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <link href="libs/mocha.css" rel="stylesheet" />
+    </head>
+<body>
+    <h3>Browsertest</h3>
+    <div id="mocha"></div>
+    <!-- load unit tests -->
+    <script src="libs/mocha.js"></script>
+    <script src="libs/chai.js"></script>
+    <script src="setup_testing.js"></script>
+    <script src="libs/gpgmejs.bundle.js"></script>
+
+    <script src="tests/inputvalues.js"></script>
+<!-- insert tests here-->
+    <script src="tests/startup.js"></script>
+    <script src="tests/encryptTest.js"></script>
+<!-- run tests -->
+    <script src="runbrowsertest.js"></script>
+    </body>
+</html>
-- 
cgit 


From c755287ba845c4cbbf1d50e5aafecb2e687c7ac9 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Thu, 3 May 2018 18:03:22 +0200
Subject: js: Added browser testing for unit tests

--

* Added unittests to be run inside a Browser. To be able to access
  the non-exposed functions and classes, a testing bundle will be
  created, containing the tests (unittests.js) and the items to be
  tested.
* src/Helpelpers, src/Key, src/Keyring: fixed some errors found
  during testing.
---
 lang/js/BrowserTestExtension/browsertest.html     |   2 +
 lang/js/BrowserTestExtension/runbrowsertest.js    |   1 +
 lang/js/BrowserTestExtension/tests/encryptTest.js |  14 +-
 lang/js/README_testing                            |  14 +
 lang/js/build_extensions.sh                       |   4 +-
 lang/js/src/Helpers.js                            |   4 +-
 lang/js/src/Key.js                                |  11 +-
 lang/js/src/Keyring.js                            |   2 +-
 lang/js/unittest_inputvalues.js                   |  45 +++
 lang/js/unittests.js                              | 321 ++++++++++++++++++++++
 lang/js/webpack.conf_unittests.js                 |  34 +++
 11 files changed, 436 insertions(+), 16 deletions(-)
 create mode 100644 lang/js/README_testing
 create mode 100644 lang/js/unittest_inputvalues.js
 create mode 100644 lang/js/unittests.js
 create mode 100644 lang/js/webpack.conf_unittests.js

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index d2c6396f..ce037a11 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -14,9 +14,11 @@
     <script src="libs/gpgmejs.bundle.js"></script>
 
     <script src="tests/inputvalues.js"></script>
+    <script src="libs/gpgmejs_unittests.bundle.js"></script>
 <!-- insert tests here-->
     <script src="tests/startup.js"></script>
     <script src="tests/encryptTest.js"></script>
+
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
     </body>
diff --git a/lang/js/BrowserTestExtension/runbrowsertest.js b/lang/js/BrowserTestExtension/runbrowsertest.js
index 39bc3fb9..308c716d 100644
--- a/lang/js/BrowserTestExtension/runbrowsertest.js
+++ b/lang/js/BrowserTestExtension/runbrowsertest.js
@@ -19,3 +19,4 @@
  */
 
 mocha.run();
+Gpgmejs_test.unittests();
diff --git a/lang/js/BrowserTestExtension/tests/encryptTest.js b/lang/js/BrowserTestExtension/tests/encryptTest.js
index e6000003..2178efac 100644
--- a/lang/js/BrowserTestExtension/tests/encryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptTest.js
@@ -18,8 +18,7 @@
  * SPDX-License-Identifier: LGPL-2.1+
  */
 describe('Encryption', function(){
-
-    it('Successfull encrypt', function(done){
+    it('Successfull encrypt', function(){
         let prm = Gpgmejs.init();
         prm.then(function(context){
             context.encrypt(
@@ -29,10 +28,6 @@ describe('Encryption', function(){
                     expect(answer.data).to.be.a("string");
                     expect(answer.data).to.include('BEGIN PGP MESSAGE');
                     expect(answer.data).to.include('END PGP MESSAGE');
-                    done();
-                }, function(err){
-                    expect(err).to.be.undefined;
-                    done();
                 });
         });
     });
@@ -44,11 +39,10 @@ describe('Encryption', function(){
                 inputvalues.encrypt.good.data,
                 null).then(function(answer){
                     expect(answer).to.be.undefined;
-                    done();
                 }, function(error){
                     expect(error).to.be.an('Error');
                     expect(error.code).to.equal('MSG_INCOMPLETE');
-                    done()
+                    //TODO: MSG_INCOMPLETE desired, GNUPG_ERROR coming
                 });
         });
     });
@@ -61,11 +55,9 @@ describe('Encryption', function(){
                     expect(answer).to.be.undefined;
                 }, function(error){
                     expect(error).to.be.an.instanceof(Error);
-                    expect(error.code).to.equal('MSG_INCOMPLETE');
-                    done();
+                    expect(error.code).to.equal('PARAM_WRONG');
                 });
         });
     });
-
     // TODO check different valid parameter
 });
diff --git a/lang/js/README_testing b/lang/js/README_testing
new file mode 100644
index 00000000..b61ca1a6
--- /dev/null
+++ b/lang/js/README_testing
@@ -0,0 +1,14 @@
+Test extension:
+
+The test extension contains tests with mocha and chai. It will be packed as an
+extra extension (see build_extension.sh).
+
+Tests from BrowserTestExtension/tests will be run against the gpgmejs.bundle.js
+itself. They aim to test the outward facing functionality and API.
+
+Unittests as defined in ./unittests.js will be bundled in
+gpgmejs_unittests.bundle.js, and test the separate components of gpgmejs,
+which mostly are not exported.
+
+The BrowserExtension can be installed the same way as the DemoExtension
+(see README).
\ No newline at end of file
diff --git a/lang/js/build_extensions.sh b/lang/js/build_extensions.sh
index b99a362c..91d5479b 100755
--- a/lang/js/build_extensions.sh
+++ b/lang/js/build_extensions.sh
@@ -1,11 +1,13 @@
 #/!bin/bash
 
 npx webpack --config webpack.conf.js
+npx webpack --config webpack.conf_unittests.js
 mkdir -p BrowserTestExtension/libs
 cp node_modules/chai/chai.js \
     node_modules/mocha/mocha.css \
     node_modules/mocha/mocha.js \
-    build/gpgmejs.bundle.js BrowserTestExtension/libs
+    build/gpgmejs.bundle.js \
+    build/gpgmejs_unittests.bundle.js BrowserTestExtension/libs
 rm -rf build/extensions
 mkdir -p build/extensions
 zip -r build/extensions/browsertest.zip BrowserTestExtension
diff --git a/lang/js/src/Helpers.js b/lang/js/src/Helpers.js
index 9a69f851..ea056fff 100644
--- a/lang/js/src/Helpers.js
+++ b/lang/js/src/Helpers.js
@@ -91,9 +91,9 @@ export function isFingerprint(string){
     return hextest(string, 40);
 };
 /**
- * check if the input is a valid Hex string with a length of 16
+ *  TODO no usage; check if the input is a valid Hex string with a length of 16
  */
-export function isLongId(string){
+function isLongId(string){
     return hextest(string, 16);
 };
 
diff --git a/lang/js/src/Key.js b/lang/js/src/Key.js
index 1e0d3195..6d3cf17d 100644
--- a/lang/js/src/Key.js
+++ b/lang/js/src/Key.js
@@ -61,6 +61,9 @@ export class GPGME_Key {
     }
 
     get connection(){
+        if (!this._fingerprint){
+            return gpgme_error('KEY_INVALID');
+        }
         if (!this._connection instanceof Connection){
             return gpgme_error('CONN_NO_CONNECT');
         } else {
@@ -75,6 +78,9 @@ export class GPGME_Key {
     }
 
     get fingerprint(){
+        if (!this._fingerprint){
+            return gpgme_error('KEY_INVALID');
+        }
         return this._fingerprint;
     }
 
@@ -125,7 +131,7 @@ export class GPGME_Key {
         let msg = createMessage ('export_key');
         msg.setParameter('armor', true);
         if (msg instanceof Error){
-            return gpgme_error('INVALID_KEY');
+            return gpgme_error('KEY_INVALID');
         }
         this.connection.post(msg).then(function(result){
             return result.data;
@@ -203,6 +209,9 @@ export class GPGME_Key {
     * TODO: check if Promise.then(return)
     */
     checkKey(property){
+        if (!this._fingerprint){
+            return gpgme_error('KEY_INVALID');
+        }
         return gpgme_error('NOT_YET_IMPLEMENTED');
         // TODO: async is not what is to be ecpected from Key information :(
         if (!property || typeof(property) !== 'string' ||
diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js
index 2cf87c24..4596035a 100644
--- a/lang/js/src/Keyring.js
+++ b/lang/js/src/Keyring.js
@@ -20,7 +20,7 @@
 
 import {createMessage} from './Message'
 import {GPGME_Key} from './Key'
-import { isFingerprint, isLongId } from './Helpers';
+import { isFingerprint } from './Helpers';
 import { gpgme_error } from './Errors';
 import { Connection } from './Connection';
 
diff --git a/lang/js/unittest_inputvalues.js b/lang/js/unittest_inputvalues.js
new file mode 100644
index 00000000..3450afd2
--- /dev/null
+++ b/lang/js/unittest_inputvalues.js
@@ -0,0 +1,45 @@
+import {Connection} from "./src/Connection";
+import {createKey} from "./src/Key";
+
+let conn = new Connection;
+
+export const helper_params = {
+    validLongId: '0A0A0A0A0A0A0A0A',
+    validKeys: ['A1E3BC45BDC8E87B74F4392D53B151A1368E50F3',
+        createKey('ADDBC303B6D31026F5EB4591A27EABDF283121BB', conn),
+        'EE17AEE730F88F1DE7713C54BBE0A4FF7851650A'],
+    validFingerprint: '9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A',
+    validFingerprints: ['9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A9A9A7A7A8A',
+        '9AAE7A338A9A9A7A7A8A9A9A7A7A8A9A9A7A7DDA'],
+    invalidLongId: '9A9A7A7A8A9A9A7A7A8A',
+    invalidFingerprints: [{hello:'World'}, ['kekekeke'], new Uint32Array(40)],
+    invalidKeyArray: {curiosity:'uncat'},
+    invalidKeyArray_OneBad: [
+        createKey('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08', conn),
+        'E1D18E6E994FA9FE9360Bx0E687B940FEFEB095A',
+        '3AEA7FE4F5F416ED18CEC63DD519450D9C0FAEE5'],
+    invalidErrorCode: 'Please type in all your passwords.',
+    validGPGME_Key: createKey('ADDBC303B6D31026F5EB4591A27EABDF283121BB', conn),
+    valid_openpgplike: { primaryKey: {
+        getFingerprint: function(){
+            return '85DE2A8BA5A5AB3A8A7BE2000B8AED24D7534BC2';}
+        }
+    }
+}
+
+export const message_params = {
+    invalid_op_action : 'dance',
+    invalid_op_type : [234, 34, '<>'],
+    valid_encrypt_data: "مرحبا بالعالم",
+    invalid_param_test: {
+        valid_op: 'encrypt',
+        invalid_param_names: [22,'dance', {}],
+        validparam_name_0: 'mime',
+        invalid_values_0: [2134, 'All your passwords',
+            createKey('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08', conn), null]
+    }
+}
+
+export const whatever_params = {
+    four_invalid_params: ['<(((-<', '>°;==;~~', '^^', '{{{{o}}}}']
+}
diff --git a/lang/js/unittests.js b/lang/js/unittests.js
new file mode 100644
index 00000000..0a1b4b48
--- /dev/null
+++ b/lang/js/unittests.js
@@ -0,0 +1,321 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+import "./node_modules/mocha/mocha";
+import "./node_modules/chai/chai";
+import { helper_params as hp } from "./unittest_inputvalues";
+import { message_params as mp } from "./unittest_inputvalues";
+import { whatever_params as wp } from "./unittest_inputvalues";
+import { Connection } from "./src/Connection";
+import { gpgme_error } from "./src/Errors";
+import { toKeyIdArray , isFingerprint } from "./src/Helpers";
+import { GPGME_Key , createKey } from "./src/Key";
+import { GPGME_Keyring } from "./src/Keyring";
+import {GPGME_Message, createMessage} from "./src/Message";
+import { setTimeout } from "timers";
+
+mocha.setup('bdd');
+var expect = chai.expect;
+chai.config.includeStack = true;
+
+function unittests (){
+    describe('Connection testing', function(){
+
+        it('Connecting', function(done) {
+            let conn0 = new Connection;
+            let delayed = function(){
+                expect(conn0.isConnected).to.be.true;
+                expect(conn0.connect).to.be.a('function');
+                expect(conn0.disconnect).to.be.a('function');
+                expect(conn0.post).to.be.a('function');
+                done();
+            };
+            setTimeout(delayed, 5);
+
+        });
+
+        it('Disconnecting', function(done) {
+            let conn0 = new Connection;
+            let delayed = function(){
+                conn0.disconnect(); // TODO fails!
+                expect(conn0.isConnected).to.be.false;
+                done();
+            };
+            setTimeout(delayed, 5);
+        });
+
+        // broken
+        // it('Connect info still only available after a delay', function(done){
+        //     // if false, all delayed connections can be refactored
+        //     let conn0 = new Connection;
+        //     expect(conn0.isConnected).to.be.undefined;
+        //  //
+        // })
+    });
+
+    describe('Error Object handling', function(){
+
+        it('check the Timeout error', function(){
+            let test0 = gpgme_error('CONN_TIMEOUT');
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('CONN_TIMEOUT');
+        });
+
+        it('Error Object returns generic code if code is not listed', function(){
+            let test0 = gpgme_error(hp.invalidErrorCode);
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('GENERIC_ERROR');
+        });
+
+        it('Warnings like PARAM_IGNORED should not return errors', function(){
+            let test0 = gpgme_error('PARAM_IGNORED');
+
+            expect(test0).to.be.null;
+        });
+    });
+
+    describe('Fingerprint checking', function(){
+
+        it('isFingerprint(): valid Fingerprint', function(){
+            let test0  = isFingerprint(hp.validFingerprint);
+
+            expect(test0).to.be.true;
+        });
+
+        it('isFingerprint(): invalid Fingerprints', function(){
+            for (let i=0; i < hp.invalidFingerprints.length; i++){
+                let test0 = isFingerprint(hp.invalidFingerprints[i]);
+
+                expect(test0).to.be.false;
+            }
+        });
+    });
+
+    describe('toKeyIdArray() (converting input to fingerprint', function(){
+
+        it('Correct fingerprint string', function(){
+            let test0 = toKeyIdArray(hp.validFingerprint);
+
+            expect(test0).to.be.an('array');
+            expect(test0).to.include(hp.validFingerprint);
+        });
+
+        it('correct GPGME_Key', function(){
+            expect(hp.validGPGME_Key).to.be.an.instanceof(GPGME_Key);
+            let test0 = toKeyIdArray(hp.validGPGME_Key);
+
+            expect(test0).to.be.an('array');
+            expect(test0).to.include(hp.validGPGME_Key.fingerprint);
+        });
+
+        it('openpgpjs-like object', function(){
+            let test0 = toKeyIdArray(hp.valid_openpgplike);
+
+            expect(test0).to.be.an('array').with.lengthOf(1);
+            console.log(test0);
+            expect(test0).to.include(
+                hp.valid_openpgplike.primaryKey.getFingerprint());
+        });
+
+        it('Array of valid inputs', function(){
+            let test0 = toKeyIdArray(hp.validKeys);
+            expect(test0).to.be.an('array');
+            expect(test0).to.have.lengthOf(hp.validKeys.length);
+        });
+
+        it('Incorrect inputs', function(){
+
+            it('valid Long ID', function(){
+                let test0 = toKeyIdArray(hp.validLongId);
+
+                expect(test0).to.be.empty;
+            });
+
+            it('invalidFingerprint', function(){
+                let test0 = toKeyIdArray(hp.invalidFingerprint);
+
+                expect(test0).to.be.empty;
+            });
+
+            it('invalidKeyArray', function(){
+                let test0 = toKeyIdArray(hp.invalidKeyArray);
+
+                expect(test0).to.be.empty;
+            });
+
+            it('Partially invalid array', function(){
+                let test0 = toKeyIdArray(hp.invalidKeyArray_OneBad);
+
+                expect(test0).to.be.an('array');
+                expect(test0).to.have.lengthOf(
+                    hp.invalidKeyArray_OneBad.length - 1);
+            });
+        });
+    });
+
+    describe('GPGME_Key', function(){
+
+        it('correct Key initialization', function(){
+            let conn = new Connection;
+            let key = createKey(hp.validFingerprint, conn);
+
+            expect(key).to.be.an.instanceof(GPGME_Key);
+            expect(key.connection).to.be.an.instanceof(Connection);
+            // TODO not implemented yet: Further Key functionality
+        });
+
+        it('Key can use the connection', function(){
+            let conn = new Connection;
+            let key = createKey(hp.validFingerprint, conn);
+
+            expect(key.connection.isConnected).to.be.true;
+
+            key.connection.disconnect();
+            expect(key.connection.isConnected).to.be.false;
+        });
+
+        it('createKey returns error if parameters are wrong', function(){
+            let conn = new Connection;
+            for (let i=0; i< 4; i++){
+                let key0 = createKey(wp.four_invalid_params[i], conn);
+
+                expect(key0).to.be.an.instanceof(Error);
+                expect(key0.code).to.equal('PARAM_WRONG');
+            }
+            for (let i=0; i< 4; i++){
+                let key0 = createKey(
+                    hp.validFingerprint, wp.four_invalid_params[i]);
+
+                expect(key0).to.be.an.instanceof(Error);
+                expect(key0.code).to.equal('PARAM_WRONG');
+            }
+        });
+        it('bad GPGME_Key returns Error if used', function(){
+            let conn = new Connection;
+            for (let i=0; i < 4; i++){
+                let key = new GPGME_Key(wp.four_invalid_params[i], conn);
+
+                expect(key.connection).to.be.an.instanceof(Error);
+                expect(key.connection.code).to.equal('KEY_INVALID');
+            }
+        });
+    });
+
+    describe('GPGME_Keyring', function(){
+
+        it('correct initialization', function(){
+            let conn = new Connection;
+            let keyring = new GPGME_Keyring(conn);
+
+            expect(keyring).to.be.an.instanceof(GPGME_Keyring);
+            expect(keyring.connection).to.be.an.instanceof(Connection);
+            expect(keyring.getKeys).to.be.a('function');
+            expect(keyring.getSubset).to.be.a('function');
+        });
+
+        it('Keyring should return errors if not connected', function(){
+            let keyring = new GPGME_Keyring;
+
+            expect(keyring).to.be.an.instanceof(GPGME_Keyring);
+            expect(keyring.connection).to.be.an.instanceof(Error);
+            expect(keyring.connection.code).to.equal('CONN_NO_CONNECT');
+            expect(keyring.getKeys).to.be.an.instanceof(Error);
+            expect(keyring.getkeys.code).to.equal('CONN_NO_CONNECT');
+        });
+            //TODO not yet implemented:
+            //  getKeys(pattern, include_secret) //note: pattern can be null
+            //  getSubset(flags, pattern)
+                // available Boolean flags: secret revoked expired
+    });
+
+    describe('GPGME_Message', function(){
+
+        it('creating encrypt Message', function(){
+            let test0 = createMessage('encrypt');
+
+            expect(test0).to.be.an.instanceof(GPGME_Message);
+            expect(test0.isComplete).to.be.false;
+        });
+
+        it('Message is complete after setting mandatoy data', function(){
+            let test0 = createMessage('encrypt');
+            test0.setParameter('data', mp.valid_encrypt_data);
+            test0.setParameter('keys', hp.validFingerprints);
+
+            expect(test0.isComplete).to.be.true;
+        });
+
+        it('Complete Message contains the data that was set', function(){
+            let test0 = createMessage('encrypt');
+            test0.setParameter('data', mp.valid_encrypt_data);
+            test0.setParameter('keys', hp.validFingerprints);
+
+            expect(test0.message).to.not.be.null;
+            expect(test0.message).to.have.keys('op', 'data', 'keys');
+            expect(test0.message.op).to.equal('encrypt');
+            expect(test0.message.data).to.equal(
+                mp.valid_encrypt_data);
+        });
+
+        it ('Not accepting non-allowed operation', function(){
+            let test0 = createMessage(mp.invalid_op_action);
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('MSG_WRONG_OP');
+        });
+        it('Not accepting wrong parameter type', function(){
+            let test0 = createMessage(mp.invalid_op_type);
+
+            expect(test0).to.be.an.instanceof(Error);
+            expect(test0.code).to.equal('PARAM_WRONG');
+        });
+
+        it('Not accepting wrong parameter name', function(){
+            let test0 = createMessage(mp.invalid_param_test.valid_op);
+            for (let i=0;
+                i < mp.invalid_param_test.invalid_param_names.length; i++){
+                    let ret = test0.setParameter(
+                        mp.invalid_param_test.invalid_param_names[i],
+                        'Somevalue');
+
+                    expect(ret).to.be.an.instanceof(Error);
+                    expect(ret.code).to.equal('PARAM_WRONG');
+            }
+        });
+
+        it('Not accepting wrong parameter value', function(){
+            let test0 = createMessage(mp.invalid_param_test.valid_op);
+            for (let j=0;
+                j < mp.invalid_param_test.invalid_values_0.length; j++){
+                    let ret = test0.setParameter(
+                        mp.invalid_param_test.validparam_name_0,
+                        mp.invalid_param_test.invalid_values_0[j]);
+
+                    expect(ret).to.be.an.instanceof(Error);
+                    expect(ret.code).to.equal('PARAM_WRONG');
+            }
+        });
+    });
+
+    mocha.run();
+}
+
+export default {unittests};
\ No newline at end of file
diff --git a/lang/js/webpack.conf_unittests.js b/lang/js/webpack.conf_unittests.js
new file mode 100644
index 00000000..4b903be6
--- /dev/null
+++ b/lang/js/webpack.conf_unittests.js
@@ -0,0 +1,34 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ *
+ * This is the configuration file for building the gpgmejs-Library with webpack
+ */
+const path = require('path');
+
+module.exports = {
+  entry: './unittests.js',
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, 'build'),
+    filename: 'gpgmejs_unittests.bundle.js',
+    libraryTarget: 'var',
+    libraryExport: 'default',
+    library: 'Gpgmejs_test'
+  }
+};
-- 
cgit 


From 8f3d83e5f0903323ec92f588f60dcecb0ae96de4 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Mon, 7 May 2018 18:27:25 +0200
Subject: js: fixing errors found by testing: encrypt/decrypt

--

* Key.js: Error code for wrong parameter in createKey should be
  "PARAM_WRONG"
* Helpers.js: The property openpgpjs-like Objects were checked for in
  toKeyIdArray was not defined.
* src/permittedOperations.js: updated more expectations and assumptions
  for the native API

* new Problems:
  - There seems to be a message size limit of about 21 MB for
    nativeMessaging, much lower than the documented 4GB.
  - Some bytes are lost with random data in an encrypt-decrypt
    roundtrip. The culprit is unclear.
---
 lang/js/BrowserTestExtension/browsertest.html      |   1 +
 .../tests/encryptDecryptTest.js                    |  72 +++++++++++++
 lang/js/BrowserTestExtension/tests/encryptTest.js  | 114 ++++++++++++++++++---
 lang/js/BrowserTestExtension/tests/inputvalues.js  |  12 +++
 lang/js/src/Connection.js                          |  13 ++-
 lang/js/src/Message.js                             |  19 +++-
 lang/js/unittests.js                               |  11 +-
 7 files changed, 219 insertions(+), 23 deletions(-)
 create mode 100644 lang/js/BrowserTestExtension/tests/encryptDecryptTest.js

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index ce037a11..d12e03cf 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -18,6 +18,7 @@
 <!-- insert tests here-->
     <script src="tests/startup.js"></script>
     <script src="tests/encryptTest.js"></script>
+    <script src="tests/encryptDecryptTest.js"></script>
 
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
diff --git a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
new file mode 100644
index 00000000..7abf2d94
--- /dev/null
+++ b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
@@ -0,0 +1,72 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+describe('Encryption and Decryption', function () {
+    it('Successful encrypt and decrypt', function (done) {
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            context.encrypt(
+                inputvalues.encrypt.good.data,
+                inputvalues.encrypt.good.fingerprint).then( function(answer){
+                    expect(answer).to.not.be.empty;
+                    expect(answer.data).to.be.a("string");
+                    expect(answer.data).to.include('BEGIN PGP MESSAGE');
+                    expect(answer.data).to.include('END PGP MESSAGE');
+                    context.decrypt(answer.data).then(function(result){
+                        expect(result).to.not.be.empty;
+                        expect(result.data).to.be.a('string');
+                        expect(result.data).to.equal(inputvalues.encrypt.good.data);
+                        done();
+                    });
+                });
+        });
+    });
+
+/**
+ * Fails with random data! Some bytes (up to 100) of the original are missing in
+ * the result
+ */
+/**
+    for (let i=0; i< 20; i++) {
+        it('Successful encrypt 1 MB '+ i+ '/20', function (done) {
+            let prm = Gpgmejs.init();
+            let data = bigString(0.1);
+                prm.then(function (context) {
+                    context.encrypt(data,
+                        inputvalues.encrypt.good.fingerprint).then(
+                            function (answer){
+                                expect(answer).to.not.be.empty;
+                                expect(answer.data).to.be.a("string");
+                                expect(answer.data).to.include(
+                                    'BEGIN PGP MESSAGE');
+                                expect(answer.data).to.include(
+                                    'END PGP MESSAGE');
+                                context.decrypt(answer.data).then(
+                                    function(result){
+                                        expect(result).to.not.be.empty;
+                                        expect(result.data).to.be.a('string');
+                                        expect(result.data).to.equal(data);
+                                        done();
+                                });
+                        });
+                });
+        }).timeout(10000);
+    };*/
+});
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/tests/encryptTest.js b/lang/js/BrowserTestExtension/tests/encryptTest.js
index 2178efac..37b319ed 100644
--- a/lang/js/BrowserTestExtension/tests/encryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptTest.js
@@ -17,47 +17,133 @@
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  */
-describe('Encryption', function(){
-    it('Successfull encrypt', function(){
+describe('Encryption', function () {
+    it('Successful encrypt', function (done) {
         let prm = Gpgmejs.init();
-        prm.then(function(context){
+        prm.then(function (context) {
             context.encrypt(
-            inputvalues.encrypt.good.data,
-            inputvalues.encrypt.good.fingerprint).then(function(answer){
+                inputvalues.encrypt.good.data,
+                inputvalues.encrypt.good.fingerprint).then(function (answer) {
                     expect(answer).to.not.be.empty;
                     expect(answer.data).to.be.a("string");
                     expect(answer.data).to.include('BEGIN PGP MESSAGE');
                     expect(answer.data).to.include('END PGP MESSAGE');
+                    done();
                 });
         });
     });
 
-    it('Sending encryption without keys fails', function(){
+    it('Successful encrypt 5 MB', function (done) {
         let prm = Gpgmejs.init();
-        prm.then(function(context){
+        let data = bigString(5);
+        prm.then(function (context) {
+            context.encrypt(
+                data,
+                inputvalues.encrypt.good.fingerprint).then(function (answer) {
+                    expect(answer).to.not.be.empty;
+                    expect(answer.data).to.be.a("string");
+                    expect(answer.data).to.include('BEGIN PGP MESSAGE');
+                    expect(answer.data).to.include('END PGP MESSAGE');
+                    done();
+                });
+        });
+    }).timeout(5000);
+
+    it('Successful encrypt 20 MB', function (done) {
+        let prm = Gpgmejs.init();
+        let data = bigString(20);
+        prm.then(function (context) {
+            context.encrypt(
+                data,
+                inputvalues.encrypt.good.fingerprint).then(function (answer) {
+                    expect(answer).to.not.be.empty;
+                    expect(answer.data).to.be.a("string");
+                    expect(answer.data).to.include('BEGIN PGP MESSAGE');
+                    expect(answer.data).to.include('END PGP MESSAGE');
+                    done();
+                });
+        });
+    }).timeout(20000);
+
+/**
+    it('Successful encrypt 30 MB', function (done) {
+        // TODO: There seems to be a limit imposed at least by chrome at about 21 MB
+        let prm = Gpgmejs.init();
+        let data = bigString(30);
+        prm.then(function (context) {
+            context.encrypt(
+                data,
+                inputvalues.encrypt.good.fingerprint).then(function (answer) {
+                    expect(answer).to.not.be.empty;
+                    expect(answer.data).to.be.a("string");
+                    expect(answer.data).to.include('BEGIN PGP MESSAGE');
+                    expect(answer.data).to.include('END PGP MESSAGE');
+                    done();
+                });
+        });
+    }).timeout(20000);
+*/
+
+    it('Sending encryption without keys fails', function (done) {
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
             context.encrypt(
                 inputvalues.encrypt.good.data,
-                null).then(function(answer){
+                null).then(function (answer) {
                     expect(answer).to.be.undefined;
                 }, function(error){
                     expect(error).to.be.an('Error');
                     expect(error.code).to.equal('MSG_INCOMPLETE');
-                    //TODO: MSG_INCOMPLETE desired, GNUPG_ERROR coming
+                    done();
                 });
         });
     });
 
-    it('Sending encryption without data fails', function(){
+    it('Sending encryption without data fails', function (done) {
         let prm = Gpgmejs.init();
-        prm.then(function(context){
+        prm.then(function (context) {
             context.encrypt(
-                null,inputvalues.encrypt.good.keyid).then(function(answer){
+                null, inputvalues.encrypt.good.keyid).then(function (answer) {
                     expect(answer).to.be.undefined;
-                }, function(error){
+                }, function (error) {
                     expect(error).to.be.an.instanceof(Error);
-                    expect(error.code).to.equal('PARAM_WRONG');
+                    expect(error.code).to.equal('MSG_INCOMPLETE');
+                    done();
+                });
+        });
+    });
+
+
+    it('Sending encryption with non existing keys fails', function (done) {
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            context.encrypt(
+                inputvalues.encrypt.good.data,
+                inputvalues.encrypt.bad.fingerprint).then(function (answer) {
+                    expect(answer).to.be.undefined;
+                }, function(error){
+                    expect(error).to.be.an('Error');
+                    expect(error.code).to.not.be.undefined;
+                    expect(error.code).to.equal('GNUPG_ERROR');
+                    done();
                 });
         });
     });
+
+    it('Overly large message ( >= 48MB) is rejected', function (done) {
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            context.encrypt(
+                bigString(48),
+                inputvalues.encrypt.good.fingerprint).then(function (answer) {
+                    expect(answer).to.be.undefined;
+                }, function(error){
+                    expect(error).to.be.an.instanceof(Error);
+                    // TODO who is throwing the error here?
+                    // It is not a GPGME_Error!
+                    done();
+                });
+        });
+    }).timeout(8000);
     // TODO check different valid parameter
 });
diff --git a/lang/js/BrowserTestExtension/tests/inputvalues.js b/lang/js/BrowserTestExtension/tests/inputvalues.js
index 1761c82f..3cd1e92a 100644
--- a/lang/js/BrowserTestExtension/tests/inputvalues.js
+++ b/lang/js/BrowserTestExtension/tests/inputvalues.js
@@ -23,6 +23,9 @@ var inputvalues = {
         good:{
             data : 'Hello World.',
             fingerprint : 'CDC3A2B2860625CCBFC5A5A9FC6D1B604967FC40'
+        },
+        bad: {
+            fingerprint: 'CDC3A2B2860625CCBFC5AAAAAC6D1B604967FC4A'
         }
     },
     init: {
@@ -30,3 +33,12 @@ var inputvalues = {
     }
 
 };
+
+function bigString(megabytes){
+    let maxlength = 1024 * 1024 * megabytes;
+    let uint = new Uint8Array(maxlength);
+    for (let i= 0; i < maxlength; i++){
+        uint[i] = Math.random() * Math.floor(256);
+    }
+    return new TextDecoder('utf-8').decode(uint);
+}
diff --git a/lang/js/src/Connection.js b/lang/js/src/Connection.js
index a198bdc6..2c8792d6 100644
--- a/lang/js/src/Connection.js
+++ b/lang/js/src/Connection.js
@@ -99,11 +99,12 @@ export class Connection{
                     me._connection.onMessage.removeListener(listener)
                     reject(gpgme_error('CONN_EMPTY_GPG_ANSWER'));
                 } else if (msg.type === "error"){
-                    me._connection.onMessage.removeListener(listener)
+                    me._connection.onMessage.removeListener(listener);
                     reject(gpgme_error('GNUPG_ERROR', msg.msg));
                 } else {
                     let answer_result = answer.add(msg);
                     if (answer_result !== true){
+                        me._connection.onMessage.removeListener(listener);
                         reject(answer_result);
                     }
                     if (msg.more === true){
@@ -127,8 +128,12 @@ export class Connection{
                         }, 5000);
                     }]).then(function(result){
                     return result;
-                }, function(error){
-                    return error;
+                }, function(reject){
+                    if(!reject instanceof Error) {
+                        return gpgme_error('GNUPG_ERROR', reject);
+                    } else {
+                        return reject;
+                    }
                 });
             }
         });
@@ -196,7 +201,7 @@ class Answer{
                         this._response.push(msg[key]);
                     }
                     else {
-                        return gpgme_error('CONN_UNEXPECTED_ANSWER', key);
+                        return gpgme_error('CONN_UNEXPECTED_ANSWER');
                     }
                     break;
             }
diff --git a/lang/js/src/Message.js b/lang/js/src/Message.js
index c42480f2..6a59c3e0 100644
--- a/lang/js/src/Message.js
+++ b/lang/js/src/Message.js
@@ -84,9 +84,22 @@ export class GPGME_Message {
         let checktype = function(val){
             switch(typeof(val)){
                 case 'string':
+                    if (poparam.allowed.indexOf(typeof(val)) >= 0
+                        && val.length > 0) {
+                        return true;
+                    }
+                    return gpgme_error('PARAM_WRONG');
+                    break;
                 case 'number':
+                    if (
+                        poparam.allowed.indexOf('number') >= 0
+                        && isNaN(value) === false){
+                            return true;
+                    }
+                    return gpgme_error('PARAM_WRONG');
+                    break;
                 case 'boolean':
-                    if (poparam.allowed.indexOf(typeof(val)) >= 0){
+                    if (poparam.allowed.indexOf('boolean') >= 0){
                         return true;
                     }
                     return gpgme_error('PARAM_WRONG');
@@ -102,7 +115,9 @@ export class GPGME_Message {
                                 return res;
                             }
                         }
-                        return true;
+                        if (val.length > 0) {
+                            return true;
+                        }
                     } else if (val instanceof Uint8Array){
                         if (poparam.allowed.indexOf('Uint8Array') >= 0){
                             return true;
diff --git a/lang/js/unittests.js b/lang/js/unittests.js
index 6c0d1890..c437d599 100644
--- a/lang/js/unittests.js
+++ b/lang/js/unittests.js
@@ -130,7 +130,6 @@ function unittests (){
             let test0 = toKeyIdArray(hp.valid_openpgplike);
 
             expect(test0).to.be.an('array').with.lengthOf(1);
-            console.log(test0);
             expect(test0).to.include(
                 hp.valid_openpgplike.primaryKey.getFingerprint());
         });
@@ -255,7 +254,7 @@ function unittests (){
             expect(test0.isComplete).to.be.false;
         });
 
-        it('Message is complete after setting mandatoy data', function(){
+        it('Message is complete after setting mandatory data', function(){
             let test0 = createMessage('encrypt');
             test0.setParameter('data', mp.valid_encrypt_data);
             test0.setParameter('keys', hp.validFingerprints);
@@ -263,6 +262,13 @@ function unittests (){
             expect(test0.isComplete).to.be.true;
         });
 
+        it('Message is not complete after mandatory data is empty', function(){
+            let test0 = createMessage('encrypt');
+            test0.setParameter('data', '');
+            test0.setParameter('keys', hp.validFingerprints);
+            expect(test0.isComplete).to.be.false;
+        });
+
         it('Complete Message contains the data that was set', function(){
             let test0 = createMessage('encrypt');
             test0.setParameter('data', mp.valid_encrypt_data);
@@ -315,7 +321,6 @@ function unittests (){
         });
     });
 
-    mocha.run();
 }
 
 export default {unittests};
\ No newline at end of file
-- 
cgit 


From c92326cc257cf7c8b6c0ddc43ec81573c409bc64 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Wed, 9 May 2018 19:40:57 +0200
Subject: js: more testing of nativeMessaging connection

--

* There were some inconsistencies between utf-8, transfer and browsers'
  utf16, which broke characters that were split between individual
  messages. src/Connection now contains a workaround that reassembles
  javascripts' format from passed base64 strings. This needs someone
  more experienced looking.
* Added several new tests which were failing during initial debugging
  of this issue
* reorganized BrowsertestExtension to avoid cluttering.
---
 lang/js/BrowserTestExtension/browsertest.html      |   3 -
 lang/js/BrowserTestExtension/index.html            |  40 +++++
 lang/js/BrowserTestExtension/longTests.html        |  22 +++
 lang/js/BrowserTestExtension/popup.js              |   2 +-
 lang/js/BrowserTestExtension/runbrowsertest.js     |   1 -
 lang/js/BrowserTestExtension/rununittests.js       |  21 +++
 .../tests/encryptDecryptTest.js                    | 191 +++++----------------
 lang/js/BrowserTestExtension/tests/encryptTest.js  |   2 +-
 lang/js/BrowserTestExtension/tests/inputvalues.js  | 119 ++++++++++++-
 .../BrowserTestExtension/tests/longRunningTests.js |  53 ++++++
 lang/js/BrowserTestExtension/unittests.html        |  17 ++
 lang/js/src/Connection.js                          |  19 +-
 12 files changed, 328 insertions(+), 162 deletions(-)
 create mode 100644 lang/js/BrowserTestExtension/index.html
 create mode 100644 lang/js/BrowserTestExtension/longTests.html
 create mode 100644 lang/js/BrowserTestExtension/rununittests.js
 create mode 100644 lang/js/BrowserTestExtension/tests/longRunningTests.js
 create mode 100644 lang/js/BrowserTestExtension/unittests.html

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index d12e03cf..c379ef53 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -12,14 +12,11 @@
     <script src="libs/chai.js"></script>
     <script src="setup_testing.js"></script>
     <script src="libs/gpgmejs.bundle.js"></script>
-
     <script src="tests/inputvalues.js"></script>
-    <script src="libs/gpgmejs_unittests.bundle.js"></script>
 <!-- insert tests here-->
     <script src="tests/startup.js"></script>
     <script src="tests/encryptTest.js"></script>
     <script src="tests/encryptDecryptTest.js"></script>
-
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
     </body>
diff --git a/lang/js/BrowserTestExtension/index.html b/lang/js/BrowserTestExtension/index.html
new file mode 100644
index 00000000..05d413ba
--- /dev/null
+++ b/lang/js/BrowserTestExtension/index.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <link href="libs/mocha.css" rel="stylesheet" />
+    </head>
+<body>
+    <h3>gpgmejs - Tests</h3>
+    <p>
+        The unittests rely on a separately packaged version of gpgmejs,
+        with the different classes and functions exposed. These tests and their
+        input values can be found in gpgme/lang/js/test. They do not test the
+        overall functionality, but the individual behaviour of the components.
+        <ul>
+            <li>
+                <a href="unittests.html">
+                    Unittests of the individual functions and classes.
+                </a>
+            </li>
+        </ul>
+    </p>
+    <p>
+        The functionality tests, to be found in
+        gpgme/lang/js/BrowserTestExtension, check the overall functionality of
+        the standard  packaged version of gpgmejs.
+        <ul>
+            <li>
+                <a href="browsertest.html">
+                    Functionality tests using the bundled library.
+                </a>
+            </li>
+            <li>
+                <a href="longTests.html">
+                    Functionality tests with larger/longer running data sets.
+                </a>
+            </li>
+        </ul>
+        </p>
+    </body>
+</html>
diff --git a/lang/js/BrowserTestExtension/longTests.html b/lang/js/BrowserTestExtension/longTests.html
new file mode 100644
index 00000000..8ff969b7
--- /dev/null
+++ b/lang/js/BrowserTestExtension/longTests.html
@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <link href="libs/mocha.css" rel="stylesheet" />
+    </head>
+<body>
+    <h3>Browsertest</h3>
+    <div id="mocha"></div>
+    <!-- load unit tests -->
+    <script src="libs/mocha.js"></script>
+    <script src="libs/chai.js"></script>
+    <script src="setup_testing.js"></script>
+    <script src="libs/gpgmejs.bundle.js"></script>
+    <script src="tests/inputvalues.js"></script>
+<!-- insert tests here-->
+    <script src="tests/startup.js"></script>
+    <script src="tests/longRunningTests.js"></script>
+<!-- run tests -->
+    <script src="runbrowsertest.js"></script>
+    </body>
+</html>
diff --git a/lang/js/BrowserTestExtension/popup.js b/lang/js/BrowserTestExtension/popup.js
index 4764df55..12beb1eb 100644
--- a/lang/js/BrowserTestExtension/popup.js
+++ b/lang/js/BrowserTestExtension/popup.js
@@ -39,6 +39,6 @@
 
 document.addEventListener('DOMContentLoaded', function() {
     chrome.tabs.create({
-        url: './browsertest.html'
+        url: './index.html'
     });
 });
diff --git a/lang/js/BrowserTestExtension/runbrowsertest.js b/lang/js/BrowserTestExtension/runbrowsertest.js
index 308c716d..39bc3fb9 100644
--- a/lang/js/BrowserTestExtension/runbrowsertest.js
+++ b/lang/js/BrowserTestExtension/runbrowsertest.js
@@ -19,4 +19,3 @@
  */
 
 mocha.run();
-Gpgmejs_test.unittests();
diff --git a/lang/js/BrowserTestExtension/rununittests.js b/lang/js/BrowserTestExtension/rununittests.js
new file mode 100644
index 00000000..f85ed8b5
--- /dev/null
+++ b/lang/js/BrowserTestExtension/rununittests.js
@@ -0,0 +1,21 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+Gpgmejs_test.unittests();
+mocha.run();
diff --git a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
index e28dd66b..a66e1534 100644
--- a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
@@ -19,7 +19,7 @@
  */
 
 describe('Encryption and Decryption', function () {
-    it('Successful encrypt and decrypt', function (done) {
+    it('Successful encrypt and decrypt simple string', function (done) {
         let prm = Gpgmejs.init();
         prm.then(function (context) {
             context.encrypt(
@@ -39,54 +39,6 @@ describe('Encryption and Decryption', function () {
                 });
         });
     });
-
-    /**
-     * Fails with random data! Some bytes (up to 100) of the original are missing in
-     * the result
-*/
-/**
-    for (let j = 0; j < 10; j++){
-    it('Successful encrypt and decrypt specific sets: ',
-            function (done) {
-                let prm = Gpgmejs.init();
-                let data = bigBoringString(5); //see ./inputvalues.js
-                expect(Object.prototype.toString.call(data)).to.equal("[object String]");
-                prm.then(function (context) {
-                    context.encrypt(data,
-                        inputvalues.encrypt.good.fingerprint).then(
-                        function (answer) {
-                            expect(answer).to.not.be.empty;
-                            expect(answer.data).to.be.a("string");
-                            expect(answer.data).to.include(
-                                'BEGIN PGP MESSAGE');
-                            expect(answer.data).to.include(
-                                'END PGP MESSAGE');
-                            context.decrypt(answer.data).then(
-                                function (result) {
-                                    if (data.length !== result.data.length) {
-
-                                        for (let k = 0; k < data.length; k++) {
-                                            if (data[k] !== result.data[k]) {
-                                                console.log(k);
-                                                console.log(data[k - 2] + data[k - 1] + data[k] + data[k + 1]);
-                                                console.log(result.data[k - 2] + result.data[k - 1] + result.data[k] + result.data[k + 1]);
-                                                break;
-                                            }
-                                        }
-                                    }
-                                    expect(result).to.not.be.empty;
-                                    expect(result.data).to.be.a('string');
-                                    expect(result.data).to.equal(data);
-                                    context.connection.disconnect();
-                                    done();
-
-                                });
-                        });
-                });
-            }).timeout(5000);
-        }
-
-
     it('Roundtrip does not destroy trailing whitespace',
         function (done) {
             let prm = Gpgmejs.init();
@@ -112,88 +64,22 @@ describe('Encryption and Decryption', function () {
                             });
                     });
             });
-        }).timeout(3000);
-
-    it('Test with simple non-ascii input',
-        function (done) {
-            let prm = Gpgmejs.init();
-            prm.then(function (context) {
-                let data = '';
-                for (let i=0; i < 1024 * 1024 * 0.1; i++){
-                    data += inputvalues.encrypt.good.data_nonascii;
-                }
-                context.encrypt(data,
-                    inputvalues.encrypt.good.fingerprint).then(
-                    function (answer) {
-                        expect(answer).to.not.be.empty;
-                        expect(answer.data).to.be.a("string");
-                        expect(answer.data).to.include(
-                            'BEGIN PGP MESSAGE');
-                        expect(answer.data).to.include(
-                            'END PGP MESSAGE');
-                        console.log(answer);
-                        context.decrypt(answer.data).then(
-                            function (result) {
-                                expect(result).to.not.be.empty;
-                                expect(result.data).to.be.a('string');
-                                if (data.length !== result.data.length) {
-
-                                    for (let k = 0; k < data.length; k++) {
-                                        if (data[k] !== result.data[k]) {
-                                            console.log(k);
-                                            console.log(data[k - 2] + data[k - 1] + data[k] + data[k + 1]);
-                                            console.log(result.data[k - 2] + result.data[k - 1] + result.data[k] + result.data[k + 1]);
-                                            break;
-                                        }
-                                    }
-                                }
-                                console.log(data.length - result.data.length);
-                                expect(result.data).to.equal(data);
-                                context.connection.disconnect();
-                                done();
+        }).timeout(5000);
 
-                            });
-                    });
-            });
-        }).timeout(3000);
-*/
-/**
-    for (let i=0; i< 100; i++) {
-        it('Successful encrypt random data '+ (i+1) + '/100', function (done) {
-            let prm = Gpgmejs.init();
-            let data = bigString(0.2); // << set source data here
+    for (let j = 0; j < inputvalues.encrypt.good.data_nonascii_32.length; j++){
+        it('Roundtrip with >1MB non-ascii input meeting default chunksize (' + (j + 1) + '/' + inputvalues.encrypt.good.data_nonascii_32.length + ')',
+            function (done) {
+                let input = inputvalues.encrypt.good.data_nonascii_32[j];
+                expect(input).to.have.length(32);
+                let prm = Gpgmejs.init();
                 prm.then(function (context) {
+                    let data = '';
+                    for (let i=0; i < 34 * 1024; i++){
+                        data += input;
+                    }
                     context.encrypt(data,
                         inputvalues.encrypt.good.fingerprint).then(
-                            function (answer){
-                                expect(answer).to.not.be.empty;
-                                expect(answer.data).to.be.a("string");
-                                expect(answer.data).to.include(
-                                    'BEGIN PGP MESSAGE');
-                                expect(answer.data).to.include(
-                                    'END PGP MESSAGE');
-                                context.decrypt(answer.data).then(
-                                    function(result){
-                                        expect(result).to.not.be.empty;
-                                        expect(result.data).to.be.a('string');
-                                        expect(result.data).to.equal(data);
-                                        context.connection.disconnect();
-                                        done();
-                                });
-                        });
-                });
-        }).timeout(5000);
-    };
-*/
-
-/** still fails
-    it('Successful encrypt 0.8 MB Uint8Array', function (done) {
-        let prm = Gpgmejs.init();
-        let data = bigUint8(0.8);
-        prm.then(function (context) {
-                context.encrypt(data,
-                    inputvalues.encrypt.good.fingerprint).then(
-                        function (answer){
+                        function (answer) {
                             expect(answer).to.not.be.empty;
                             expect(answer.data).to.be.a("string");
                             expect(answer.data).to.include(
@@ -201,38 +87,39 @@ describe('Encryption and Decryption', function () {
                             expect(answer.data).to.include(
                                 'END PGP MESSAGE');
                             context.decrypt(answer.data).then(
-                                function(result){
+                                function (result) {
                                     expect(result).to.not.be.empty;
                                     expect(result.data).to.be.a('string');
                                     expect(result.data).to.equal(data);
-                                    done();
-                            });
-                    });
-            });
-    }).timeout(5000);
-*/
-
-    it('Decrypt simple non-ascii',
-        function (done) {
-            let prm = Gpgmejs.init();
-            prm.then(function (context) {
-                data = encryptedData;
-                context.decrypt(data).then(
-                    function (result) {
-                        expect(result).to.not.be.empty;
-                        expect(result.data).to.be.a('string');
-                        expect(result.data).to.equal(inputvalues.encrypt.good.data_nonascii);
-                        context.encrypt(inputvalues.encrypt.good.data_nonascii, inputvalues.encrypt.good.fingerprint).then(
-                            function(result){
-                                context.decrypt(result.data).then(function(answer){
-                                    expect(answer.data).to.equal(inputvalues.encrypt.good.data_nonascii);
                                     context.connection.disconnect();
                                     done();
                                 });
+                        });
+                });
+        }).timeout(5000);
+    };
+
+    it('Encrypt-decrypt simple non-ascii', function (done) {
+        //FAILS TODO: Check newline at the end
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            data = encryptedData;
+            context.decrypt(data).then(
+                function (result) {
+                    expect(result).to.not.be.empty;
+                    expect(result.data).to.be.a('string');
+                    expect(result.data).to.equal(inputvalues.encrypt.good.data_nonascii);
+                    context.encrypt(inputvalues.encrypt.good.data_nonascii, inputvalues.encrypt.good.fingerprint).then(
+                        function(result){
+                            context.decrypt(result.data).then(function(answer){
+                                expect(answer.data).to.equal('¡Äußerste µ€ før ñoquis@hóme! Добрый день');
+                                context.connection.disconnect();
+                                done();
                             });
                         });
+                    });
 
-            });
-    }).timeout(8000);
+        });
+    }).timeout(6000);
 
-});
\ No newline at end of file
+});
diff --git a/lang/js/BrowserTestExtension/tests/encryptTest.js b/lang/js/BrowserTestExtension/tests/encryptTest.js
index 2e95151b..5ef68a32 100644
--- a/lang/js/BrowserTestExtension/tests/encryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptTest.js
@@ -49,7 +49,7 @@ describe('Encryption', function () {
                     done();
                 });
         });
-    }).timeout(5000);
+    }).timeout(10000);
 
 /**
     it('Successful encrypt 20 MB', function (done) {
diff --git a/lang/js/BrowserTestExtension/tests/inputvalues.js b/lang/js/BrowserTestExtension/tests/inputvalues.js
index bc8c97bb..e23b7786 100644
--- a/lang/js/BrowserTestExtension/tests/inputvalues.js
+++ b/lang/js/BrowserTestExtension/tests/inputvalues.js
@@ -23,7 +23,23 @@ var inputvalues = {
         good:{
             data : 'Hello World.',
             fingerprint : 'D41735B91236FDB882048C5A2301635EEFF0CB05',
-            data_nonascii: '¡Äußerste µ€ før ñoquis@hóme! Добрый день\n'
+            data_nonascii: '¡Äußerste µ€ før ñoquis@hóme! Добрый день',
+            data_nonascii_32: [
+                'K€K€K€K€K€K€K€K€K€K€K€K€K€K€K€K€',
+                'µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€', //fails result has 3 chars more
+                '€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€', //fails 3 chars
+                '²³²³²³²³²³²³²³²³²³²³²³²³²³²³²³²³',
+                'µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€A€µ€µ€µ€µ€', //fails 2 chars
+                'µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µ€µAµ€µ€µ€µ€', //is okay if 2 chunksizes.
+                'üüüüüüüüüüüüüüüüüüüüüüüüüüüüüüüü',
+                'µAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA€',
+                'µAAAAµAAAAAAAAAAAAAAAAAAAAAAAAA€',
+                'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAµ€',
+                'µAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA°',
+                '€AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA€',
+                'µ||||||||||||||||||||||||||||||€',
+                'æſæſ³¼„¬“³³¬“¬½”æſæſ³¼„¬“³³¬“¬½”'
+            ]
         },
         bad: {
             fingerprint: 'CDC3A2B2860625CCBFC5AAAAAC6D1B604967FC4A'
@@ -56,7 +72,7 @@ function bigUint8(megabytes){
 function bigBoringString(megabytes){
     let maxlength = 1024 * 1024 * megabytes;
     let string = '';
-    let chars = ' ä0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let chars = ' 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
     for (let i= 0; i < maxlength; i++){
         string = string + chars[Math.floor(Math.random() * chars.length)];
     }
@@ -101,4 +117,101 @@ var encryptedData =
     'isGL7jOlDCBKwep67ted0cTRPLWkk3NSuLIlvD5xs6L4z3rPu92gXYgbZoMMdP0N\n' +
     'kSAQYOHplfA7YJWkrlRm\n' +
     '=zap6\n' +
-    '-----END PGP MESSAGE-----\n';
\ No newline at end of file
+    '-----END PGP MESSAGE-----\n';
+var encryptedBroken = '-----BEGIN PGP MESSAGE-----\n' +
+'\n' +
+'hQEMA6B8jfIUScGEAQf/bUYF70KRCHWITfNH7zaYaLa8P+QoCo+NpFzc3U9J4mty\n' +
+'FxjIpoNwxEvQ9UUEMi6LgHhvURYCbWrCV5XYjo/sE66CRXsEuNirfYkAzXVNcUf7\n' +
+'BaAzio/QzyyvBfzwHHqMLSxAcNggs+f5lob+TcBnBghwpn1lh5BgNUuhDKVq21/F\n' +
+'wWK4rqjmmjrpoR3tKcl916+/Z0VI5SAkPG4IrWUfumxG0xbePB9IFT8uGMmXy2qr\n' +
+'ICmEfPakLUIo7NLrdMNInnVQaAeNS/5u5TbpZpRxZWtRP7m4EyUoEA+TgSkp+hG8\n' +
+'Um7hmbFsB99H0yiyCSLicN5AxzmgCrL3D77Fqh7LaNLsAYjcyVZm+R7te4vwpv9P\n' +
+'F/MCAEUFKGfNYHqyVjBhBlm4/PMC+YtOE9jF920hwtDckT/V3L2POk1Kr78+nVjw\n' +
+'1HXTfK/Tk6QMGrzCd2ril5aB2RCi+Fr41B2ftS8SLwcrnrFkP2enH6VYBserx5l8\n' +
+'qZlgRR53QNnLvqnn7h/NO1ZNN5cnD2pf0PWBkSHmr5ph82JQ+XyB0h4eV1kwX80K\n' +
+'8IkBAq6hFpfm7TU4gy5x1VNTeVoCRdlzESkzVwbvjNZ+OU6+vcpfCaHMbuVBUmYz\n' +
+'xjTKYlenevSzwfF1RY7noDTrPUQrBrVor2cPjN3ROLCbFpARrQf44BfzGaq5XdWc\n' +
+'NZWFgiRKVGVJQeBQjRyqHAv4e8rkcr5qwnY8kyZpLYAKIVBgtqnh7GExaW5efWRG\n' +
+'tyJMgUuP+dF/+HymhlEmMKZabLf5W8J3p8+uBOkU359OX/HOS8mPr6a7bnI4895W\n' +
+'7Dt5vkpHRR81V1Le0+Mtcj7G46hsvFMA0dgw29mBbaOA8fhOrumqTBOh01lZliwI\n' +
+'6/OF6iqAeBAH3hJQlodCACf1yTxHynF6Ro/SnIa/3BN4CN4PPRHdLMHBJevRm3Ih\n' +
+'CbqXVmSdtrihHsViPKjc8+u+7g2n/lt9LHrMyOmptyVX8vT9B/AQYHxf0FDmv4Vg\n' +
+'62Mo+eDRWZF+XmKPQYedM6nF5hcyxc/1aCM4yXtu8qQir/GDvyghPbfnKkium5kk\n' +
+'+XOb+aIUsxbNzhdLowp2mZcy1MYMPHIJNjIXmVjPnc/GwB8S2SX/gHn1quz52ENq\n' +
+'l12ome7rfAp9JkrVbHOK11iDPbd3UdHSTfFNO8wQrxtqnZhUwqLhZwteOi4EGSSh\n' +
+'OrWihjdonqL0qcfiS6N9QemJz2w40fR8ZwDuGvPgl6LeNtKjihyqsWvh+zJzwmwM\n' +
+'R2Y50wNyvQnXGH4RJJUQVAKO/vMp63K2j3DnHsyz/XLbmp25QGn9f1QIjfplY64D\n' +
+'q3lp2W6GvhpYWLRzBfIo6ebwLtqHTsTgON9TA4CD+1QbOXMIxQKAb9hhzEtp/5zN\n' +
+'+gJhF4pOvEu5Cg1j9CtXh93iE0J9rwrjyMujzBSiaoqxHabXtRarv8d2v/w75AKh\n' +
+'6Avt+WFYRdSLKCstdHeuREXEibIaM55nUUIEO0v9kcb0Y7LyH/vFVGAo0QFh3u+t\n' +
+'zMupQwywjeuuUwM18KeWjKrhGuRf1WWCDRnnH1yEztDPLx5kyxadsC31/XyqLjYl\n' +
+'zt+vUSm+JrXujhba9VaYO3DSB9hL0qdrA3gaK2DAl2nvFGRn0fjtw0xfa9VJlafN\n' +
+'JLosw7MDDEFx962vHbx5XfjJRGaEdDnsco5E5VUkQ+RjhWWrzMHpIPYWYacXiUKr\n' +
+'TcNTAg1jR5M2FRz/QOk7qsTl98RyNCYXTUmuPh/pLJI0kJ5rtTPrlzFNgVjwiYEJ\n' +
+'+iNITXhqx5KJ5ifY89BXeNVavIb1Tp0xc1+637U/ztH9D0Jp6m0w/VIHW+881Ik3\n' +
+'fMKw8A/RuEdTil/PU0bjVRNYLS/KCQCqrlYdItYh57IAkt+sQNxvw0xg46QN+OkO\n' +
+'QHKnIazexhGAqyBe6c2KYuRLW46h9grGbCJnqvmoThBRrqL7twmp00O846tvRms8\n' +
+'3QEXL3oXqBTH1d6bRd/E6m++X/n9I6VaKMgYe6GNQEqwvtSySFi65VK5cH1jnEGw\n' +
+'wr2ZkXUrVbNTfXci6SdNqh+W8DRnFvlRyKzG1jnibsOW5FwGSMT3kVRUvnnJbzlc\n' +
+'wj1cJC/NMvkoQtGHppHkMjE23byjBhJlZXBTbGc3kSOfXKAMAT7I9Dm/GgEpbbpD\n' +
+'4fgzqNEeWucrCWgbXviXt1pWOyNtudb9rHWgvIQlE9JeykPgvmg+pl4Av42lQTYp\n' +
+'kyNFjq46niWT9VsYlsW52x4jCQifT7HkxTuSaD9JyVqjQWS11rci9UM/NuoXfqrv\n' +
+'vJYMBJGhzTxFzzFCzSRSERbjN0iXJ2E8vFKkpd5nCZxRMz6XBMk1NVyrE956BMum\n' +
+'yNaSy5mwR+ekS3xM7oUdbqyyDwFEDxpPhtIRqRfFugpIn8tRy7jwDZB9mctFGfKo\n' +
+'th5dCzcaU0qPfUJWPVQVh2LCPneLGhLENgFUhoNZ+rzaf5SltLeB4vuVjZMLe+PW\n' +
+'KqtT9l6QFQajbe7pj99BScteaI8lpiQiNTvQq/LZRFWr9eb5z0Xk5Wc3aYZgymkp\n' +
+'EYxyVqwomyz4wPf2BrgsSdKk0OZKIkAxfA3i73tHvCsCQOHeriRMSfLzFN3J54nf\n' +
+'+MOuUm1hKLsLbPLQxOfzPiymVGp6DjYCkrRmafvZUJHkvGubvVVR5Yq0txznM1Vg\n' +
+'yZq4HoF3RGgKzJtk8N4me5YsVaM2/q+2B2ziVa/HeEFt/cZfcH/byY3ooW3OnAum\n' +
+'KTe/+T2BEjXfipmbIMA6iK3IKIoguuVwvSJz+5QfjMH1o8HIUdDOhnrbBBHmkvNK\n' +
+'MG+dV+oDijC2rL3n0qRURu4VWdk/bqKcaaLoZC5iDGLThZ20q+9jlFKahmlKe1WH\n' +
+'2Rch+JJfqSHtNYVKxZU0CC0I9Wg/Ws6TQJREKCiJf0/aTvxWRSHZtecFiZK7q+zn\n' +
+'NyRdWnqAv+HKRjN/tVZcf8I0CERswxmixF9uWMTjH+hq0u/h4It3I3tOObNyAQO3\n' +
+'iY9uSZEZbrKBSM3DqFF75toLjooWXU8yaC9so3mQVf5MnSZpG3PA5klwusLmi0QU\n' +
+'HD1eZ2aXUnTx7TbHuovWLjI40SIUKnaMAf0TCUHfBvJ5rLUPYez35QwrYRx0Qixn\n' +
+'Pcj7KCCXrT5cqwH64vGTiW6JCZJlLzneiE+dmnAT+wnNRNxbVooi6ejWce5HYbYd\n' +
+'c2SyBHJstGn0zuNN/248qhV+r5AMBgZ+vDilV8Bmdh3N/xlXBIgLIocegL6Kc+S0\n' +
+'Pr60DHKLcnZIunQwZOwyRb8wG9jV6I718CmbSw94gKNCi99B8BSDZ7z2ai+0yv44\n' +
+'ErR4Qp/gnCp9/6NXNmafluYn5Pgl9vZCozcJ8EN8mzD4szZBL19btecoT6Wcnve2\n' +
+'fYDRuYPWpT79QyRDSMSSzrQoFpezIOtPS2nrN+II81TxyTgOMY+jzR4TRJyMt185\n' +
+'7OG4t8Q+WOgzNS4clmPHnmgBBhsueWob72SvIgRtq5pQYB0fStx9qUDMZPnePdhS\n' +
+'rI+K82k1/eY5vTQ/eDXMN7UUfdLriuK0UXnJFu5CQSwrMD1u5nFVbQYC9PEwgdUc\n' +
+'XEASt9/jh2wDgSXAGegc6mLRI+Zu5H5ygpCIAMs8pNwFJ5DhCsve5RbalGEbYbuL\n' +
+'NwB1rRExCCUBjnAkpwNU0TL991y1Gn+gpN2lNvITq/BroE3HLjXbnEACTN+hwNPB\n' +
+'KJi38zKSb6/k27/zpTMuEKRXkSz4QuuviQbGJTmCbub+l2aVBQhVNwooGI92Gt8n\n' +
+'EQjGOzqeS4J0KQGZmhYRGVc7DdwjBYLV5pi1WkCIt1a1PDK9VZ4vzz978gLaxSZM\n' +
+'yozdL97g9wo0IJcAj+36b1Wewj+hL81t0SgIShEO0aIGSNDlFZM4mKQNmCUhvWuO\n' +
+'M1CpniR8cBN4MHUaQdBIlW2ua9Ba8JM7LNwcD8JddGvmUBwzFr5w4Hu4ylweacXP\n' +
+'5zUfZpJyFZKoxJe1cPY47NmXemOLuBVJRlThnUazvhM/KRxfyu2q4WOz6VSm6LEq\n' +
+'PFfr/NYH1AxIda/Z4tLLAs0nLbV+HrqRFMJOBGdY6dMxuvaiUutY3MZCMCKupz8f\n' +
+'yHh2p2lFy2jQvZs4HAKN6hTx8X7at1ue0RYw3hdjoPHa/NBKDzrkKjGInfraTVr6\n' +
+'qrxqW09/yNuiatISi+KxuBM4o9L/w85Zf01RNEZTS5zCKX0ml33JHgNxQgPosp+7\n' +
+'R0TUK2lANdKVTXJe8V/IT4tGUD4mg0EjMVRmFV2CL3LgBbW3ScOC15D4mzD14Yyb\n' +
+'KTUHwfX189GHKjJhHnSuZ3QgVKynoSII+0x4fiDHsdhdXdMj/qvVdZIMlABWKRD0\n' +
+'JVmrkFpzFtt4yXupl62+9ZYZehSKNKurlO4A8OBeg6xKDUKuvrI7Ug/2s5Q0pCxp\n' +
+'EgtxwOhhYrAhd8mN2ilKeB++JCAmZ2KwnwCGFF8kZ/5TOwWZHm/RNKEchTRC5kws\n' +
+'KsDUxq/19ORifzCA19f6Tc5s9HcPwxvnrscvb6LLTGGiROp3BlcitHjmPsH5bRUX\n' +
+'OAqV069l1JKeiCkGgQmlRviBGG0yO2zIcAeoDIPhaO4O0K6/VHo4p6kAlZAzWJuT\n' +
+'QmHI0ETyO+2m0jySoxW0EUU1FB3eQ4KBocneYqJUgCbOCeXf14TO8HekDtkfoKOK\n' +
+'bded3iCtnSAH6I9ERtPebqiWdR2tVCO4Yyqkf2f3vzCWrtyXHUWtZtC1I08HNLin\n' +
+'zGhEdQZ/VFCLP8CWmbtLU8BPeu88VTpw7i8G76QuHq5+0DY9eBgHWxcBYiwRisT/\n' +
+'DHXH0TvjuPedJ4F/sNmlktTXLLMqVu+J8i/qJ48E1r9wXkHTICnFy8jvm5MpQ4gu\n' +
+'rwzpyjSFLJZpzDMAxcPSXYGi1kchW+CDg/N/cdeYlVLCoBrUn6dEq6CC05Y6JmDW\n' +
+'t46R6lFHbQoq1WsMWZSKomB4WlxWP+hYDsssQOUR9Y7wwI4KXPtf6Ar9W2T9cSfO\n' +
+'mtDpgfeOVq/vE01TQGlZc4zwF5dcXBV3OLYBSXlv4JFIreOlKDi/IbPc6TYw0mbV\n' +
+'wFuzPi8VpHip3YoGdM7XUDvO1sE07FX8/xrEQVkJfzgl/v+mQ66TCb+/g13QPgZI\n' +
+'UftRS6hLeKNTd0pZc8+CTbNzgrCDGqbYn5ZpyPFYF+fVGZnqqLUid5NTjkwI1IoD\n' +
+'PgOSHQEo+pIlNfTtR2DCYgqOiMaBSZ4bc4b6SohAKGJkPhNmlMJ61MwGN2J8pFpl\n' +
+'1uG2MO3TUo6MxQAkCcKe4twwy1bQh4kO3kReUqTDW/VTnp6HfZhqtYc1tBGLcahu\n' +
+'C0ZX7B/8Wbu1PWN4Y34F7ouuSu2l6ASnoAc/Ek1S9R1uyiwLtaPuK58oUbVisDh3\n' +
+'cYmnjP0DelYq8FpJPWPrSGwqlERotf3KU3L1k84SHYUB1pHFYPF46KAKYH5qTrsO\n' +
+'T3id3CO3mt1gtgWAEGRkEQ+qVmvWtINBOwyFYVAD9ZqXflzF83ZGvdmvdJ6kzRZ7\n' +
+'fY5ACZGMghb3f4mfLlbF81WluDbk2k+t186qmRFrJFtJPvAl3VxXczo8pw5bSAdK\n' +
+'R6c7cagA6ql4QaYqtbIHpFbgz7iQ9ESe23Q2+o82lkTbUFdG+GDhnZFOL+ldWf/g\n' +
+'ufSCqY7IlNxj3hYxgTpaXb2lWvVVdo7C4VhPHyIDbQUCdUE80t2cDgJqPFABe3la\n' +
+'Y+UsW9W787mGGuuNSF/iI0tANw5twlQjdRQtqxnF1yETh/hFA4bgD9bmBOBFd+GT\n' +
+'+ECxkqI4/UYMgYfVMFja/e6+dQTWLblzuNaZh6wHASeNqpFmeQSBawBVV7qK3nC7\n' +
+'CDY9r6Aq9JYMiJTE/TzyfBmBhnxtL1aKTu6EHy3siDlID7EjQx1Xyr/EtbJCmsVl\n' +
+'E14StpggdK8=\n' +
+'=enm3\n' +
+'-----END PGP MESSAGE-----\n';
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/tests/longRunningTests.js b/lang/js/BrowserTestExtension/tests/longRunningTests.js
new file mode 100644
index 00000000..0f32ca92
--- /dev/null
+++ b/lang/js/BrowserTestExtension/tests/longRunningTests.js
@@ -0,0 +1,53 @@
+describe('Long running Encryption/Decryption', function () {
+    for (let i=0; i< 100; i++) {
+        it('Successful encrypt/decrypt completely random data ' + (i+1) + '/100', function (done) {
+            let prm = Gpgmejs.init();
+            let data = bigString(2);
+                prm.then(function (context) {
+                    context.encrypt(data,
+                        inputvalues.encrypt.good.fingerprint).then(
+                            function (answer){
+                                expect(answer).to.not.be.empty;
+                                expect(answer.data).to.be.a("string");
+                                expect(answer.data).to.include(
+                                    'BEGIN PGP MESSAGE');
+                                expect(answer.data).to.include(
+                                    'END PGP MESSAGE');
+                                context.decrypt(answer.data).then(
+                                    function(result){
+                                        expect(result).to.not.be.empty;
+                                        expect(result.data).to.be.a('string');
+                                        expect(result.data).to.equal(data);
+                                        context.connection.disconnect();
+                                        done();
+                                });
+                        });
+                });
+        }).timeout(5000);
+    };
+
+    it('Successful encrypt 1 MB Uint8Array', function (done) {
+        let prm = Gpgmejs.init();
+        let data = bigUint8(1);
+        prm.then(function (context) {
+                context.encrypt(data,
+                    inputvalues.encrypt.good.fingerprint).then(
+                        function (answer){
+                            expect(answer).to.not.be.empty;
+                            expect(answer.data).to.be.a("string");
+                            expect(answer.data).to.include(
+                                'BEGIN PGP MESSAGE');
+                            expect(answer.data).to.include(
+                                'END PGP MESSAGE');
+                            context.decrypt(answer.data).then(
+                                function(result){
+                                    expect(result).to.not.be.empty;
+                                    expect(result.data).to.be.a('string');
+                                    expect(result.data).to.equal(data);
+                                    done();
+                            });
+                    });
+            });
+    }).timeout(5000);
+
+});
diff --git a/lang/js/BrowserTestExtension/unittests.html b/lang/js/BrowserTestExtension/unittests.html
new file mode 100644
index 00000000..6f7da3f1
--- /dev/null
+++ b/lang/js/BrowserTestExtension/unittests.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <link href="libs/mocha.css" rel="stylesheet" />
+
+    </head>
+<body>
+    <h3>Unit tests</h3>
+    <div id="mocha"></div>
+    <script src="libs/mocha.js"></script>
+    <script src="libs/chai.js"></script>
+    <script src="setup_testing.js"></script>
+    <script src="libs/gpgmejs_unittests.bundle.js"></script>
+    <script src="rununittests.js"></script>
+    </body>
+</html>
diff --git a/lang/js/src/Connection.js b/lang/js/src/Connection.js
index 2c8792d6..64621f60 100644
--- a/lang/js/src/Connection.js
+++ b/lang/js/src/Connection.js
@@ -181,7 +181,8 @@ class Answer{
                         if (!this._response.hasOwnProperty(key)){
                             this._response[key] = '';
                         }
-                        this._response[key] = this._response[key].concat(msg[key]);
+                        // console.log(msg[key]);
+                        this._response[key] += msg[key];
                     }
                     //params should not change through the message
                     else if (poa.params.indexOf(key) >= 0){
@@ -214,6 +215,22 @@ class Answer{
      * TODO: does not care yet if completed.
      */
     get message(){
+        let keys = Object.keys(this._response);
+        let poa = permittedOperations[this.operation].answer;
+        for (let i=0; i < keys.length; i++) {
+            if (poa.data.indexOf(keys[i]) >= 0){
+                if (this._response.base64 == true){
+                    let respatob =  atob(this._response[keys[i]]);
+
+                    let result = decodeURIComponent(
+                        respatob.split('').map(function(c) {
+                            return '%' +
+                            ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+                        }).join(''));
+                    this._response[keys[i]] = result;
+                }
+            }
+        }
         return this._response;
     }
 }
-- 
cgit 


From a4ba80c553c2ac42f9e311344302c04ec9aa715b Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Thu, 24 May 2018 15:16:18 +0200
Subject: js: adding sign method

--

  * src/gpgmejs.js: method, update in src/permittedOperations
  * basic testing in BrowsertestExtension
---
 lang/js/BrowserTestExtension/browsertest.html |  1 +
 lang/js/src/gpgmejs.js                        | 38 +++++++++++++++++++++++
 lang/js/src/permittedOperations.js            | 44 ++++++++++++++++++++++++++-
 3 files changed, 82 insertions(+), 1 deletion(-)

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index c379ef53..3d81a9ec 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -17,6 +17,7 @@
     <script src="tests/startup.js"></script>
     <script src="tests/encryptTest.js"></script>
     <script src="tests/encryptDecryptTest.js"></script>
+    <script src="tests/signTest.js"></script>
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
     </body>
diff --git a/lang/js/src/gpgmejs.js b/lang/js/src/gpgmejs.js
index 3aa5957a..1e76655e 100644
--- a/lang/js/src/gpgmejs.js
+++ b/lang/js/src/gpgmejs.js
@@ -120,6 +120,44 @@ export class GpgME {
 
     }
 
+    sign(data, keys, mode='clearsign', base64=false) { //sender
+        if (data === undefined){
+            return Promise.reject(gpgme_error('MSG_EMPTY'));
+        }
+        let key_arr = toKeyIdArray(keys);
+        if (key_arr.length === 0){
+            return Promise.reject(gpgme_error('MSG_NO_KEYS'));
+        }
+        let msg = createMessage('sign');
+
+        msg.setParameter('keys', key_arr);
+        if (base64 === true){
+            msg.setParameter('base64', true);
+        }
+        msg.setParameter('mode', mode);
+        putData(msg, data);
+        if (mode === 'detached') {
+            msg.expected = 'base64';
+        }
+        let me = this;
+        return new Promise(function(resolve,reject) {
+            me.connection.post(msg).then( function(message) {
+                if (mode === 'clearsign'){
+                    resolve({
+                        data: message.data}
+                    );
+                } else if (mode === 'detached') {
+                    resolve({
+                        data: data,
+                        signature: message.data
+                    });
+                }
+            }, function(error){
+                reject(error);
+            })
+        });
+    }
+
     deleteKey(key, delete_secret = false, no_confirm = false){
         return Promise.reject(gpgme_error('NOT_YET_IMPLEMENTED'));
         let msg = createMessage('deletekey');
diff --git a/lang/js/src/permittedOperations.js b/lang/js/src/permittedOperations.js
index da46a1fd..aa02a8bc 100644
--- a/lang/js/src/permittedOperations.js
+++ b/lang/js/src/permittedOperations.js
@@ -130,6 +130,49 @@ export const permittedOperations = {
                         // }]
         }
     },
+
+    sign: {
+        pinentry: true,
+        required: {
+            'data': {
+                allowed: ['string']},
+            'keys': {
+                allowed: ['string'],
+                array_allowed: true
+            }
+        },
+        optional: {
+            'protocol': {
+                allowed: ['string'],
+                allowed_data: ['cms', 'openpgp']
+            },
+            'chunksize': {
+                allowed: ['number'],
+            },
+            'sender': {
+                allowed: ['string'],
+            },
+            'mode': {
+                allowed: ['string'],
+                allowed_data: ['detached', 'clearsign'] // TODO 'opaque' not used
+            },
+            'base64': {
+                allowed: ['boolean']
+            },
+            'armor': {
+                allowed: ['boolean']
+            },
+        },
+        answer: {
+            type: ['signature', 'ciphertext'],
+            data: ['data'], // Unless armor mode is used a Base64 encoded binary
+                            // signature.  In armor mode a string with an armored
+                            // OpenPGP or a PEM message.
+            params: ['base64']
+        }
+    },
+
+
     /** TBD: querying the Key's information (keyinfo)
     TBD name: {
         required: {
@@ -212,6 +255,5 @@ export const permittedOperations = {
      *TBD get armored secret different treatment from keyinfo!
      * TBD key modification?
      * encryptsign: TBD
-     * verify: TBD
      */
 }
-- 
cgit 


From 0356a667c5a8b4fdb4404cebb57475ed3f39ade9 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Wed, 6 Jun 2018 11:57:41 +0200
Subject: js: implement import/delete Key, some fixes

--

* Keyring.js
   - implemented importKey: importing one or more armored public key
     blocks.
   - implemented deleteKey: deleting a public Key from gpg.

* Key.js renamed property Key.armor to Key.armored

* Helpers.js: toKeyIDArray does not complain anymore if there are no
  keys. Not having Keys in e.g. signing keys in encrypt is legitimate
  and common, the complaints were getting spammy

* Errors.js: gpgme_errors now always pass an optional additional
  message, for easier debugging in minified code

* Connection.js: Fix in gpgme-json responses containing objects

* eslintrc.json: Start using eslint. A cleanup to conform to it is not
  done yet

* Added further tests for the new functionality
---
 lang/js/.eslintrc.json                             |  29 +++++
 lang/js/BrowserTestExtension/browsertest.html      |   1 +
 .../BrowserTestExtension/tests/KeyImportExport.js  |  83 ++++++++++++
 .../tests/encryptDecryptTest.js                    |   5 +-
 lang/js/BrowserTestExtension/tests/inputvalues.js  | 105 +++++++++++++--
 lang/js/src/Connection.js                          |   5 +-
 lang/js/src/Errors.js                              |   8 +-
 lang/js/src/Helpers.js                             |   2 -
 lang/js/src/Key.js                                 |   4 +-
 lang/js/src/Keyring.js                             | 144 +++++++++++++++++----
 lang/js/unittest_inputvalues.js                    |  93 +++++++++++--
 lang/js/unittests.js                               | 126 +++++++++++++-----
 12 files changed, 511 insertions(+), 94 deletions(-)
 create mode 100644 lang/js/.eslintrc.json
 create mode 100644 lang/js/BrowserTestExtension/tests/KeyImportExport.js

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/.eslintrc.json b/lang/js/.eslintrc.json
new file mode 100644
index 00000000..65253cf3
--- /dev/null
+++ b/lang/js/.eslintrc.json
@@ -0,0 +1,29 @@
+{
+    "env": {
+        "browser": true,
+        "es6": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "warn",
+            4
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ],
+        "max-len": 1
+    }
+}
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index 3d81a9ec..f3d7a406 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -18,6 +18,7 @@
     <script src="tests/encryptTest.js"></script>
     <script src="tests/encryptDecryptTest.js"></script>
     <script src="tests/signTest.js"></script>
+    <script src="tests/KeyImportExport.js"></script>
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
     </body>
diff --git a/lang/js/BrowserTestExtension/tests/KeyImportExport.js b/lang/js/BrowserTestExtension/tests/KeyImportExport.js
new file mode 100644
index 00000000..e6eb5a30
--- /dev/null
+++ b/lang/js/BrowserTestExtension/tests/KeyImportExport.js
@@ -0,0 +1,83 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ */
+
+/* global describe, it, expect, Gpgmejs, ImportablePublicKey */
+
+describe('Key importing', function () {
+    it('Prepare test Key (deleting it from gnupg, if present)', function(done){
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            expect(context.Keyring.getKeys).to.be.a('function');
+            context.Keyring.getKeys(ImportablePublicKey.fingerprint).then(
+                function(result){
+                    if (result.length === 1) {
+                        result[0].delete().then(function(result){
+                            expect(result).to.be.true;
+                            done();
+                        });
+                    } else {
+                        done();
+                    }
+                });
+        });
+    });
+
+    it('importing, updating, then deleting public Key', function (done) {
+        //This test runs in one large step, to ensure the proper state of the
+        // key in all stages.
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            context.Keyring.getKeys(ImportablePublicKey.fingerprint).then(
+                function(result){
+                    expect(result).to.be.an('array');
+                    expect(result.length).to.equal(0);
+                    context.Keyring.importKey(ImportablePublicKey.key, true)
+                        .then(function(result){
+                            expect(result[0]).to.not.be.undefined;
+                            expect(result[0].key).to.be.an('object');
+                            expect(result[0].key.fingerprint).to.equal(
+                                ImportablePublicKey.fingerprint);
+                            expect(result[0].status).to.equal('newkey');
+                            context.Keyring.importKey(
+                                ImportablePublicKey.keyChangedUserId,true)
+                                .then(function(res){
+                                    expect(res[0]).to.not.be.undefined;
+                                    expect(res[0].key).to.be.an('object');
+                                    expect(res[0].key.fingerprint).to.equal(
+                                        ImportablePublicKey.fingerprint);
+                                    expect(res[0].status).to.equal(
+                                        'change');
+                                    expect(
+                                        res[0].changes.userId).to.be.true;
+                                    expect(
+                                        res[0].changes.subkey).to.be.false;
+                                    expect(
+                                        res[0].changes.signature).to.be.true;
+                                    res[0].key.delete().then(function(result){
+                                        expect(result).to.be.true;
+                                        done();
+                                    });
+                                });
+                        });
+                });
+        });
+    });
+
+});
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
index f5d2be16..e5c2f749 100644
--- a/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
+++ b/lang/js/BrowserTestExtension/tests/encryptDecryptTest.js
@@ -163,7 +163,6 @@ describe('Encryption and Decryption', function () {
     }).timeout(3000);
 
     it('Random data, input as base64', function (done) {
-        //TODO fails. The result is
         let data = bigBoringString(0.001);
         let b64data = btoa(data);
         let prm = Gpgmejs.init();
@@ -177,11 +176,11 @@ describe('Encryption and Decryption', function () {
                         'BEGIN PGP MESSAGE');
                     expect(answer.data).to.include(
                         'END PGP MESSAGE');
-                    context.decrypt(answer.data).then(
+                    context.decrypt(answer.data, true).then(
                         function (result) {
                             expect(result).to.not.be.empty;
                             expect(result.data).to.be.a('string');
-                            expect(result.data).to.equal(data);
+                            expect(result.data).to.equal(b64data);
                             done();
                         });
                 });
diff --git a/lang/js/BrowserTestExtension/tests/inputvalues.js b/lang/js/BrowserTestExtension/tests/inputvalues.js
index 52e3a7b0..9dc13324 100644
--- a/lang/js/BrowserTestExtension/tests/inputvalues.js
+++ b/lang/js/BrowserTestExtension/tests/inputvalues.js
@@ -18,11 +18,12 @@
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
-var inputvalues = {
+var inputvalues = {// eslint-disable-line no-unused-vars
     encrypt: {
         good:{
             data : 'Hello World.',
-            // Fingerprint of a key that has been imported to gnupg (i.e. see testkey.pub; testkey.sec)
+            // Fingerprint of a key that has been imported to gnupg
+            // (i.e. see testkey.pub; testkey.sec)
             fingerprint : 'D41735B91236FDB882048C5A2301635EEFF0CB05',
             data_nonascii: '¡Äußerste µ€ før ñoquis@hóme! Добрый день',
 
@@ -45,7 +46,8 @@ var inputvalues = {
             ]
         },
         bad: {
-            // valid Hex value, but not usable (not imported to gnupg, or bogus fingerprint)
+            // valid Hex value, but not usable (not imported to gnupg, or
+            // bogus fingerprint)
             fingerprint: 'CDC3A2B2860625CCBFC5AAAAAC6D1B604967FC4A'
         }
     },
@@ -54,14 +56,13 @@ var inputvalues = {
         invalid_startups: [
             {all_passwords: true},
             'openpgpmode',
-            {api_style:"frankenstein"}
+            {api_style:'frankenstein'}
         ]
     }
 };
 
 // (Pseudo-)Random String covering all of utf8.
-function bigString(length){
-    var uint = '';
+function bigString(length){// eslint-disable-line no-unused-vars
     let arr = [];
     for (let i= 0; i < length; i++){
         arr.push(String.fromCharCode(
@@ -71,7 +72,7 @@ function bigString(length){
     return arr.join('');
 }
 
-function fixedLengthString(megabytes){
+function fixedLengthString(megabytes){// eslint-disable-line no-unused-vars
     let maxlength = 1024 * 1024 * megabytes / 2;
     let uint = new Uint8Array(maxlength);
     for (let i = 0; i < maxlength; i++){
@@ -83,7 +84,7 @@ function fixedLengthString(megabytes){
 }
 
 // (Pseudo-)Random Uint8Array, given size in Megabytes
-function bigUint8(megabytes){
+function bigUint8(megabytes){// eslint-disable-line no-unused-vars
     let maxlength = 1024 * 1024 * megabytes;
     let uint = new Uint8Array(maxlength);
     for (let i= 0; i < maxlength; i++){
@@ -92,11 +93,13 @@ function bigUint8(megabytes){
     return uint;
 }
 
-// (Pseudo-)Random string with very limited charset (ascii only, no control chars)
-function bigBoringString(megabytes){
+// (Pseudo-)Random string with very limited charset
+// (ascii only, no control chars)
+function bigBoringString(megabytes){// eslint-disable-line no-unused-vars
     let maxlength = 1024 * 1024 * megabytes;
     let string = [];
-    let chars = ' 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let chars =
+        ' 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
     for (let i= 0; i < maxlength; i++){
         string.push(chars[Math.floor(Math.random() * chars.length)]);
     }
@@ -105,12 +108,13 @@ function bigBoringString(megabytes){
 
 // Some String with simple chars, with different characteristics, but still
 // expected to occur in an averag message
+// eslint-disable-next-line no-unused-vars
 function slightlyLessBoringString(megabytes, set){
     let maxlength = 1024 * 1024 * megabytes;
     let string = [];
     let chars = '';
     if (set ===1 ) {
-        chars = '\n\"\r \'';
+        chars = '\n"\r \'';
     } else if (set === 2 ) {
         chars = '()=?`#+-{}[]';
     } else if (set === 3){
@@ -118,7 +122,7 @@ function slightlyLessBoringString(megabytes, set){
     } else if (set ===4) {
         chars = 'äüßµüþÖ~ɁÑ||@';
     } else {
-        chars = '*<>\n\"\r§$%&/()=?`#+-{}[] \'';
+        chars = '*<>\n"\r§$%&/()=?`#+-{}[] \'';
     }
     for (let i= 0; i < maxlength; i++){
         string.push(chars[Math.floor(Math.random() * chars.length)]);
@@ -127,7 +131,7 @@ function slightlyLessBoringString(megabytes, set){
 }
 
 // Data encrypted with testKey
-var encryptedData =
+var encryptedData =// eslint-disable-line no-unused-vars
     '-----BEGIN PGP MESSAGE-----\n' +
     '\n' +
     'hQEMA6B8jfIUScGEAQgAlANd3uyhmhYLzVcfz4LEqA8tgUC3n719YH0iuKEzG/dv\n' +
@@ -141,3 +145,76 @@ var encryptedData =
     'kSAQYOHplfA7YJWkrlRm\n' +
     '=zap6\n' +
     '-----END PGP MESSAGE-----\n';
+
+var ImportablePublicKey = {// eslint-disable-line no-unused-vars
+    fingerprint: '78034948BA7F5D0E9BDB67E4F63790C11E60278A',
+    key:'-----BEGIN PGP PUBLIC KEY BLOCK-----\n' +
+    '\n' +
+    'mQENBFsPvK0BCACaIgoIN+3g05mrTITULK/YDTrfg4W7RdzIZBxch5CM0zdu/dby\n' +
+    'esFwaJbVQIqu54CRz5xKAiWmRrQCaRvhvjY0na5r5UUIpbeQiOVrl65JtNbRmlik\n' +
+    'd9Prn1kZDUOZiCPIKn+/M2ecJ92YedM7I4/BbpiaFB11cVrPFg4thepn0LB3+Whp\n' +
+    '9HDm4orH9rjy6IUr6yjWNIr+LYRY6/Ip2vWcMVjleEpTFznXrm83hrJ0n0INtyox\n' +
+    'Nass4eDWkgo6ItxDFFLOORSmpfrToxZymSosWqgux/qG6sxHvLqlqy6Xe3ZYRFbG\n' +
+    '+JcA1oGdwOg/c0ndr6BYYiXTh8+uUJfEoZvzABEBAAG0HEJsYSBCbGEgPGJsYWJs\n' +
+    'YUBleGFtcGxlLm9yZz6JAVQEEwEIAD4WIQR4A0lIun9dDpvbZ+T2N5DBHmAnigUC\n' +
+    'Ww+8rQIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRD2N5DBHmAn\n' +
+    'igwIB/9K3E3Yev9taZP4KnXPhk1oMQRW1MWAsFGUr+70N85VwedpUawymW4vXi1+\n' +
+    'hMeTc39QjmZ0+VqHkJttkqEN6bLcEvgmU/mOlOgKdzy6eUcasYAzgoAKUqSX1SPs\n' +
+    '0Imo7Tj04wnfnVwvKxaeadi0VmdqIYaW75UlrzIaltsBctyeYH8sBrvaTLscb4ON\n' +
+    '46OM3Yw2G9+dBF0P+4UYFHP3EYZMlzNxfwF+i2HsYcNDHlcLfjENr9GwKn5FJqpY\n' +
+    'Iq3qmI37w1hVasHDxXdz1X06dpsa6Im4ACk6LXa7xIQlXxTgPAQV0sz2yB5eY+Md\n' +
+    'uzEXPGW+sq0WRp3hynn7kVP6QQYvuQENBFsPvK0BCACwvBcmbnGJk8XhEBRu2QN3\n' +
+    'jKgVs3CG5nE2Xh20JipZwAuGHugDLv6/jlizzz5jtj3SAHVtJB8lJW8I0cNSEIX8\n' +
+    'bRYH4C7lP2DTb9CgMcGErQIyK480+HIsbsZhJSNHdjUUl6IPEEVfSQzWaufmuswe\n' +
+    'e+giqHiTsaiW20ytXilwVGpjlHBaxn/bpskZ0YRasgnPqKgJD3d5kunNqWoyCpMc\n' +
+    'FYgDERvPbhhceFbvFE9G/u3gbcuV15mx53dDX0ImvPcvJnDOyJS9yr7ApdOV312p\n' +
+    'A1MLbxfPnbnVu+dGXn7D/VCDd5aBYVPm+5ANrk6z9lYKH9aO5wgXpLAdJvutCOL5\n' +
+    'ABEBAAGJATwEGAEIACYWIQR4A0lIun9dDpvbZ+T2N5DBHmAnigUCWw+8rQIbDAUJ\n' +
+    'A8JnAAAKCRD2N5DBHmAnigMVB/484G2+3R0cAaj3V/z4gW3MRSMhcYqEMyJ/ACdo\n' +
+    '7y8eoreYW843JWWVDRY6/YcYYGuBBP47WO4JuP2wIlVn17XOCSgnNjmmjsIYiAzk\n' +
+    'op772TB27o0VeiFX5iWcawy0EI7JCb23xpI+QP31ksL2yyRYFXCtXSUfcOrLpCY8\n' +
+    'aEQMQbAGtkag1wHTo/Tf/Vip8q0ZEQ4xOKTR2/ll6+inP8kzGyzadElUnH1Q1OUX\n' +
+    'd2Lj/7BpBHE2++hAjBQRgnyaONF7mpUNEuw64iBNs0Ce6Ki4RV2+EBLnFubnFNRx\n' +
+    'fFJcYXcijhuf3YCdWzqYmPpU/CtF4TgDlfSsdxHxVOmnZkY3\n' +
+    '=qP6s\n' +
+    '-----END PGP PUBLIC KEY BLOCK-----\n',
+
+    keyChangedUserId: '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' +
+    '\n' +
+    'mQENBFsPvK0BCACaIgoIN+3g05mrTITULK/YDTrfg4W7RdzIZBxch5CM0zdu/dby\n' +
+    'esFwaJbVQIqu54CRz5xKAiWmRrQCaRvhvjY0na5r5UUIpbeQiOVrl65JtNbRmlik\n' +
+    'd9Prn1kZDUOZiCPIKn+/M2ecJ92YedM7I4/BbpiaFB11cVrPFg4thepn0LB3+Whp\n' +
+    '9HDm4orH9rjy6IUr6yjWNIr+LYRY6/Ip2vWcMVjleEpTFznXrm83hrJ0n0INtyox\n' +
+    'Nass4eDWkgo6ItxDFFLOORSmpfrToxZymSosWqgux/qG6sxHvLqlqy6Xe3ZYRFbG\n' +
+    '+JcA1oGdwOg/c0ndr6BYYiXTh8+uUJfEoZvzABEBAAG0HEJsYSBCbGEgPGJsYWJs\n' +
+    'YUBleGFtcGxlLm9yZz6JAVQEEwEIAD4WIQR4A0lIun9dDpvbZ+T2N5DBHmAnigUC\n' +
+    'Ww+8rQIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRD2N5DBHmAn\n' +
+    'igwIB/9K3E3Yev9taZP4KnXPhk1oMQRW1MWAsFGUr+70N85VwedpUawymW4vXi1+\n' +
+    'hMeTc39QjmZ0+VqHkJttkqEN6bLcEvgmU/mOlOgKdzy6eUcasYAzgoAKUqSX1SPs\n' +
+    '0Imo7Tj04wnfnVwvKxaeadi0VmdqIYaW75UlrzIaltsBctyeYH8sBrvaTLscb4ON\n' +
+    '46OM3Yw2G9+dBF0P+4UYFHP3EYZMlzNxfwF+i2HsYcNDHlcLfjENr9GwKn5FJqpY\n' +
+    'Iq3qmI37w1hVasHDxXdz1X06dpsa6Im4ACk6LXa7xIQlXxTgPAQV0sz2yB5eY+Md\n' +
+    'uzEXPGW+sq0WRp3hynn7kVP6QQYvtCZTb21lb25lIEVsc2UgPHNvbWVvbmVlbHNl\n' +
+    'QGV4YW1wbGUub3JnPokBVAQTAQgAPhYhBHgDSUi6f10Om9tn5PY3kMEeYCeKBQJb\n' +
+    'D705AhsDBQkDwmcABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEPY3kMEeYCeK\n' +
+    'aIUH/2o+Ra+GzxgZrVexXLL+FCSmcu0cxeWfMhL8jd96c6uXIT21qQMRU2jgvnUp\n' +
+    'Wdi/BeLKp5lYwywm04PFhmRVxWXLuLArCsDu+CFys+aPeybnjikPBZov6P8/cZV3\n' +
+    'cd6zxFvqB9J15HjDMcl/r5v6d4CgSLKlFebrO5WKxHa6zGK9TRMQrqTu1heKHRf6\n' +
+    '4+Wj+MZmYnPzEQePjiBw/VkJ1Nm37Dd24gKdcN/qJFwEOqvbI5RIjB7xqoDslZk9\n' +
+    'sAivBXwF0E9HKqvh4WZZeA7uaWNdGo/cQkD5rab5SdHGNPHLbzoRWScsM8WYtsME\n' +
+    'dEMp5iPuG9M63+TD7losAkJ/TlS5AQ0EWw+8rQEIALC8FyZucYmTxeEQFG7ZA3eM\n' +
+    'qBWzcIbmcTZeHbQmKlnAC4Ye6AMu/r+OWLPPPmO2PdIAdW0kHyUlbwjRw1IQhfxt\n' +
+    'FgfgLuU/YNNv0KAxwYStAjIrjzT4cixuxmElI0d2NRSXog8QRV9JDNZq5+a6zB57\n' +
+    '6CKoeJOxqJbbTK1eKXBUamOUcFrGf9umyRnRhFqyCc+oqAkPd3mS6c2pajIKkxwV\n' +
+    'iAMRG89uGFx4Vu8UT0b+7eBty5XXmbHnd0NfQia89y8mcM7IlL3KvsCl05XfXakD\n' +
+    'UwtvF8+dudW750ZefsP9UIN3loFhU+b7kA2uTrP2Vgof1o7nCBeksB0m+60I4vkA\n' +
+    'EQEAAYkBPAQYAQgAJhYhBHgDSUi6f10Om9tn5PY3kMEeYCeKBQJbD7ytAhsMBQkD\n' +
+    'wmcAAAoJEPY3kMEeYCeKAxUH/jzgbb7dHRwBqPdX/PiBbcxFIyFxioQzIn8AJ2jv\n' +
+    'Lx6it5hbzjclZZUNFjr9hxhga4EE/jtY7gm4/bAiVWfXtc4JKCc2OaaOwhiIDOSi\n' +
+    'nvvZMHbujRV6IVfmJZxrDLQQjskJvbfGkj5A/fWSwvbLJFgVcK1dJR9w6sukJjxo\n' +
+    'RAxBsAa2RqDXAdOj9N/9WKnyrRkRDjE4pNHb+WXr6Kc/yTMbLNp0SVScfVDU5Rd3\n' +
+    'YuP/sGkEcTb76ECMFBGCfJo40XualQ0S7DriIE2zQJ7oqLhFXb4QEucW5ucU1HF8\n' +
+    'UlxhdyKOG5/dgJ1bOpiY+lT8K0XhOAOV9Kx3EfFU6admRjc=\n' +
+    '=9WZ7\n' +
+    '-----END PGP PUBLIC KEY BLOCK-----\n'
+};
diff --git a/lang/js/src/Connection.js b/lang/js/src/Connection.js
index 3480d811..8c4cba7c 100644
--- a/lang/js/src/Connection.js
+++ b/lang/js/src/Connection.js
@@ -103,7 +103,7 @@ export class Connection{
         }
         if (!message || !message instanceof GPGME_Message){
             this.disconnect();
-            return Promise.reject(gpgme_error('PARAM_WRONG'), message);
+            return Promise.reject(gpgme_error('PARAM_WRONG', 'Connection.post'));
         }
         if (message.isComplete !== true){
             this.disconnect();
@@ -221,12 +221,13 @@ class Answer{
                         if (!this._response.hasOwnProperty(key)){
                             this._response[key] = [];
                         }
+
                         if (Array.isArray(msg[key])) {
                             for (let i=0; i< msg[key].length; i++) {
                                 this._response[key].push(msg[key][i]);
                             }
                         } else {
-                            this._response[key].push(msg[key][i]);
+                            this._response[key].push(msg[key]);
                         }
                     }
                     else {
diff --git a/lang/js/src/Errors.js b/lang/js/src/Errors.js
index 3b53eeb4..2f2bfd5c 100644
--- a/lang/js/src/Errors.js
+++ b/lang/js/src/Errors.js
@@ -74,7 +74,7 @@ const err_list = {
     'KEY_NO_INIT': {
         msg:'This property has not been retrieved yet from GPG',
         type: 'error'
-    }
+    },
     // generic
     'PARAM_WRONG':{
         msg: 'Invalid parameter was found',
@@ -118,7 +118,11 @@ class GPGME_Error extends Error{
         if (code === 'GNUPG_ERROR' && typeof(msg) === 'string'){
             super(msg);
         } else if (err_list.hasOwnProperty(code)){
-            super(err_list[code].msg);
+            if (msg){
+                super(err_list[code].msg + "--" + msg);
+            } else {
+                super(err_list[code].msg);
+            }
         } else {
             super(err_list['GENERIC_ERROR'].msg);
         }
diff --git a/lang/js/src/Helpers.js b/lang/js/src/Helpers.js
index b26f40fb..5064d03e 100644
--- a/lang/js/src/Helpers.js
+++ b/lang/js/src/Helpers.js
@@ -29,7 +29,6 @@ import { GPGME_Key } from "./Key";
 
 export function toKeyIdArray(input){
     if (!input){
-        gpgme_error('MSG_NO_KEYS');
         return [];
     }
     if (!Array.isArray(input)){
@@ -61,7 +60,6 @@ export function toKeyIdArray(input){
         }
     }
     if (result.length === 0){
-        gpgme_error('MSG_NO_KEYS');
         return [];
     } else {
         return result;
diff --git a/lang/js/src/Key.js b/lang/js/src/Key.js
index 454b1912..d85c8b6e 100644
--- a/lang/js/src/Key.js
+++ b/lang/js/src/Key.js
@@ -207,7 +207,7 @@ export class GPGME_Key {
             msg.setParameter('armor', true);
             msg.setParameter('keys', me._data.fingerprint);
             msg.post().then(function(result){
-                me._data.armor = result.data;
+                me._data.armored = result.data;
                 resolve(result.data);
             }, function(error){
                 reject(error);
@@ -280,7 +280,7 @@ export class GPGME_Key {
     /**
      * Deletes the public Key from the GPG Keyring. Note that a deletion of a
      * secret key is not supported by the native backend.
-     * @returns {Boolean} Success if key was deleted, rejects with a GPG error
+     * @returns {Promise<Boolean>} Success if key was deleted, rejects with a GPG error
      * otherwise
      */
     delete(){
diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js
index 9081cbe9..c5e613ec 100644
--- a/lang/js/src/Keyring.js
+++ b/lang/js/src/Keyring.js
@@ -18,9 +18,9 @@
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
-import {createMessage} from './Message'
-import {GPGME_Key, createKey} from './Key'
-import { isFingerprint, toKeyIdArray } from './Helpers';
+import {createMessage} from './Message';
+import {createKey} from './Key';
+import { isFingerprint } from './Helpers';
 import { gpgme_error } from './Errors';
 
 export class GPGME_Keyring {
@@ -39,10 +39,8 @@ export class GPGME_Keyring {
      *
      */
     getKeys(pattern, prepare_sync){
-        let me = this;
         return new Promise(function(resolve, reject) {
-            let msg;
-            msg = createMessage('keylist');
+            let msg = createMessage('keylist');
             if (pattern !== undefined){
                 msg.setParameter('keys', pattern);
             }
@@ -50,25 +48,28 @@ export class GPGME_Keyring {
             msg.post().then(function(result){
                 let resultset = [];
                 let promises = [];
-                // TODO check if result.key is not empty
-                for (let i=0; i< result.keys.length; i++){
-                    let k = createKey(result.keys[i].fingerprint, me);
-                    k.setKeyData(result.keys[i]);
-                    if (prepare_sync === true){
-                        promises.push(k.getArmor());
-                        promises.push(k.getHasSecret());
+                if (result.keys.length === 0){
+                    resolve([]);
+                } else {
+                    for (let i=0; i< result.keys.length; i++){
+                        let k = createKey(result.keys[i].fingerprint);
+                        k.setKeyData(result.keys[i]);
+                        if (prepare_sync === true){
+                            promises.push(k.getArmor());
+                            promises.push(k.getHasSecret());
+                        }
+                        resultset.push(k);
                     }
-                    resultset.push(k);
-                }
-                if (promises.length > 0) {
-                    Promise.all(promises).then(function (res){
+                    if (promises.length > 0) {
+                        Promise.all(promises).then(function() {
+                            resolve(resultset);
+                        }, function(error){
+                            reject(error);
+                        });
+                    } else {
                         resolve(resultset);
-                    }, function(error){
-                        reject(error);
-                    });
+                    }
                 }
-            }, function(error){
-                reject(error);
             });
         });
     }
@@ -80,7 +81,6 @@ export class GPGME_Keyring {
      * @returns {Promise<String>} Armored Key blocks
      */
     getKeysArmored(pattern) {
-        if (pattern)
         return new Promise(function(resolve, reject) {
             let msg = createMessage('export');
             msg.setParameter('armor', true);
@@ -92,10 +92,102 @@ export class GPGME_Keyring {
             }, function(error){
                 reject(error);
             });
+        });
     }
 
     // getDefaultKey() Big TODO
-    // importKeys(armoredKeys)
-    // generateKey  --> TODO (Andre noch anfragen!)
 
-};
+    /**
+     *
+     * @param {String} armored Armored Key block of the Kex(s) to be imported into gnupg
+     * @param {Boolean} prepare_sync prepare the keys for synched use (see getKeys()).
+     * @returns {Promise<Array<Object>>} An array of objects for the Keys considered.
+    *       Key.key The key itself as a GPGME_Key
+     *      Key.status String:
+     *          'nochange' if the Key was not changed,
+     *          'newkey' if the Key was imported in gpg, and did not exist previously,
+     *          'change' if the key existed, but details were updated. For details,
+     *              Key.changes is available.
+     *      Key.changes.userId: Boolean userIds changed
+     *      Key.changes.signature: Boolean signatures changed
+     *      Key.changes.subkey: Boolean subkeys changed
+     * // TODO: not yet implemented: Information about Keys that failed
+     *          (e.g. malformed Keys, secretKeys are not accepted)
+     */
+    importKey(armored, prepare_sync) {
+        if (!armored || typeof(armored) !== 'string'){
+            return Promise.reject(gpgme_error('PARAM_WRONG'));
+        }
+        let me = this;
+        return new Promise(function(resolve, reject){
+            let msg = createMessage('import');
+            msg.setParameter('data', armored);
+            msg.post().then(function(response){
+                let infos = {};
+                let fprs = [];
+                for (var res=0; res < response.result[0].imports.length; res++) {
+                    let result = response.result[0].imports[res];
+                    let status = '';
+                    if (result.status === 0){
+                        status = 'nochange';
+                    } else if ((result.status & 1) === 1){
+                        status = 'newkey';
+                    } else {
+                        status = 'change';
+                    }
+                    let changes = {};
+                    changes.userId = (result.status & 2) === 2;
+                    changes.signature = (result.status & 4) === 4;
+                    changes.subkey = (result.status & 8) === 8;
+                    //16 new secret key: not implemented
+
+                    fprs.push(result.fingerprint);
+                    infos[result.fingerprint] = {
+                        changes: changes,
+                        status: status
+                    };
+                }
+                let resultset = [];
+                if (prepare_sync === true){
+                    me.getKeys(fprs, true).then(function(result){
+                        for (let i=0; i < result.length; i++) {
+                            resultset.push({
+                                key: result[i],
+                                changes: infos[result[i].fingerprint].changes,
+                                status: infos[result[i].fingerprint].status
+                            });
+                        }
+                        resolve(resultset);
+                    }, function(error){
+                        reject(error);
+                    });
+                } else {
+                    for (let i=0; i < fprs.length; i++) {
+                        resultset.push({
+                            key: createKey(fprs[i]),
+                            changes: infos[fprs[i]].changes,
+                            status: infos[fprs[i]].status
+                        });
+                    }
+                    resolve(resultset);
+                }
+
+            }, function(error){
+                reject(error);
+            });
+
+
+        });
+
+
+    }
+
+    deleteKey(fingerprint){
+        if (isFingerprint(fingerprint) === true) {
+            let key = createKey(fingerprint);
+            key.delete();
+        }
+    }
+
+    // generateKey
+}
diff --git a/lang/js/unittest_inputvalues.js b/lang/js/unittest_inputvalues.js
index 2a21a6ae..07147bac 100644
--- a/lang/js/unittest_inputvalues.js
+++ b/lang/js/unittest_inputvalues.js
@@ -1,5 +1,5 @@
-import {Connection} from "./src/Connection";
-import {createKey} from "./src/Key";
+import {Connection} from './src/Connection';
+import {createKey} from './src/Key';
 
 let conn = new Connection;
 
@@ -23,14 +23,14 @@ export const helper_params = {
     valid_openpgplike: { primaryKey: {
         getFingerprint: function(){
             return '85DE2A8BA5A5AB3A8A7BE2000B8AED24D7534BC2';}
-        }
     }
-}
+    }
+};
 
 export const message_params = {
     invalid_op_action : 'dance',
     invalid_op_type : [234, 34, '<>'],
-    valid_encrypt_data: "مرحبا بالعالم",
+    valid_encrypt_data: 'مرحبا بالعالم',
     invalid_param_test: {
         valid_op: 'encrypt',
         invalid_param_names: [22,'dance', {}],
@@ -38,18 +38,89 @@ export const message_params = {
         invalid_values_0: [2134, 'All your passwords',
             createKey('12AE9F3E41B33BF77DF52B6BE8EE1992D7909B08', conn), null]
     }
-}
+};
 
 export const whatever_params = {
     four_invalid_params: ['<(((-<', '>°;==;~~', '^^', '{{{{o}}}}'],
-}
+};
 export const key_params = {
 // A Key you own (= having a secret Key) in GPG. See testkey.pub/testkey.sec
     validKeyFingerprint: 'D41735B91236FDB882048C5A2301635EEFF0CB05',
-// A Key you do not own (= having no secret Key) in GPG. See testkey2.pub
+    // A Key you do not own (= having no secret Key) in GPG. See testkey2.pub
     validFingerprintNoSecret: 'E059A1E0866D31AE131170884D9A2E13304153D1',
-// A Key not in your Keyring. This is just a random hex string.
+    // A Key not in your Keyring. This is just a random hex string.
     invalidKeyFingerprint: 'CDC3A2B2860625CCBFC5AAAAAC6D1B604967FC4A',
     validKeyProperties: ['expired', 'disabled','invalid','can_encrypt',
-    'can_sign','can_certify','can_authenticate','secret','is_qualified']
-}
+        'can_sign','can_certify','can_authenticate','secret','is_qualified']
+};
+export const armoredKey = {
+    fingerprint: '78034948BA7F5D0E9BDB67E4F63790C11E60278A',
+    key:'-----BEGIN PGP PUBLIC KEY BLOCK-----\n' +
+        '\n' +
+        'mQENBFsPvK0BCACaIgoIN+3g05mrTITULK/YDTrfg4W7RdzIZBxch5CM0zdu/dby\n' +
+        'esFwaJbVQIqu54CRz5xKAiWmRrQCaRvhvjY0na5r5UUIpbeQiOVrl65JtNbRmlik\n' +
+        'd9Prn1kZDUOZiCPIKn+/M2ecJ92YedM7I4/BbpiaFB11cVrPFg4thepn0LB3+Whp\n' +
+        '9HDm4orH9rjy6IUr6yjWNIr+LYRY6/Ip2vWcMVjleEpTFznXrm83hrJ0n0INtyox\n' +
+        'Nass4eDWkgo6ItxDFFLOORSmpfrToxZymSosWqgux/qG6sxHvLqlqy6Xe3ZYRFbG\n' +
+        '+JcA1oGdwOg/c0ndr6BYYiXTh8+uUJfEoZvzABEBAAG0HEJsYSBCbGEgPGJsYWJs\n' +
+        'YUBleGFtcGxlLm9yZz6JAVQEEwEIAD4WIQR4A0lIun9dDpvbZ+T2N5DBHmAnigUC\n' +
+        'Ww+8rQIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRD2N5DBHmAn\n' +
+        'igwIB/9K3E3Yev9taZP4KnXPhk1oMQRW1MWAsFGUr+70N85VwedpUawymW4vXi1+\n' +
+        'hMeTc39QjmZ0+VqHkJttkqEN6bLcEvgmU/mOlOgKdzy6eUcasYAzgoAKUqSX1SPs\n' +
+        '0Imo7Tj04wnfnVwvKxaeadi0VmdqIYaW75UlrzIaltsBctyeYH8sBrvaTLscb4ON\n' +
+        '46OM3Yw2G9+dBF0P+4UYFHP3EYZMlzNxfwF+i2HsYcNDHlcLfjENr9GwKn5FJqpY\n' +
+        'Iq3qmI37w1hVasHDxXdz1X06dpsa6Im4ACk6LXa7xIQlXxTgPAQV0sz2yB5eY+Md\n' +
+        'uzEXPGW+sq0WRp3hynn7kVP6QQYvuQENBFsPvK0BCACwvBcmbnGJk8XhEBRu2QN3\n' +
+        'jKgVs3CG5nE2Xh20JipZwAuGHugDLv6/jlizzz5jtj3SAHVtJB8lJW8I0cNSEIX8\n' +
+        'bRYH4C7lP2DTb9CgMcGErQIyK480+HIsbsZhJSNHdjUUl6IPEEVfSQzWaufmuswe\n' +
+        'e+giqHiTsaiW20ytXilwVGpjlHBaxn/bpskZ0YRasgnPqKgJD3d5kunNqWoyCpMc\n' +
+        'FYgDERvPbhhceFbvFE9G/u3gbcuV15mx53dDX0ImvPcvJnDOyJS9yr7ApdOV312p\n' +
+        'A1MLbxfPnbnVu+dGXn7D/VCDd5aBYVPm+5ANrk6z9lYKH9aO5wgXpLAdJvutCOL5\n' +
+        'ABEBAAGJATwEGAEIACYWIQR4A0lIun9dDpvbZ+T2N5DBHmAnigUCWw+8rQIbDAUJ\n' +
+        'A8JnAAAKCRD2N5DBHmAnigMVB/484G2+3R0cAaj3V/z4gW3MRSMhcYqEMyJ/ACdo\n' +
+        '7y8eoreYW843JWWVDRY6/YcYYGuBBP47WO4JuP2wIlVn17XOCSgnNjmmjsIYiAzk\n' +
+        'op772TB27o0VeiFX5iWcawy0EI7JCb23xpI+QP31ksL2yyRYFXCtXSUfcOrLpCY8\n' +
+        'aEQMQbAGtkag1wHTo/Tf/Vip8q0ZEQ4xOKTR2/ll6+inP8kzGyzadElUnH1Q1OUX\n' +
+        'd2Lj/7BpBHE2++hAjBQRgnyaONF7mpUNEuw64iBNs0Ce6Ki4RV2+EBLnFubnFNRx\n' +
+        'fFJcYXcijhuf3YCdWzqYmPpU/CtF4TgDlfSsdxHxVOmnZkY3\n' +
+        '=qP6s\n' +
+        '-----END PGP PUBLIC KEY BLOCK-----\n',
+    keyChangedUserId: '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' +
+        '\n' +
+        'mQENBFsPvK0BCACaIgoIN+3g05mrTITULK/YDTrfg4W7RdzIZBxch5CM0zdu/dby\n' +
+        'esFwaJbVQIqu54CRz5xKAiWmRrQCaRvhvjY0na5r5UUIpbeQiOVrl65JtNbRmlik\n' +
+        'd9Prn1kZDUOZiCPIKn+/M2ecJ92YedM7I4/BbpiaFB11cVrPFg4thepn0LB3+Whp\n' +
+        '9HDm4orH9rjy6IUr6yjWNIr+LYRY6/Ip2vWcMVjleEpTFznXrm83hrJ0n0INtyox\n' +
+        'Nass4eDWkgo6ItxDFFLOORSmpfrToxZymSosWqgux/qG6sxHvLqlqy6Xe3ZYRFbG\n' +
+        '+JcA1oGdwOg/c0ndr6BYYiXTh8+uUJfEoZvzABEBAAG0HEJsYSBCbGEgPGJsYWJs\n' +
+        'YUBleGFtcGxlLm9yZz6JAVQEEwEIAD4WIQR4A0lIun9dDpvbZ+T2N5DBHmAnigUC\n' +
+        'Ww+8rQIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRD2N5DBHmAn\n' +
+        'igwIB/9K3E3Yev9taZP4KnXPhk1oMQRW1MWAsFGUr+70N85VwedpUawymW4vXi1+\n' +
+        'hMeTc39QjmZ0+VqHkJttkqEN6bLcEvgmU/mOlOgKdzy6eUcasYAzgoAKUqSX1SPs\n' +
+        '0Imo7Tj04wnfnVwvKxaeadi0VmdqIYaW75UlrzIaltsBctyeYH8sBrvaTLscb4ON\n' +
+        '46OM3Yw2G9+dBF0P+4UYFHP3EYZMlzNxfwF+i2HsYcNDHlcLfjENr9GwKn5FJqpY\n' +
+        'Iq3qmI37w1hVasHDxXdz1X06dpsa6Im4ACk6LXa7xIQlXxTgPAQV0sz2yB5eY+Md\n' +
+        'uzEXPGW+sq0WRp3hynn7kVP6QQYvtCZTb21lb25lIEVsc2UgPHNvbWVvbmVlbHNl\n' +
+        'QGV4YW1wbGUub3JnPokBVAQTAQgAPhYhBHgDSUi6f10Om9tn5PY3kMEeYCeKBQJb\n' +
+        'D705AhsDBQkDwmcABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEPY3kMEeYCeK\n' +
+        'aIUH/2o+Ra+GzxgZrVexXLL+FCSmcu0cxeWfMhL8jd96c6uXIT21qQMRU2jgvnUp\n' +
+        'Wdi/BeLKp5lYwywm04PFhmRVxWXLuLArCsDu+CFys+aPeybnjikPBZov6P8/cZV3\n' +
+        'cd6zxFvqB9J15HjDMcl/r5v6d4CgSLKlFebrO5WKxHa6zGK9TRMQrqTu1heKHRf6\n' +
+        '4+Wj+MZmYnPzEQePjiBw/VkJ1Nm37Dd24gKdcN/qJFwEOqvbI5RIjB7xqoDslZk9\n' +
+        'sAivBXwF0E9HKqvh4WZZeA7uaWNdGo/cQkD5rab5SdHGNPHLbzoRWScsM8WYtsME\n' +
+        'dEMp5iPuG9M63+TD7losAkJ/TlS5AQ0EWw+8rQEIALC8FyZucYmTxeEQFG7ZA3eM\n' +
+        'qBWzcIbmcTZeHbQmKlnAC4Ye6AMu/r+OWLPPPmO2PdIAdW0kHyUlbwjRw1IQhfxt\n' +
+        'FgfgLuU/YNNv0KAxwYStAjIrjzT4cixuxmElI0d2NRSXog8QRV9JDNZq5+a6zB57\n' +
+        '6CKoeJOxqJbbTK1eKXBUamOUcFrGf9umyRnRhFqyCc+oqAkPd3mS6c2pajIKkxwV\n' +
+        'iAMRG89uGFx4Vu8UT0b+7eBty5XXmbHnd0NfQia89y8mcM7IlL3KvsCl05XfXakD\n' +
+        'UwtvF8+dudW750ZefsP9UIN3loFhU+b7kA2uTrP2Vgof1o7nCBeksB0m+60I4vkA\n' +
+        'EQEAAYkBPAQYAQgAJhYhBHgDSUi6f10Om9tn5PY3kMEeYCeKBQJbD7ytAhsMBQkD\n' +
+        'wmcAAAoJEPY3kMEeYCeKAxUH/jzgbb7dHRwBqPdX/PiBbcxFIyFxioQzIn8AJ2jv\n' +
+        'Lx6it5hbzjclZZUNFjr9hxhga4EE/jtY7gm4/bAiVWfXtc4JKCc2OaaOwhiIDOSi\n' +
+        'nvvZMHbujRV6IVfmJZxrDLQQjskJvbfGkj5A/fWSwvbLJFgVcK1dJR9w6sukJjxo\n' +
+        'RAxBsAa2RqDXAdOj9N/9WKnyrRkRDjE4pNHb+WXr6Kc/yTMbLNp0SVScfVDU5Rd3\n' +
+        'YuP/sGkEcTb76ECMFBGCfJo40XualQ0S7DriIE2zQJ7oqLhFXb4QEucW5ucU1HF8\n' +
+        'UlxhdyKOG5/dgJ1bOpiY+lT8K0XhOAOV9Kx3EfFU6admRjc=\n' +
+        '=9WZ7\n' +
+        '-----END PGP PUBLIC KEY BLOCK-----\n'
+};
\ No newline at end of file
diff --git a/lang/js/unittests.js b/lang/js/unittests.js
index 443aa685..d1118448 100644
--- a/lang/js/unittests.js
+++ b/lang/js/unittests.js
@@ -17,19 +17,19 @@
  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  */
-import "./node_modules/mocha/mocha";
-import "./node_modules/chai/chai";
-import { helper_params as hp } from "./unittest_inputvalues";
-import { message_params as mp } from "./unittest_inputvalues";
-import { whatever_params as wp } from "./unittest_inputvalues";
-import { key_params as kp } from "./unittest_inputvalues";
-import { Connection } from "./src/Connection";
-import { gpgme_error } from "./src/Errors";
-import { toKeyIdArray , isFingerprint } from "./src/Helpers";
-import { GPGME_Key , createKey } from "./src/Key";
-import { GPGME_Keyring } from "./src/Keyring";
-import {GPGME_Message, createMessage} from "./src/Message";
-import { setTimeout } from "timers";
+
+import './node_modules/mocha/mocha'; /*global mocha, it, describe*/
+import './node_modules/chai/chai';/*global chai*/
+import { helper_params as hp } from './unittest_inputvalues';
+import { message_params as mp } from './unittest_inputvalues';
+import { whatever_params as wp } from './unittest_inputvalues';
+import { key_params as kp } from './unittest_inputvalues';
+import { Connection } from './src/Connection';
+import { gpgme_error } from './src/Errors';
+import { toKeyIdArray , isFingerprint } from './src/Helpers';
+import { GPGME_Key , createKey } from './src/Key';
+import { GPGME_Keyring } from './src/Keyring';
+import {GPGME_Message, createMessage} from './src/Message';
 
 mocha.setup('bdd');
 var expect = chai.expect;
@@ -74,12 +74,14 @@ function unittests (){
             expect(test0.code).to.equal('CONN_TIMEOUT');
         });
 
-        it('Error Object returns generic code if code is not listed', function(){
-            let test0 = gpgme_error(hp.invalidErrorCode);
+        it('Error Object returns generic code if code is not listed',
+            function(){
+                let test0 = gpgme_error(hp.invalidErrorCode);
 
-            expect(test0).to.be.an.instanceof(Error);
-            expect(test0.code).to.equal('GENERIC_ERROR');
-        });
+                expect(test0).to.be.an.instanceof(Error);
+                expect(test0.code).to.equal('GENERIC_ERROR');
+            }
+        );
 
         it('Warnings like PARAM_IGNORED should not return errors', function(){
             let test0 = gpgme_error('PARAM_IGNORED');
@@ -201,7 +203,7 @@ function unittests (){
 
         it('Non-cached key async armored Key', function (done){
             let key = createKey(kp.validKeyFingerprint);
-            key.get('armor', false).then(function(result){
+            key.get('armored', false).then(function(result){
                 expect(result).to.be.a('string');
                 expect(result).to.include('KEY BLOCK-----');
                 done();
@@ -233,7 +235,7 @@ function unittests (){
                     expect(error).to.be.an.instanceof(Error);
                     expect(error.code).to.equal('KEY_NOKEY');
                     done();
-            });
+                });
         });
 
         it('createKey returns error if parameters are wrong', function(){
@@ -269,14 +271,74 @@ function unittests (){
             keyring.getKeys(null, true).then(function(result){
                 expect(result).to.be.an('array');
                 expect(result[0]).to.be.an.instanceof(GPGME_Key);
-                expect(result[0].get('armor')).to.be.a('string');
-                expect(result[0].get('armor')).to.include(
+                expect(result[0].get('armored')).to.be.a('string');
+                expect(result[0].get('armored')).to.include(
                     '-----END PGP PUBLIC KEY BLOCK-----');
                 done();
             });
         });
+
+        it('Loading specific Key from Keyring, to be used synchronously', function(done){
+            let keyring = new GPGME_Keyring;
+            keyring.getKeys(kp.validKeyFingerprint, true).then(function(result){
+                expect(result).to.be.an('array');
+                expect(result[0]).to.be.an.instanceof(GPGME_Key);
+                expect(result[0].get('armored')).to.be.a('string');
+                expect(result[0].get('armored')).to.include(
+                    '-----END PGP PUBLIC KEY BLOCK-----');
+                done();
+            });
+        });
+
+        it('Querying non-existing Key from Keyring', function(done){
+            let keyring = new GPGME_Keyring;
+            keyring.getKeys(kp.invalidKeyFingerprint, true).then(function(result){
+                expect(result).to.be.an('array');
+                expect(result.length).to.equal(0);
+                done();
+            });
+        });
     });
 
+    // describe('Keyring import/export', function(){
+    //     before(function(done) {
+    //         let keyring = new GPGME_Keyring;
+
+    //         keyring.getKeys(ak.fingerprint, false).then(function(result){
+    //             if (result.length === 1){
+    //                 result[0].delete().then(function(delete_result){
+    //                     if (delete_result === true){
+    //                         done();
+    //                     }
+    //                 });
+    //             } else {
+    //                 done();
+    //             }
+    //         });
+    //     });
+    //     it('Import Public Key', function(done){
+    //         keyring.importKey(ak.key).then(function(result){
+    //             expect(result).to.be.an('array');
+    //             expect(result[0].key).to.be.an.instanceof(GPGME_Key);
+    //             expect(result[0].changed).to.equal('newkey');
+    //             expect(result[0].key.keyring).to.equal(ak.fingerprint);
+    //             done();
+    //         });
+    //     });
+
+    //     it('Update Public Key', function(done){
+    //         keyring.importKey(ak.key).then(function(result){
+    //             expect(result).to.be.an('array');
+    //             expect(result[0].key).to.be.an.instanceof(GPGME_Key);
+    //             expect(result[0].changed).to.equal('change');
+    //             expect(result[0].changes.userId).to.be.true;
+    //             expect(result[0].changes.subkeys).to.be.false;
+    //             expect(result[0].key.keyring).to.equal(ak.fingerprint);
+    //             done();
+    //         });
+    //     });
+    // });
+
     describe('GPGME_Message', function(){
 
         it('creating encrypt Message', function(){
@@ -330,12 +392,12 @@ function unittests (){
             let test0 = createMessage(mp.invalid_param_test.valid_op);
             for (let i=0;
                 i < mp.invalid_param_test.invalid_param_names.length; i++){
-                    let ret = test0.setParameter(
-                        mp.invalid_param_test.invalid_param_names[i],
-                        'Somevalue');
+                let ret = test0.setParameter(
+                    mp.invalid_param_test.invalid_param_names[i],
+                    'Somevalue');
 
-                    expect(ret).to.be.an.instanceof(Error);
-                    expect(ret.code).to.equal('PARAM_WRONG');
+                expect(ret).to.be.an.instanceof(Error);
+                expect(ret.code).to.equal('PARAM_WRONG');
             }
         });
 
@@ -343,12 +405,12 @@ function unittests (){
             let test0 = createMessage(mp.invalid_param_test.valid_op);
             for (let j=0;
                 j < mp.invalid_param_test.invalid_values_0.length; j++){
-                    let ret = test0.setParameter(
-                        mp.invalid_param_test.validparam_name_0,
-                        mp.invalid_param_test.invalid_values_0[j]);
+                let ret = test0.setParameter(
+                    mp.invalid_param_test.validparam_name_0,
+                    mp.invalid_param_test.invalid_values_0[j]);
 
-                    expect(ret).to.be.an.instanceof(Error);
-                    expect(ret.code).to.equal('PARAM_WRONG');
+                expect(ret).to.be.an.instanceof(Error);
+                expect(ret.code).to.equal('PARAM_WRONG');
             }
         });
     });
-- 
cgit 


From 8964627f6ad7c407785a9fa5cb508c7c28be0d60 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Mon, 9 Jul 2018 11:57:01 +0200
Subject: js: fix verify result reporting

--

* src/Signature.js: searching for overall validity in the "summary"
  property
* BrowsertestExtension: Added two verify tests
---
 lang/js/BrowserTestExtension/browsertest.html    |  1 +
 lang/js/BrowserTestExtension/tests/verifyTest.js | 86 ++++++++++++++++++++++++
 lang/js/src/Signature.js                         |  3 +-
 3 files changed, 88 insertions(+), 2 deletions(-)
 create mode 100644 lang/js/BrowserTestExtension/tests/verifyTest.js

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index f3d7a406..de8cd41a 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -18,6 +18,7 @@
     <script src="tests/encryptTest.js"></script>
     <script src="tests/encryptDecryptTest.js"></script>
     <script src="tests/signTest.js"></script>
+    <script src="tests/verifyTest.js"></script>
     <script src="tests/KeyImportExport.js"></script>
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
diff --git a/lang/js/BrowserTestExtension/tests/verifyTest.js b/lang/js/BrowserTestExtension/tests/verifyTest.js
new file mode 100644
index 00000000..bf0f0c0f
--- /dev/null
+++ b/lang/js/BrowserTestExtension/tests/verifyTest.js
@@ -0,0 +1,86 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ *
+ * Author(s):
+ *     Maximilian Krambach <mkrambach@intevation.de>
+ */
+
+/* global describe, it, expect, bigString, inputvalues, Gpgmejs */
+
+let verifyData = {
+    signedMessage: '-----BEGIN PGP SIGNED MESSAGE-----\n' +
+    'Hash: SHA256\n' +
+    '\n' +
+    'Matschige Münsteraner Marshmallows\n' +
+    '-----BEGIN PGP SIGNATURE-----\n' +
+    '\n' +
+    'iQEzBAEBCAAdFiEE34YHmHCyv9oBiN3shwTx6WpaVdQFAlsqWxYACgkQhwTx6Wpa\n' +
+    'VdRaTQf9Fj8agQzbE6DtonewZVGzj1KmjjpyAypnDldY21lrN8zIaQ+aKqRVkVrV\n' +
+    '5A/MeUfoHh0b/9G1Co4LOuNjGS14GRNlFvPtxeA2mCwlk7kgP2i6ekbHdEXWcG9c\n' +
+    'gSbzdJ3EgfVCFNkC/yhldXSLOJZ7oyiGEteDpi8dDSa9dIprT++sQ4kRuR8jPrIi\n' +
+    'UUY+DltG3it7PybcTFfQm53I0mtnpFsizzCmgyJAkfG5fwVL3uWwbYGofD049PSu\n' +
+    '6IEkSY74r8JbAbkCOiF/ln40RYGSwM0Ta5rrb3A3MixZNL/a1r17oljkaWz8e8VT\n' +
+    'N7NUgBHwbIQ4e3RLuUU8fF3ICCGDOw==\n' +
+    '=oGai\n' +
+    '-----END PGP SIGNATURE-----\n'
+};
+
+describe('Verify data', function () {
+    it('Successful verify message', function (done) {
+        let message = verifyData.signedMessage;
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            context.verify(message).then(function(result){
+                expect(result.data).to.be.a('string');
+                expect(result.all_valid).to.be.true;
+                expect(result.count).to.equal(1);
+                expect(result.signatures.good).to.be.an('array');
+                expect(result.signatures.good.length).to.equal(1);
+                expect(result.signatures.good[0].fingerprint)
+                    .to.be.a('string');
+                expect(result.signatures.good[0].valid).to.be.true;
+                done();
+            });
+        });
+    });
+
+    it('Encrypt-Sign-Verify random message', function (done) {
+        let message = bigString(2000);
+        let fpr = inputvalues.encrypt.good.fingerprint;
+        let prm = Gpgmejs.init();
+        prm.then(function (context) {
+            context.encrypt(message, fpr).then(function(message_enc){
+                context.sign(message_enc.data, fpr).then(function(message_encsign){
+                    context.verify(message_encsign.data).then(function(result){
+                        expect(result.data).to.equal(message_enc.data);
+                        expect(result.data).to.be.a('string');
+                        expect(result.all_valid).to.be.true;
+                        expect(result.count).to.equal(1);
+                        expect(result.signatures.good).to.be.an('array');
+                        expect(result.signatures.good.length).to.equal(1);
+                        expect(result.signatures.good[0].fingerprint)
+                            .to.equal(fpr);
+                        expect(result.signatures.good[0].valid).to.be.true;
+                        done();
+                    });
+                });
+            });
+        });
+    });
+});
\ No newline at end of file
diff --git a/lang/js/src/Signature.js b/lang/js/src/Signature.js
index a07fc4d1..c3c511a8 100644
--- a/lang/js/src/Signature.js
+++ b/lang/js/src/Signature.js
@@ -67,7 +67,6 @@ export function createSignature(sigObject){
             }
         }
     }
-    console.log('sig created');
     return new GPGME_Signature(sigObject);
 }
 
@@ -114,7 +113,7 @@ class GPGME_Signature {
      * additional information
      */
     get valid() {
-        if (this._rawSigObject.valid === true){
+        if (this._rawSigObject.summary.valid === true){
             return true;
         } else {
             return false;
-- 
cgit 


From 68a012deb3b501d7417778be12c88bd475a37cb5 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Wed, 1 Aug 2018 12:51:12 +0200
Subject: js: make init export immutable

--

* src/index.js: The export now uses a freezed Object, which does not
  allow for simply overwriting the init method by e.g. a third-party
  library.
* BrowsertestExtension: Added some tests trying if decryption of bad
  data properly fails
---
 lang/js/BrowserTestExtension/browsertest.html     |  1 +
 lang/js/BrowserTestExtension/tests/decryptTest.js | 62 +++++++++++++++++++++++
 lang/js/BrowserTestExtension/tests/inputvalues.js | 36 +++++++++++++
 lang/js/src/index.js                              |  7 ++-
 4 files changed, 102 insertions(+), 4 deletions(-)
 create mode 100644 lang/js/BrowserTestExtension/tests/decryptTest.js

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index de8cd41a..a20cfe19 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -19,6 +19,7 @@
     <script src="tests/encryptDecryptTest.js"></script>
     <script src="tests/signTest.js"></script>
     <script src="tests/verifyTest.js"></script>
+    <script src="tests/decryptTest.js"></script>
     <script src="tests/KeyImportExport.js"></script>
 <!-- run tests -->
     <script src="runbrowsertest.js"></script>
diff --git a/lang/js/BrowserTestExtension/tests/decryptTest.js b/lang/js/BrowserTestExtension/tests/decryptTest.js
new file mode 100644
index 00000000..c6b3a3c5
--- /dev/null
+++ b/lang/js/BrowserTestExtension/tests/decryptTest.js
@@ -0,0 +1,62 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ *
+ * Author(s):
+ *     Maximilian Krambach <mkrambach@intevation.de>
+ */
+
+/* global describe, it, before, expect, Gpgmejs */
+/* global bigString, inputvalues, sabotageMsg*/
+
+describe('Decryption', function () {
+    let context = null;
+    const good_fpr = inputvalues.encrypt.good.fingerprint;
+
+    before(function(done){
+        const prm = Gpgmejs.init();
+        prm.then(function(gpgmejs){
+            context = gpgmejs;
+            done();
+        });
+    });
+
+    it('Decryption of random string fails', function (done) {
+        let data = bigString(20 * 1024);
+        context.decrypt(data).then(
+            function(){},
+            function(error){
+                expect(error).to.be.an('error');
+                expect(error.code).to.equal('GNUPG_ERROR');
+                done();
+            });
+    });
+
+    it('Decryption of slightly corrupted message fails', function (done) {
+        const data = bigString(10000);
+        context.encrypt(data, good_fpr).then(function(enc){
+            context.decrypt(sabotageMsg(enc.data)).then(
+                function(){},
+                function(error){
+                    expect(error).to.be.an('error');
+                    expect(error.code).to.equal('GNUPG_ERROR');
+                    done();
+                });
+        });
+    }).timeout(5000);
+});
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/tests/inputvalues.js b/lang/js/BrowserTestExtension/tests/inputvalues.js
index 9d956b69..1e8f1544 100644
--- a/lang/js/BrowserTestExtension/tests/inputvalues.js
+++ b/lang/js/BrowserTestExtension/tests/inputvalues.js
@@ -248,3 +248,39 @@ const ImportablePublicKey = {// eslint-disable-line no-unused-vars
     '=9WZ7\n' +
     '-----END PGP PUBLIC KEY BLOCK-----\n'
 };
+
+/**
+ * Changes base64 encoded gpg messages
+ * @param {String} msg input message
+ * @param {Number} rate of changes as percentage of message length.
+ * @param {[Number, Number]} p begin and end of the message left untouched (to
+ * preserve) header/footer
+ */
+// eslint-disable-next-line no-unused-vars
+function sabotageMsg(msg, rate = 0.01, p= [35,35]){
+    const iterations = Math.floor(Math.random() * msg.length * rate) + 1;
+    const base64_set =
+        'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/';
+    for (let i=0; i < iterations; i++){
+        let str0, str1, str2;
+        const chosePosition = function(){
+            let position =
+                Math.floor( Math.random() * (msg.length - p[0] + p[1]))
+                + p[0];
+            str1 = msg.substring(position,position+1);
+            if (str1 === '\n'){
+                chosePosition();
+            } else {
+                str0 = msg.substring(0,position);
+                str2 = msg.substring(position +1);
+            }
+        };
+        chosePosition();
+        let new1 = function(){
+            let n = base64_set[Math.floor(Math.random() * 64)];
+            return (n === str1) ? new1() : n;
+        };
+        msg = str0.concat(new1()).concat(str2);
+    }
+    return msg;
+}
diff --git a/lang/js/src/index.js b/lang/js/src/index.js
index 2fed95f9..51f07538 100644
--- a/lang/js/src/index.js
+++ b/lang/js/src/index.js
@@ -34,7 +34,7 @@ import { Connection } from './Connection';
  */
 function init(){
     return new Promise(function(resolve, reject){
-        let connection = Object.freeze(new Connection);
+        const connection = Object.freeze(new Connection);
         connection.checkConnection(false).then(
             function(result){
                 if (result === true) {
@@ -48,6 +48,5 @@ function init(){
     });
 }
 
-export default {
-    init: init
-};
\ No newline at end of file
+const exportvalue = Object.freeze({init:init});
+export default exportvalue;
\ No newline at end of file
-- 
cgit 


From 622db0d1de665dfd93c991cd2d517078b04b3a13 Mon Sep 17 00:00:00 2001
From: Maximilian Krambach <maximilian.krambach@intevation.de>
Date: Thu, 16 Aug 2018 11:25:50 +0200
Subject: js: consistently return uppercase fingerprint

--

* src/Key.js: the fingerprint returned by a Key is now always upper
  case hex, even if the constructor had lower case input. This is to be
  more consistent with gpgme and to be more readable and reliable in
  comparisions.
---
 lang/js/BrowserTestExtension/browsertest.html     |  1 +
 lang/js/BrowserTestExtension/tests/KeyInfos.js    | 46 +++++++++++++++++++++++
 lang/js/BrowserTestExtension/tests/inputvalues.js |  1 +
 lang/js/src/Key.js                                |  5 ++-
 4 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 lang/js/BrowserTestExtension/tests/KeyInfos.js

(limited to 'lang/js/BrowserTestExtension/browsertest.html')

diff --git a/lang/js/BrowserTestExtension/browsertest.html b/lang/js/BrowserTestExtension/browsertest.html
index a20cfe19..0d3e2936 100644
--- a/lang/js/BrowserTestExtension/browsertest.html
+++ b/lang/js/BrowserTestExtension/browsertest.html
@@ -15,6 +15,7 @@
     <script src="tests/inputvalues.js"></script>
 <!-- insert tests here-->
     <script src="tests/startup.js"></script>
+    <script src="tests/KeyInfos.js"></script>
     <script src="tests/encryptTest.js"></script>
     <script src="tests/encryptDecryptTest.js"></script>
     <script src="tests/signTest.js"></script>
diff --git a/lang/js/BrowserTestExtension/tests/KeyInfos.js b/lang/js/BrowserTestExtension/tests/KeyInfos.js
new file mode 100644
index 00000000..03773a44
--- /dev/null
+++ b/lang/js/BrowserTestExtension/tests/KeyInfos.js
@@ -0,0 +1,46 @@
+/* gpgme.js - Javascript integration for gpgme
+ * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * GPGME is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * SPDX-License-Identifier: LGPL-2.1+
+ *
+ * Author(s):
+ *     Maximilian Krambach <mkrambach@intevation.de>
+ */
+
+/* global describe, it, expect, before, Gpgmejs */
+/* global inputvalues, fixedLengthString */
+
+describe('Key information', function () {
+    let context = null;
+    before(function(done){
+        const prm = Gpgmejs.init();
+        prm.then(function(gpgmejs){
+            context = gpgmejs;
+            done();
+        });
+    });
+
+    it('A fingerprint is consistently returned upper case hex', function(done){
+        const mixedCase = inputvalues.encrypt.good.fingerprint_mixedcase;
+        context.Keyring.getKeys(mixedCase).then(function(result){
+            expect(result).to.be.an('array');
+            expect(result.length).to.equal(1);
+            expect(result[0].fingerprint).to.equal(mixedCase.toUpperCase());
+            done();
+        });
+    });
+});
\ No newline at end of file
diff --git a/lang/js/BrowserTestExtension/tests/inputvalues.js b/lang/js/BrowserTestExtension/tests/inputvalues.js
index 1e8f1544..7dda47cd 100644
--- a/lang/js/BrowserTestExtension/tests/inputvalues.js
+++ b/lang/js/BrowserTestExtension/tests/inputvalues.js
@@ -28,6 +28,7 @@ const inputvalues = {// eslint-disable-line no-unused-vars
             // Fingerprint of a key that has been imported to gnupg
             // (i.e. see testkey.pub; testkey.sec)
             fingerprint : 'D41735B91236FDB882048C5A2301635EEFF0CB05',
+            fingerprint_mixedcase: 'D41735B91236fdb882048C5A2301635eeFF0Cb05',
             data_nonascii: '¡Äußerste µ€ før ñoquis@hóme! Добрый день',
 
             // used for checking encoding consistency in > 2MB messages.
diff --git a/lang/js/src/Key.js b/lang/js/src/Key.js
index 88c49d3f..eeb27035 100644
--- a/lang/js/src/Key.js
+++ b/lang/js/src/Key.js
@@ -58,7 +58,7 @@ export class GPGME_Key {
          */
         this.isAsync = async;
 
-        let _data = {fingerprint: fingerprint};
+        let _data = {fingerprint: fingerprint.toUpperCase()};
         this.getFingerprint = function(){
             if (!_data.fingerprint || !isFingerprint(_data.fingerprint)){
                 return gpgme_error('KEY_INVALID');
@@ -88,7 +88,8 @@ export class GPGME_Key {
             if (typeof(data) !== 'object') {
                 return gpgme_error('KEY_INVALID');
             }
-            if (!data.fingerprint || data.fingerprint !== _data.fingerprint){
+            if (!data.fingerprint ||
+                data.fingerprint.toUpperCase() !== _data.fingerprint){
                 return gpgme_error('KEY_INVALID');
             }
             let keys = Object.keys(data);
-- 
cgit