@codefresh-io/service-base 3.0.19 → 3.0.21

package/infra/config.js

@@ -116,7 +116,12 @@ base.logger = {
             try {
                 const authEntity = getAuthenticatedEntity().toJson({ partial: true });
                 if (_.get(authEntity, 'activeAccount')) {
-                    authEntity.activeAccount = _.omit(authEntity.activeAccount, 'features');
+                    // eslint-disable-next-line max-len
+                    authEntity.activeAccount = _.pick(authEntity.activeAccount, ['type', 'id', 'name', 'activeAccount.name', 'activeAccount.id']);
+                }
+
+                if (_.get(authEntity, 'account')) {
+                    authEntity.account = _.pick(authEntity.account, ['type', 'id', 'name', 'account.name', 'account.id']);
                 }
                 return authEntity;
             } catch (err) {

package/infra/encryption/safe.js

@@ -51,11 +51,18 @@ Safe.prototype.read_crypto = function (ciphertext) { // eslint-disable-line
     const iv = Buffer.alloc(16, this.safeModel.key);
 
     const shouldParse = ciphertext.startsWith(STRINGIFY_CRYPTO_PREFIX);
-    const prefixLength = (shouldParse ? STRINGIFY_CRYPTO_PREFIX : CRYPTO_PREFIX).length;
+    const prefix = shouldParse ? STRINGIFY_CRYPTO_PREFIX : CRYPTO_PREFIX;
+
+    // don't try to encrypt empty strings
+    // this causes segfault with node.js >= 14.x.x
+    if (ciphertext === CRYPTO_PREFIX) {
+        deferred.resolve('');
+        return deferred.promise;
+    }
 
     const encrypt = 0; // 0 = Decrypt
     cryptoAsync.cipher(
-        ALGORITHM, encrypt, key, iv, Buffer.from(ciphertext.slice(prefixLength), 'hex'),
+        ALGORITHM, encrypt, key, iv, Buffer.from(ciphertext.slice(prefix.length), 'hex'),
         (error, plaintext) => {
             if (error) {
                 deferred.reject(error);
@@ -75,8 +82,16 @@ Safe.prototype.write_crypto = function (plaintext) { // eslint-disable-line
     const iv = Buffer.alloc(16, this.safeModel.key);
 
     const shouldStringify = !_.isString(plaintext);
+    const prefix = shouldStringify ? STRINGIFY_CRYPTO_PREFIX : CRYPTO_PREFIX;
     const textToEncrypt = shouldStringify ? JSON.stringify(plaintext) : plaintext;
 
+    // don't try to encrypt empty strings
+    // this causes segfault with node.js >= 14.x.x
+    if (textToEncrypt === '') {
+        deferred.resolve(prefix);
+        return deferred.promise;
+    }
+
     const encrypt = 1; // 1 = Encrypt
     cryptoAsync.cipher(
         ALGORITHM, encrypt, key, iv, Buffer.from(textToEncrypt),
@@ -85,7 +100,7 @@ Safe.prototype.write_crypto = function (plaintext) { // eslint-disable-line
                 deferred.reject(error);
                 return;
             }
-            deferred.resolve(`${shouldStringify ? STRINGIFY_CRYPTO_PREFIX : CRYPTO_PREFIX}${ciphertext.toString('hex')}`);
+            deferred.resolve(`${prefix}${ciphertext.toString('hex')}`);
         },
     );
     return deferred.promise;

package/infra/encryption/safe.unit.spec.js

@@ -65,13 +65,15 @@ const STRINGIFY_CRYPTO_PREFIX = '$$$crypto-obj$$$';
     it('should encrypt all object', () => {
       const objToEncrypt = {
         keyToBeEncrypted: 'value-1',
-        keyToBeEncrypted2: 'value-2'
+        keyToBeEncrypted2: 'value-2',
+        keyToBeEncrypted3: '',
       };
       const keysToEncrypt = Object.keys(objToEncrypt);
       return encryptObjectValues(generateSafeId(), objToEncrypt, keysToEncrypt)
         .then((res) => {
           expect(res.keyToBeEncrypted).to.have.string(CRYPTO_PREFIX);
           expect(res.keyToBeEncrypted2).to.have.string(CRYPTO_PREFIX);
+          expect(res.keyToBeEncrypted3).to.equal(CRYPTO_PREFIX);
         });
     });
 
@@ -125,7 +127,8 @@ const STRINGIFY_CRYPTO_PREFIX = '$$$crypto-obj$$$';
     it('should decrypt encrypted object', () => {
       const objToEncrypt = {
         keyToBeEncrypted: 'value-1',
-        keyToBeEncrypted2: 'value-2'
+        keyToBeEncrypted2: 'value-2',
+        keyToBeEncrypted3: '', // should be decrypted as empty string
       };
       const keysToEncrypt = Object.keys(objToEncrypt);
       return encryptObjectValues(generateSafeId(), objToEncrypt, keysToEncrypt)
@@ -133,7 +136,9 @@ const STRINGIFY_CRYPTO_PREFIX = '$$$crypto-obj$$$';
           return decryptObjectValues(generateSafeId(), res, keysToEncrypt);
         })
         .then((decrypted) => {
-          expect(decrypted).to.be.deep.equal(objToEncrypt);
+            expect(decrypted.keyToBeEncrypted).to.be.deep.equal(objToEncrypt.keyToBeEncrypted);
+            expect(decrypted.keyToBeEncrypted2).to.be.deep.equal(objToEncrypt.keyToBeEncrypted2);
+            expect(decrypted.keyToBeEncrypted3).to.be.equal('');
         });
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefresh-io/service-base",
-  "version": "3.0.19",
+  "version": "3.0.21",
   "main": "index.js",
   "description": "",
   "bin": {