@gjsify/crypto 0.3.21 → 0.4.3

package/src/constants.ts

@@ -1,16 +0,0 @@
-// 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

@@ -1,64 +0,0 @@
-// 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

@@ -1,111 +0,0 @@
-// 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();
-    });
-  });
-};