@gjsify/crypto 0.1.0

package/src/constants.ts

@@ -0,0 +1,16 @@
+// Reference: Node.js lib/internal/crypto/util.js — crypto constants
+// Subset of Node.js crypto constants relevant to the GJS implementation
+
+export const constants = {
+  // RSA padding modes (stubs for compatibility)
+  RSA_PKCS1_PADDING: 1,
+  RSA_NO_PADDING: 3,
+  RSA_PKCS1_OAEP_PADDING: 4,
+  RSA_PKCS1_PSS_PADDING: 6,
+
+  // DiffieHellman error codes
+  DH_CHECK_P_NOT_SAFE_PRIME: 2,
+  DH_CHECK_P_NOT_PRIME: 1,
+  DH_UNABLE_TO_CHECK_GENERATOR: 4,
+  DH_NOT_SUITABLE_GENERATOR: 8,
+} as const;

package/src/crypto-utils.ts

@@ -0,0 +1,64 @@
+// Crypto utilities for GJS — original implementation
+// Centralizes algorithm normalization, digest/block sizes, and common helpers
+// used across hash, hmac, pbkdf2, hkdf, mgf1, rsa-pss, rsa-oaep, ecdsa, and sign modules.
+
+import { Buffer } from 'node:buffer';
+
+/**
+ * Normalize a hash algorithm name to lowercase without hyphens.
+ * e.g. "SHA-256" → "sha256", "MD5" → "md5"
+ */
+export function normalizeAlgorithm(algorithm: string): string {
+  return algorithm.toLowerCase().replace(/-/g, '');
+}
+
+/** Hash digest output sizes in bytes. */
+export const DIGEST_SIZES: Record<string, number> = {
+  md5: 16,
+  sha1: 20,
+  sha256: 32,
+  sha384: 48,
+  sha512: 64,
+};
+
+/** Hash block sizes in bytes (used for HMAC key padding). */
+export const BLOCK_SIZES: Record<string, number> = {
+  md5: 64,
+  sha1: 64,
+  sha256: 64,
+  sha384: 128,
+  sha512: 128,
+};
+
+/** Set of supported hash algorithm names (normalized). */
+export const SUPPORTED_ALGORITHMS = new Set(['md5', 'sha1', 'sha256', 'sha384', 'sha512']);
+
+/**
+ * Get hash digest size in bytes for a given algorithm.
+ * Accepts unnormalized names (e.g. "SHA-256").
+ */
+export function hashSize(algo: string): number {
+  const normalized = normalizeAlgorithm(algo);
+  const size = DIGEST_SIZES[normalized];
+  if (size === undefined) {
+    throw new Error(`Unknown hash algorithm: ${algo}`);
+  }
+  return size;
+}
+
+/**
+ * Convert various input types to Buffer.
+ * Handles string, Buffer, Uint8Array, DataView, and ArrayBuffer.
+ */
+export function toBuffer(input: string | Buffer | Uint8Array | DataView | ArrayBuffer, encoding?: string): Buffer {
+  if (typeof input === 'string') {
+    return Buffer.from(input, (encoding as BufferEncoding) || 'utf8');
+  }
+  if (input instanceof DataView) {
+    return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  }
+  if (input instanceof ArrayBuffer) {
+    return Buffer.from(input);
+  }
+  return Buffer.from(input);
+}

package/src/dh.spec.ts

@@ -0,0 +1,111 @@
+// Ported from refs/node-test/parallel/test-crypto-dh.js
+// Original: MIT license, Copyright (c) Node.js contributors
+
+import { describe, it, expect } from '@gjsify/unit';
+import { createDiffieHellman, getDiffieHellman } from 'node:crypto';
+import { Buffer } from 'node:buffer';
+
+export default async () => {
+
+  await describe('crypto.createDiffieHellman', async () => {
+    await it('should be a function', async () => {
+      expect(typeof createDiffieHellman).toBe('function');
+    });
+
+    await it('should create DH with prime buffer', async () => {
+      // Use a predefined group prime instead of generating (Node.js rejects small primes)
+      const dh = getDiffieHellman('modp14');
+      expect(dh).toBeDefined();
+      expect(typeof dh.generateKeys).toBe('function');
+    });
+
+    await it('should generate keys', async () => {
+      const dh = getDiffieHellman('modp14');
+      const keys = dh.generateKeys();
+      expect(keys).toBeDefined();
+      expect(Buffer.isBuffer(keys)).toBe(true);
+      expect(keys.length).toBeGreaterThan(0);
+    });
+
+    await it('should get prime and generator', async () => {
+      const dh = getDiffieHellman('modp14');
+      dh.generateKeys();
+      const prime = dh.getPrime();
+      const generator = dh.getGenerator();
+      expect(Buffer.isBuffer(prime)).toBe(true);
+      expect(Buffer.isBuffer(generator)).toBe(true);
+      expect(prime.length).toBeGreaterThan(0);
+      expect(generator.length).toBeGreaterThan(0);
+    });
+
+    await it('should compute shared secret', async () => {
+      const alice = createDiffieHellman(512);
+      alice.generateKeys();
+
+      const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
+      bob.generateKeys();
+
+      const aliceSecret = alice.computeSecret(bob.getPublicKey());
+      const bobSecret = bob.computeSecret(alice.getPublicKey());
+
+      expect(aliceSecret.toString('hex')).toBe(bobSecret.toString('hex'));
+    });
+
+    await it('should support hex encoding for keys', async () => {
+      const dh = getDiffieHellman('modp5');
+      dh.generateKeys();
+
+      const pubHex = dh.getPublicKey('hex');
+      const privHex = dh.getPrivateKey('hex');
+      expect(typeof pubHex).toBe('string');
+      expect(typeof privHex).toBe('string');
+      expect(pubHex.length).toBeGreaterThan(0);
+      expect(privHex.length).toBeGreaterThan(0);
+    });
+
+    await it('should create DH from prime buffer', async () => {
+      const source = getDiffieHellman('modp5');
+      const primeBuf = source.getPrime();
+
+      const dh = createDiffieHellman(primeBuf);
+      dh.generateKeys();
+      expect(dh.getPrime('hex')).toBe(primeBuf.toString('hex'));
+    });
+  });
+
+  await describe('crypto.getDiffieHellman', async () => {
+    await it('should be a function', async () => {
+      expect(typeof getDiffieHellman).toBe('function');
+    });
+
+    await it('should return a DH object for modp14', async () => {
+      const dh = getDiffieHellman('modp14');
+      expect(dh).toBeDefined();
+      expect(typeof dh.generateKeys).toBe('function');
+    });
+
+    await it('should compute shared secret with predefined group', async () => {
+      const alice = getDiffieHellman('modp14');
+      alice.generateKeys();
+
+      const bob = getDiffieHellman('modp14');
+      bob.generateKeys();
+
+      const aliceSecret = alice.computeSecret(bob.getPublicKey());
+      const bobSecret = bob.computeSecret(alice.getPublicKey());
+
+      expect(aliceSecret.toString('hex')).toBe(bobSecret.toString('hex'));
+    });
+
+    await it('should support modp5', async () => {
+      const dh = getDiffieHellman('modp5');
+      dh.generateKeys();
+      const pub = dh.getPublicKey();
+      expect(pub.length).toBeGreaterThan(0);
+    });
+
+    await it('should throw for unknown group', async () => {
+      expect(() => getDiffieHellman('modp999')).toThrow();
+    });
+  });
+};