agent-skill-manager 1.22.0 → 2.0.0

package/node_modules/ssh2/test/test-protocol-crypto.js

@@ -1,631 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const { randomBytes } = require('crypto');
-
-const {
-  CIPHER_INFO,
-  MAC_INFO,
-  bindingAvailable,
-  NullCipher,
-  createCipher,
-  NullDecipher,
-  createDecipher,
-  init: cryptoInit,
-} = require('../lib/protocol/crypto.js');
-
-(async () => {
-  await cryptoInit;
-
-  console.log(`Crypto binding ${bindingAvailable ? '' : 'not '}available`);
-  {
-    const PAIRS = [
-      // cipher, decipher
-      ['native', 'native'],
-      ['binding', 'native'],
-      ['native', 'binding'],
-      ['binding', 'binding'],
-    ].slice(0, bindingAvailable ? 4 : 1);
-
-    [
-      { cipher: null },
-      { cipher: 'chacha20-poly1305@openssh.com' },
-      { cipher: 'aes128-gcm@openssh.com' },
-      { cipher: 'aes128-cbc', mac: 'hmac-sha1-etm@openssh.com' },
-      { cipher: 'aes128-ctr', mac: 'hmac-sha1' },
-      { cipher: 'arcfour', mac: 'hmac-sha2-256-96' },
-    ].forEach((testConfig) => {
-      for (const pair of PAIRS) {
-        function onCipherData(data) {
-          ciphered = Buffer.concat([ciphered, data]);
-        }
-
-        function onDecipherPayload(payload) {
-          deciphered.push(payload);
-        }
-
-        function reset() {
-          ciphered = Buffer.alloc(0);
-          deciphered = [];
-        }
-
-        function reinit() {
-          if (testConfig.cipher === null) {
-            cipher = new NullCipher(1, onCipherData);
-            decipher = new NullDecipher(1, onDecipherPayload);
-          } else {
-            cipher = createCipher(config);
-            decipher = createDecipher(config);
-          }
-        }
-
-        let ciphered;
-        let deciphered;
-        let cipher;
-        let decipher;
-        let macSize;
-        let packet;
-        let payload;
-        let cipherInfo;
-        let config;
-
-        console.log('Testing cipher: %s, mac: %s (%s encrypt, %s decrypt) ...',
-                    testConfig.cipher,
-                    testConfig.mac
-                      || (testConfig.cipher === null ? '<none>' : '<implicit>'),
-                    pair[0],
-                    pair[1]);
-
-        if (testConfig.cipher === null) {
-          cipher = new NullCipher(1, onCipherData);
-          decipher = new NullDecipher(1, onDecipherPayload);
-          macSize = 0;
-        } else {
-          cipherInfo = CIPHER_INFO[testConfig.cipher];
-          let macInfo;
-          let macKey;
-          if (testConfig.mac) {
-            macInfo = MAC_INFO[testConfig.mac];
-            macKey = randomBytes(macInfo.len);
-            macSize = macInfo.actualLen;
-          } else if (cipherInfo.authLen) {
-            macSize = cipherInfo.authLen;
-          } else {
-            throw new Error('Missing MAC for cipher');
-          }
-          const key = randomBytes(cipherInfo.keyLen);
-          const iv = (cipherInfo.ivLen
-                      ? randomBytes(cipherInfo.ivLen)
-                      : Buffer.alloc(0));
-          config = {
-            outbound: {
-              onWrite: onCipherData,
-              cipherInfo,
-              cipherKey: Buffer.from(key),
-              cipherIV: Buffer.from(iv),
-              seqno: 1,
-              macInfo,
-              macKey: (macKey && Buffer.from(macKey)),
-              forceNative: (pair[0] === 'native'),
-            },
-            inbound: {
-              onPayload: onDecipherPayload,
-              decipherInfo: cipherInfo,
-              decipherKey: Buffer.from(key),
-              decipherIV: Buffer.from(iv),
-              seqno: 1,
-              macInfo,
-              macKey: (macKey && Buffer.from(macKey)),
-              forceNative: (pair[1] === 'native'),
-            },
-          };
-          try {
-            cipher = createCipher(config);
-          } catch (ex) {
-            if (ex.code === 'ERR_OSSL_EVP_UNSUPPORTED'
-                || /unsupported/i.test(ex.message)) {
-              console.log(
-                '  ... skipping because cipher is unsupported by OpenSSL'
-              );
-              continue;
-            }
-            throw ex;
-          }
-          try {
-            decipher = createDecipher(config);
-          } catch (ex) {
-            if (ex.code === 'ERR_OSSL_EVP_UNSUPPORTED'
-                || /unsupported/i.test(ex.message)) {
-              console.log(
-                '  ... skipping because cipher is unsupported by OpenSSL'
-              );
-              continue;
-            }
-            throw ex;
-          }
-
-          if (pair[0] === 'binding')
-            assert(/binding/i.test(cipher.constructor.name));
-          else
-            assert(/native/i.test(cipher.constructor.name));
-          if (pair[1] === 'binding')
-            assert(/binding/i.test(decipher.constructor.name));
-          else
-            assert(/native/i.test(decipher.constructor.name));
-        }
-
-        let expectedSeqno;
-        // Test zero-length payload ============================================
-        payload = Buffer.alloc(0);
-        expectedSeqno = 2;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(decipher.decrypt(ciphered, 0, ciphered.length),
-                           undefined);
-
-        assert.strictEqual(cipher.outSeqno, expectedSeqno);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test single byte payload ============================================
-        payload = Buffer.from([ 0xEF ]);
-        expectedSeqno = 3;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(decipher.decrypt(ciphered, 0, ciphered.length),
-                           undefined);
-
-        assert.strictEqual(cipher.outSeqno, 3);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test large payload ==================================================
-        payload = randomBytes(32 * 1024);
-        expectedSeqno = 4;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(decipher.decrypt(ciphered, 0, ciphered.length),
-                           undefined);
-
-        assert.strictEqual(cipher.outSeqno, expectedSeqno);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test sequnce number rollover ========================================
-        payload = randomBytes(4);
-        expectedSeqno = 0;
-        cipher.outSeqno = decipher.inSeqno = (2 ** 32) - 1;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(decipher.decrypt(ciphered, 0, ciphered.length),
-                           undefined);
-
-        assert.strictEqual(cipher.outSeqno, expectedSeqno);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test chunked input -- split length bytes ============================
-        payload = randomBytes(32 * 768);
-        expectedSeqno = 1;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(decipher.decrypt(ciphered, 0, 2), undefined);
-        assert.strictEqual(decipher.decrypt(ciphered, 2, ciphered.length),
-                           undefined);
-
-        assert.strictEqual(cipher.outSeqno, expectedSeqno);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test chunked input -- split length from payload =====================
-        payload = randomBytes(32 * 768);
-        expectedSeqno = 2;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(decipher.decrypt(ciphered, 0, 4), undefined);
-        assert.strictEqual(decipher.decrypt(ciphered, 4, ciphered.length),
-                           undefined);
-
-        assert.strictEqual(cipher.outSeqno, expectedSeqno);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test chunked input -- split length and payload from MAC =============
-        payload = randomBytes(32 * 768);
-        expectedSeqno = 3;
-
-        reset();
-        packet = cipher.allocPacket(payload.length);
-        payload.copy(packet, 5);
-        cipher.encrypt(packet);
-        assert.strictEqual(
-          decipher.decrypt(ciphered, 0, ciphered.length - macSize),
-          undefined
-        );
-        assert.strictEqual(
-          decipher.decrypt(ciphered,
-                           ciphered.length - macSize,
-                           ciphered.length),
-          undefined
-        );
-
-        assert.strictEqual(cipher.outSeqno, expectedSeqno);
-        assert(ciphered.length >= 9 + macSize);
-        assert.strictEqual(decipher.inSeqno, cipher.outSeqno);
-        assert.strictEqual(deciphered.length, 1);
-        assert.deepStrictEqual(deciphered[0], payload);
-
-        // Test packet length checks ===========================================
-        [0, 2 ** 32 - 1].forEach((n) => {
-          reset();
-          packet = cipher.allocPacket(0);
-          packet.writeUInt32BE(n, 0); // Overwrite packet length field
-          cipher.encrypt(packet);
-          let threw = false;
-          try {
-            decipher.decrypt(ciphered, 0, ciphered.length);
-          } catch (ex) {
-            threw = true;
-            assert(ex instanceof Error);
-            assert(/packet length/i.test(ex.message));
-          }
-          if (!threw)
-            throw new Error('Expected error');
-
-          // Recreate deciphers since errors leave them in an unusable state.
-          // We recreate the ciphers as well so that internal states of both
-          // ends match again.
-          reinit();
-        });
-
-        // Test minimum padding length check ===================================
-        if (testConfig.cipher !== null) {
-          let payloadLen;
-          const blockLen = cipherInfo.blockLen;
-          if (/chacha|gcm/i.test(testConfig.cipher)
-              || /etm/i.test(testConfig.mac)) {
-            payloadLen = blockLen - 2;
-          } else {
-            payloadLen = blockLen - 6;
-          }
-          const minLen = 4 + 1 + payloadLen + (blockLen + 1);
-          // We don't do strict equality checks here since the length of the
-          // returned Buffer can vary due to implementation details.
-          assert(cipher.allocPacket(payloadLen).length >= minLen);
-        }
-
-        // =====================================================================
-        cipher.free();
-        decipher.free();
-        if (testConfig.cipher === null)
-          break;
-      }
-    });
-  }
-
-  // Test createCipher()/createDecipher() exceptions
-  {
-    [
-      [
-        [true, null],
-        /invalid config/i
-      ],
-      [
-        [{}],
-        [/invalid outbound/i, /invalid inbound/i]
-      ],
-      [
-        [{ outbound: {}, inbound: {} }],
-        [/invalid outbound\.onWrite/i, /invalid inbound\.onPayload/i]
-      ],
-      [
-        [
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: true
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: true
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: null
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: null
-            },
-          },
-        ],
-        [/invalid outbound\.cipherInfo/i, /invalid inbound\.decipherInfo/i]
-      ],
-      [
-        [
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: {},
-              cipherKey: {},
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: {},
-              decipherKey: {},
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 32 },
-              cipherKey: Buffer.alloc(8),
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 32 },
-              decipherKey: Buffer.alloc(8),
-            },
-          },
-        ],
-        [/invalid outbound\.cipherKey/i, /invalid inbound\.decipherKey/i]
-      ],
-      [
-        [
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 12 },
-              cipherKey: Buffer.alloc(1),
-              cipherIV: true
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 12 },
-              decipherKey: Buffer.alloc(1),
-              cipherIV: true
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 12 },
-              cipherKey: Buffer.alloc(1),
-              cipherIV: null
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 12 },
-              decipherKey: Buffer.alloc(1),
-              cipherIV: null
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 12 },
-              cipherKey: Buffer.alloc(1),
-              cipherIV: {}
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 12 },
-              decipherKey: Buffer.alloc(1),
-              cipherIV: {}
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 12 },
-              cipherKey: Buffer.alloc(1),
-              cipherIV: Buffer.alloc(1)
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 12 },
-              decipherKey: Buffer.alloc(1),
-              cipherIV: Buffer.alloc(1)
-            },
-          },
-        ],
-        [/invalid outbound\.cipherIV/i, /invalid inbound\.decipherIV/i]
-      ],
-      [
-        [
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0 },
-              cipherKey: Buffer.alloc(1),
-              seqno: true
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0 },
-              decipherKey: Buffer.alloc(1),
-              seqno: true
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0 },
-              cipherKey: Buffer.alloc(1),
-              seqno: -1
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0 },
-              decipherKey: Buffer.alloc(1),
-              seqno: -1
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0 },
-              cipherKey: Buffer.alloc(1),
-              seqno: 2 ** 32
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0 },
-              decipherKey: Buffer.alloc(1),
-              seqno: 2 ** 32
-            },
-          },
-        ],
-        [/invalid outbound\.seqno/i, /invalid inbound\.seqno/i]
-      ],
-      [
-        [
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: true
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: true
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: null
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: null
-            },
-          },
-        ],
-        [/invalid outbound\.macInfo/i, /invalid inbound\.macInfo/i]
-      ],
-      [
-        [
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 }
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 }
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 },
-              macKey: true
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 },
-              macKey: true
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 },
-              macKey: null
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 },
-              macKey: null
-            },
-          },
-          { outbound: {
-              onWrite: () => {},
-              cipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              cipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 },
-              macKey: Buffer.alloc(1)
-            },
-            inbound: {
-              onPayload: () => {},
-              decipherInfo: { keyLen: 1, ivLen: 0, sslName: 'foo' },
-              decipherKey: Buffer.alloc(1),
-              seqno: 0,
-              macInfo: { keyLen: 16 },
-              macKey: Buffer.alloc(1)
-            },
-          },
-        ],
-        [/invalid outbound\.macKey/i, /invalid inbound\.macKey/i]
-      ],
-    ].forEach((testCase) => {
-      let errorChecks = testCase[1];
-      if (!Array.isArray(errorChecks))
-        errorChecks = [errorChecks[0], errorChecks[0]];
-      for (const input of testCase[0]) {
-        assert.throws(() => createCipher(input), errorChecks[0]);
-        assert.throws(() => createDecipher(input), errorChecks[1]);
-      }
-    });
-  }
-})();