conflict solved

Author: mertcanaltin

.github/workflows/build-windows.yml

@@ -0,0 +1,53 @@
+name: Build Windows
+
+on:
+  pull_request:
+    paths-ignore:
+      - README.md
+      - .github/**
+      - '!.github/workflows/build-windows.yml'
+    types: [opened, synchronize, reopened, ready_for_review]
+  push:
+    branches:
+      - main
+      - canary
+      - v[0-9]+.x-staging
+      - v[0-9]+.x
+    paths-ignore:
+      - README.md
+      - .github/**
+      - '!.github/workflows/build-windows.yml'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  PYTHON_VERSION: '3.11'
+  FLAKY_TESTS: keep_retrying
+
+permissions:
+  contents: read
+
+jobs:
+  build-windows:
+    if: github.event.pull_request.draft == false
+    strategy:
+      matrix:
+        windows: [windows-2019, windows-2022]
+      fail-fast: false
+    runs-on: ${{ matrix.windows }}
+    steps:
+      - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c  # v3.3.0
+        with:
+          persist-credentials: false
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@d27e3f3d7c64b4bbf8e4abfb9b63b83e846e0435  # v4.5.0
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Install deps
+        run: choco install nasm
+      - name: Environment Information
+        run: npx envinfo
+      - name: Build
+        run: ./vcbuild.bat

.github/workflows/test-asan.yml

@@ -0,0 +1,62 @@
+name: Test ASan
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+    paths-ignore:
+      - .mailmap
+      - '**.md'
+      - AUTHORS
+      - doc/**
+      - .github/**
+      - '!.github/workflows/test-asan.yml'
+  push:
+    branches:
+      - main
+      - canary
+      - v[0-9]+.x-staging
+      - v[0-9]+.x
+    paths-ignore:
+      - .mailmap
+      - '**.md'
+      - AUTHORS
+      - doc/**
+      - .github/**
+      - '!.github/workflows/test-asan.yml'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  ASAN_OPTIONS: intercept_tls_get_addr=0
+  PYTHON_VERSION: '3.11'
+  FLAKY_TESTS: keep_retrying
+
+permissions:
+  contents: read
+
+jobs:
+  test-asan:
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-20.04
+    env:
+      CC: clang
+      CXX: clang++
+      LINK: clang++
+      CONFIG_FLAGS: --enable-asan
+      ASAN: true
+    steps:
+      - uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c  # v3.3.0
+        with:
+          persist-credentials: false
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@d27e3f3d7c64b4bbf8e4abfb9b63b83e846e0435  # v4.5.0
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Environment Information
+        run: npx envinfo
+      - name: Build
+        run: make build-ci -j2 V=1
+      - name: Test
+        run: make run-ci -j2 V=1 TEST_CI_ARGS="-p actions -t 300 --measure-flakiness 9"

benchmark/buffers/buffer-hex.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  len: [64, 1024],
+  n: [1e6],
+});
+
+function main({ len, n }) {
+  const buf = Buffer.alloc(len);
+
+  for (let i = 0; i < buf.length; i++)
+    buf[i] = i & 0xff;
+
+  const hex = buf.toString('hex');
+
+  bench.start();
+
+  for (let i = 0; i < n; i += 1)
+    Buffer.from(hex, 'hex');
+
+  bench.end(n);
+}

benchmark/crypto/cipher-stream.js

@@ -0,0 +1,101 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  writes: [500],
+  cipher: ['AES192', 'AES256'],
+  type: ['asc', 'utf', 'buf'],
+  len: [2, 1024, 102400, 1024 * 1024],
+  api: ['legacy', 'stream'],
+}, {
+  flags: ['--no-warnings'],
+});
+
+function main({ api, cipher, type, len, writes }) {
+  if (api === 'stream' && /^v0\.[0-8]\./.test(process.version)) {
+    console.error('Crypto streams not available until v0.10');
+    // Use the legacy, just so that we can compare them.
+    api = 'legacy';
+  }
+
+  const crypto = require('crypto');
+  const assert = require('assert');
+  const alice = crypto.getDiffieHellman('modp5');
+  const bob = crypto.getDiffieHellman('modp5');
+
+  alice.generateKeys();
+  bob.generateKeys();
+
+  const pubEnc = /^v0\.[0-8]/.test(process.version) ? 'binary' : null;
+  const alice_secret = alice.computeSecret(bob.getPublicKey(), pubEnc, 'hex');
+  const bob_secret = bob.computeSecret(alice.getPublicKey(), pubEnc, 'hex');
+
+  // alice_secret and bob_secret should be the same
+  assert(alice_secret === bob_secret);
+
+  const alice_cipher = crypto.createCipher(cipher, alice_secret);
+  const bob_cipher = crypto.createDecipher(cipher, bob_secret);
+
+  let message;
+  let encoding;
+  switch (type) {
+    case 'asc':
+      message = 'a'.repeat(len);
+      encoding = 'ascii';
+      break;
+    case 'utf':
+      message = 'ü'.repeat(len / 2);
+      encoding = 'utf8';
+      break;
+    case 'buf':
+      message = Buffer.alloc(len, 'b');
+      break;
+    default:
+      throw new Error(`unknown message type: ${type}`);
+  }
+
+  const fn = api === 'stream' ? streamWrite : legacyWrite;
+
+  // Write data as fast as possible to alice, and have bob decrypt.
+  // use old API for comparison to v0.8
+  bench.start();
+  fn(alice_cipher, bob_cipher, message, encoding, writes);
+}
+
+function streamWrite(alice, bob, message, encoding, writes) {
+  let written = 0;
+  bob.on('data', (c) => {
+    written += c.length;
+  });
+
+  bob.on('end', () => {
+    // Gbits
+    const bits = written * 8;
+    const gbits = bits / (1024 * 1024 * 1024);
+    bench.end(gbits);
+  });
+
+  alice.pipe(bob);
+
+  while (writes-- > 0)
+    alice.write(message, encoding);
+
+  alice.end();
+}
+
+function legacyWrite(alice, bob, message, encoding, writes) {
+  let written = 0;
+  let enc, dec;
+  for (let i = 0; i < writes; i++) {
+    enc = alice.update(message, encoding);
+    dec = bob.update(enc);
+    written += dec.length;
+  }
+  enc = alice.final();
+  dec = bob.update(enc);
+  written += dec.length;
+  dec = bob.final();
+  written += dec.length;
+  const gbits = written / (1024 * 1024 * 1024);
+  bench.end(gbits);
+}

benchmark/crypto/oneshot-sign-verify.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const common = require('../common.js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const fixtures_keydir = path.resolve(__dirname, '../../test/fixtures/keys/');
+const keyFixtures = {
+  publicKey: fs.readFileSync(`${fixtures_keydir}/ec_p256_public.pem`)
+    .toString(),
+  privateKey: fs.readFileSync(`${fixtures_keydir}/ec_p256_private.pem`)
+    .toString(),
+};
+
+const data = crypto.randomBytes(256);
+
+let pems;
+let keyObjects;
+
+function getKeyObject({ privateKey, publicKey }) {
+  return {
+    privateKey: crypto.createPrivateKey(privateKey),
+    publicKey: crypto.createPublicKey(publicKey),
+  };
+}
+
+const bench = common.createBenchmark(main, {
+  mode: ['sync', 'async-serial', 'async-parallel'],
+  keyFormat: ['pem', 'keyObject', 'pem.unique', 'keyObject.unique'],
+  n: [1e3],
+});
+
+function measureSync(n, privateKey, publicKey, keys) {
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    crypto.verify(
+      'sha256',
+      data,
+      { key: publicKey || keys[i].publicKey, dsaEncoding: 'ieee-p1363' },
+      crypto.sign(
+        'sha256',
+        data,
+        { key: privateKey || keys[i].privateKey, dsaEncoding: 'ieee-p1363' }));
+  }
+  bench.end(n);
+}
+
+function measureAsyncSerial(n, privateKey, publicKey, keys) {
+  let remaining = n;
+  function done() {
+    if (--remaining === 0)
+      bench.end(n);
+    else
+      one();
+  }
+
+  function one() {
+    crypto.sign(
+      'sha256',
+      data,
+      {
+        key: privateKey || keys[n - remaining].privateKey,
+        dsaEncoding: 'ieee-p1363',
+      },
+      (err, signature) => {
+        crypto.verify(
+          'sha256',
+          data,
+          {
+            key: publicKey || keys[n - remaining].publicKey,
+            dsaEncoding: 'ieee-p1363',
+          },
+          signature,
+          done);
+      });
+  }
+  bench.start();
+  one();
+}
+
+function measureAsyncParallel(n, privateKey, publicKey, keys) {
+  let remaining = n;
+  function done() {
+    if (--remaining === 0)
+      bench.end(n);
+  }
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    crypto.sign(
+      'sha256',
+      data,
+      { key: privateKey || keys[i].privateKey, dsaEncoding: 'ieee-p1363' },
+      (err, signature) => {
+        crypto.verify(
+          'sha256',
+          data,
+          { key: publicKey || keys[i].publicKey, dsaEncoding: 'ieee-p1363' },
+          signature,
+          done);
+      });
+  }
+}
+
+function main({ n, mode, keyFormat }) {
+  pems ||= [...Buffer.alloc(n)].map(() => ({
+    privateKey: keyFixtures.privateKey,
+    publicKey: keyFixtures.publicKey,
+  }));
+  keyObjects ||= pems.map(getKeyObject);
+
+  let privateKey, publicKey, keys;
+
+  switch (keyFormat) {
+    case 'keyObject':
+      ({ publicKey, privateKey } = keyObjects[0]);
+      break;
+    case 'pem':
+      ({ publicKey, privateKey } = pems[0]);
+      break;
+    case 'pem.unique':
+      keys = pems;
+      break;
+    case 'keyObject.unique':
+      keys = keyObjects;
+      break;
+    default:
+      throw new Error('not implemented');
+  }
+
+  switch (mode) {
+    case 'sync':
+      measureSync(n, privateKey, publicKey, keys);
+      break;
+    case 'async-serial':
+      measureAsyncSerial(n, privateKey, publicKey, keys);
+      break;
+    case 'async-parallel':
+      measureAsyncParallel(n, privateKey, publicKey, keys);
+      break;
+  }
+}