tiny-essentials 1.1.1 → 1.2.0

package/dist/v1/libs/TinyCrypto.cjs

@@ -2,9 +2,18 @@
 
 var crypto = require('crypto');
 var fs = require('fs');
+var buffer = require('buffer');
 var objFilter = require('../basics/objFilter.cjs');
 
-// Detecta se estamos no browser
+/**
+ * Determines if the environment is a browser.
+ *
+ * This constant checks if the code is running in a browser environment by verifying if
+ * the `window` object and the `window.document` object are available. It will return `true`
+ * if the environment is a browser, and `false` otherwise (e.g., in a Node.js environment).
+ *
+ * @constant {boolean}
+ */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 
 /**
@@ -99,7 +108,7 @@ class TinyCrypto {
     });
 
     let encrypted = cipher.update(plainText, this.inputEncoding);
-    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    encrypted = buffer.Buffer.concat([encrypted, cipher.final()]);
     const authTag = cipher.getAuthTag();
 
     return {
@@ -134,9 +143,9 @@ class TinyCrypto {
    * console.log(decrypted); // Outputs: 'Hello, world!'
    */
   decrypt({ iv, encrypted, authTag }, expectedType = null) {
-    const ivBuffer = Buffer.from(iv, this.outputEncoding);
-    const encryptedBuffer = Buffer.from(encrypted, this.outputEncoding);
-    const authTagBuffer = Buffer.from(authTag, this.outputEncoding);
+    const ivBuffer = buffer.Buffer.from(iv, this.outputEncoding);
+    const encryptedBuffer = buffer.Buffer.from(encrypted, this.outputEncoding);
+    const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
     const decipher = crypto.createDecipheriv(this.algorithm, this.key, ivBuffer, {
       authTagLength: this.authTagLength,
@@ -174,9 +183,9 @@ class TinyCrypto {
    * console.log(dataType); // Outputs: 'string'
    */
   getTypeFromEncrypted({ iv, encrypted, authTag }) {
-    const ivBuffer = Buffer.from(iv, this.outputEncoding);
-    const encryptedBuffer = Buffer.from(encrypted, this.outputEncoding);
-    const authTagBuffer = Buffer.from(authTag, this.outputEncoding);
+    const ivBuffer = buffer.Buffer.from(iv, this.outputEncoding);
+    const encryptedBuffer = buffer.Buffer.from(encrypted, this.outputEncoding);
+    const authTagBuffer = buffer.Buffer.from(authTag, this.outputEncoding);
 
     const decipher = crypto.createDecipheriv(this.algorithm, this.key, ivBuffer, {
       authTagLength: this.authTagLength,
@@ -322,7 +331,7 @@ class TinyCrypto {
         const reader = new FileReader();
         reader.onload = () => {
           const hexKey = reader.result.trim();
-          const keyBuffer = Buffer.from(hexKey, 'hex');
+          const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
           this.key = keyBuffer;
           resolve(keyBuffer);
         };
@@ -331,7 +340,7 @@ class TinyCrypto {
       });
     } else {
       const hexKey = fs.readFileSync(file, 'utf8');
-      const keyBuffer = Buffer.from(hexKey, 'hex');
+      const keyBuffer = buffer.Buffer.from(hexKey, 'hex');
       this.key = keyBuffer;
       return keyBuffer;
     }
@@ -409,7 +418,7 @@ class TinyCrypto {
     else if (typeof config.authTagLength !== 'undefined')
       throw new Error('Invalid or missing "authTagLength" property. Expected a number.');
 
-    if (typeof config.key === 'string') this.key = Buffer.from(config.key, 'hex');
+    if (typeof config.key === 'string') this.key = buffer.Buffer.from(config.key, 'hex');
     else if (typeof config.key !== 'undefined')
       throw new Error('Invalid or missing "key" property. Expected a hexadecimal string.');
   }
@@ -532,7 +541,7 @@ class TinyCrypto {
     array: (value) => value,
     object: (value) => value,
     string: (value) => String(value),
-    buffer: (value) => Buffer.from(value, 'base64'),
+    buffer: (value) => buffer.Buffer.from(value, 'base64'),
   };
 
   /**

package/dist/v1/libs/TinyCrypto.d.mts

@@ -265,3 +265,4 @@ declare class TinyCrypto {
     }): void;
     #private;
 }
+import { Buffer } from 'buffer';

package/dist/v1/libs/TinyCrypto.mjs

@@ -1,7 +1,16 @@
 import crypto from 'crypto';
 import fs from 'fs';
+import { Buffer } from 'buffer';
 import { objType } from '../../v1/basics/objFilter.mjs';
-// Detecta se estamos no browser
+/**
+ * Determines if the environment is a browser.
+ *
+ * This constant checks if the code is running in a browser environment by verifying if
+ * the `window` object and the `window.document` object are available. It will return `true`
+ * if the environment is a browser, and `false` otherwise (e.g., in a Node.js environment).
+ *
+ * @constant {boolean}
+ */
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 /**
  * TinyCrypto is a utility class that provides methods for secure key generation,

package/docs/README.md

@@ -14,6 +14,8 @@ This folder contains external libraries and utility modules that are designed to
 
 - 🔐 **[TinyCrypto.md](./libs/TinyCrypto.md)** — A flexible and browser-compatible AES-256-GCM encryption utility with support for complex JavaScript types like `Date`, `RegExp`, `Buffer`, and even DOM elements (in the browser).
 
+- 📄 **[TinyCertCrypto.md](./libs/TinyCertCrypto.md)** — A lightweight tool for managing RSA key pairs and X.509 certificates with support for generation, PEM parsing, encryption/decryption of JSON, and certificate metadata extraction. Works in both Node.js and browser environments (with limitations in browser).
+
 ---
 
 ### 2. **`basics/`** 

package/docs/libs/TinyCertCrypto.md

@@ -0,0 +1,202 @@
+# ✨ Tiny Cert Crypto
+
+A lightweight 🔐 utility for managing, generating, and handling **X.509 certificates** and **RSA key pairs**.  
+Built with flexibility in mind — runs seamlessly in both **Node.js** and **browser** environments! 🌍
+
+---
+
+## 📦 Features
+
+- 🛠️ RSA key pair generation (**Node.js only**)
+- 🧾 Self-signed X.509 certificate creation
+- 🧬 Support for PEM-based 🔑 public/private keys and certificates
+- 🧊 JSON encryption & decryption using Base64 encoding
+- 🕵️ Metadata extraction from certificates (issuer, subject, validity, etc.)
+- 📁 Flexible key loading: from memory, local files (Node.js), or URLs (browser)
+
+---
+
+## 🚀 Getting Started
+
+### 📚 Constructor
+
+```js
+const instance = new TinyCertCrypto({
+  publicCertPath: 'cert.pem',          // Path to public cert (Node.js)
+  privateKeyPath: 'key.pem',           // Path to private key (Node.js)
+  publicCertBuffer: null,              // String or Buffer in memory (Node.js/browser)
+  privateKeyBuffer: null,              // String or Buffer in memory (Node.js/browser)
+  cryptoType: 'RSA-OAEP',              // Encryption algorithm (default: 'RSA-OAEP')
+});
+```
+
+> 🔍 In **browser environments**, at least `publicCertPath` or `publicCertBuffer` must be provided.
+
+---
+
+## 🧪 Core Methods
+
+### 🔧 `async init()`
+Initializes the certificate and key system from files, memory buffers, or URLs.
+
+- Loads the public certificate/key.
+- Optionally loads the private key.
+- Detects whether you’re running in Node.js or the browser and adjusts behavior accordingly.
+
+---
+
+### 📑 `extractCertMetadata()`
+Returns parsed metadata from the loaded certificate.
+
+```js
+{
+  subject: { names: {}, shortNames: {}, raw: "CN=example.com,O=MyOrg" },
+  issuer: { names: {}, shortNames: {}, raw: "CN=example.com,O=MyOrg" },
+  serialNumber: '...',
+  validFrom: Date,
+  validTo: Date
+}
+```
+
+---
+
+### 🛡️ `encryptJson(jsonObject)`
+Encrypts a JavaScript object using the loaded **public key**, returning a **Base64-encoded string**.
+
+```js
+const encrypted = instance.encryptJson({ hello: "world" });
+```
+
+---
+
+### 🔓 `decryptToJson(base64String)`
+Decrypts a Base64 string using the **private key**, returning the original JSON object.
+
+```js
+const json = instance.decryptToJson(encrypted);
+```
+
+---
+
+### 🔍 `hasKeys()`
+Returns `true` if both `publicKey` and `privateKey` are loaded.
+
+---
+
+### 📜 `hasCert()`
+Returns `true` if a certificate (`publicCert`) is loaded.
+
+---
+
+### ♻️ `reset()`
+Resets the internal state, clearing:
+- `publicKey`
+- `privateKey`
+- `publicCert`
+- `metadata`
+- `source`
+
+---
+
+### 📦 `fetchNodeForge()` & `getNodeForge()`
+Handles lazy-loading and reuse of the `node-forge` module.
+
+Use if you want to access Forge directly without importing it yourself:
+
+```js
+const forge = await instance.fetchNodeForge();
+```
+
+---
+
+## 🧠 Internals & Design
+
+- 🔍 Uses regular expressions to detect PEM types (`CERTIFICATE`, `PUBLIC KEY`, `PRIVATE KEY`)
+- 🧪 Automatically parses PEM buffers and files depending on the runtime
+- 🔐 Encrypts data with the selected algorithm (`RSA-OAEP`, etc.)
+- 🧬 X.509 certificate metadata extraction is done via `node-forge`
+
+---
+
+## 🧰 Requirements
+
+| Environment | Requirement        |
+|-------------|--------------------|
+| Node.js     | `node-forge` |
+| Browser     | Works with native `fetch()` and `TextDecoder` |
+
+---
+
+## 😺 Example Use Case
+
+```js
+const crypto = new TinyCertCrypto({ publicCertPath: 'cert.pem', privateKeyPath: 'key.pem' });
+await crypto.init();
+
+const data = { secret: 'I love ponies' };
+const encrypted = crypto.encryptJson(data);
+const decrypted = crypto.decryptToJson(encrypted);
+
+console.log(decrypted); // { secret: 'I love ponies' }
+```
+
+---
+
+### 🧾 `async generateX509Cert(subjectFields, options = {})`
+Generates a new **RSA key pair** and a **self-signed X.509 certificate** using the provided subject information.
+
+🔐 This is ideal for internal services, development environments, or cryptographic testing tools where a trusted CA is not required.
+
+---
+
+**🧬 Parameters:**
+
+- `subjectFields` (`Object`) – Describes the identity fields that will be embedded into the certificate's subject and issuer:
+  - Common fields include:
+    - `CN`: Common Name (e.g. domain or hostname)
+    - `O`: Organization Name
+    - `OU`: Organizational Unit
+    - `L`: Locality (City)
+    - `ST`: State or Province
+    - `C`: Country (2-letter code)
+    - `emailAddress`: Optional email field
+
+- `options` (`Object`) – Optional configuration:
+  - `keySize` (`number`) – RSA key size in bits (default: `2048`)
+  - `validityInYears` (`number`) – Certificate validity period (default: `1`)
+  - `randomBytesLength` (`number`) – Length of the serial number (default: `16`)
+  - `digestAlgorithm` (`string`) – Digest algorithm used to sign the certificate (default: `'sha256'`)
+  - `forgeInstance` (`object`) – Optionally inject a specific instance of `node-forge`
+  - `cryptoType` (`string`) – Encryption scheme used for later operations (e.g., `'RSA-OAEP'`, `'RSAES-PKCS1-V1_5'`)
+
+---
+
+**✅ Returns:**
+
+An object containing all the generated artifacts:
+
+```js
+{
+  publicKey: '-----BEGIN PUBLIC KEY-----...',
+  privateKey: '-----BEGIN PRIVATE KEY-----...',
+  cert: '-----BEGIN CERTIFICATE-----...'
+}
+```
+
+- `publicKey`: The newly generated **PEM-encoded RSA public key**
+- `privateKey`: The corresponding **PEM-encoded RSA private key**
+- `cert`: A **PEM-encoded X.509 certificate** that is **self-signed** with the private key and matches the provided subject
+
+---
+
+**📌 Notes:**
+
+- 🔄 The `subject` and `issuer` of the certificate are the same (self-signed).
+- ⏳ The certificate `validFrom` is set to the current date, and `validTo` is based on the `validityInYears` option.
+- 🔢 A secure random `serialNumber` is generated using `crypto.randomBytes`.
+
+---
+
+**⚠️ Availability:**
+
+> This method is only available in **Node.js environments** due to its dependency on the native `crypto` module and synchronous file access via `fs`.

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "tiny-essentials",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Collection of small, essential scripts designed to be used across various projects. These simple utilities are crafted for speed, ease of use, and versatility.",
   "scripts": {
     "test": "npm run test:mjs && npm run test:cjs && npm run test:js",
     "test:js": "npx babel-node test/index.js",
     "test:mjs": "node test/index.mjs",
     "test:cjs": "node test/index.cjs",
-    "fix:prettier": "prettier --write ./src/* && prettier --write ./test/*",
+    "fix:prettier": "npm run fix:prettier:src && npm run fix:prettier:test && npm run fix:prettier:rollup.config && npm run fix:prettier:webpack.config",
+    "fix:prettier:src": "prettier --write ./src/*",
+    "fix:prettier:test": "prettier --write ./test/*",
+    "fix:prettier:rollup.config": "prettier --write ./rollup.config.mjs",
+    "fix:prettier:webpack.config": "prettier --write ./webpack.config.mjs",
     "auto-build": "npm run build",
-    "build": "tsc -p tsconfig.json && rollup -c",
+    "build": "tsc -p tsconfig.json && rollup -c && webpack --mode production",
     "build-clean": "npm run clean && npm run build",
     "build-dist": "npm run build",
     "build-browserify": "npx browserify build/browserify.js -p esmify > dist/TinyAiApi.web.js",
@@ -58,7 +62,6 @@
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.2",
     "babel-preset-es2015": "^6.24.1",
     "byte-length": "^1.0.2",
@@ -72,15 +75,17 @@
     "moment-timezone": "^0.5.48",
     "mysql": "^2.18.1",
     "node-fetch": "2.7.0",
+    "node-forge": "^1.3.1",
+    "node-polyfill-webpack-plugin": "^4.1.0",
     "object-hash": "^3.0.0",
     "prettier": "3.5.3",
     "rollup": "^4.40.0",
-    "rollup-plugin-polyfill-node": "^0.13.0",
     "rollup-preserve-directives": "^1.1.3",
     "tinycolor2": "^1.6.0",
     "tslib": "^2.8.1",
     "type-fest": "^4.40.0",
     "typescript": "^5.8.3",
-    "util": "^0.12.5"
+    "webpack": "^5.99.6",
+    "webpack-cli": "^6.0.1"
   }
 }

package/webpack.config.mjs

@@ -0,0 +1,69 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import webpack from 'webpack';
+import NodePolyfillPlugin from 'node-polyfill-webpack-plugin';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Add modules
+const modules = [];
+const addModule = (entry, library, isClass = false) => {
+  const baseConfig = {
+    entry,
+    output: {
+      path: path.resolve(__dirname, 'dist'),
+      library,
+      libraryTarget: 'window',
+      libraryExport: isClass ? library : undefined,
+    },
+    optimization: {
+      runtimeChunk: false,
+      splitChunks: false,
+    },
+    plugins: [
+      new NodePolyfillPlugin(),
+      new webpack.ProvidePlugin({
+        process: 'process/browser',
+      }),
+    ],
+  };
+  modules.push(
+    // Non-minified version
+    {
+      ...baseConfig,
+      mode: 'development',
+      output: {
+        ...baseConfig.output,
+        filename: `${library}.js`,
+      },
+      optimization: {
+        ...baseConfig.optimization,
+        minimize: false,
+      },
+    },
+    // Minified version
+    {
+      ...baseConfig,
+      mode: 'production',
+      output: {
+        ...baseConfig.output,
+        filename: `${library}.min.js`,
+      },
+      optimization: {
+        ...baseConfig.optimization,
+        minimize: true,
+      },
+    },
+  );
+};
+
+// Main
+addModule('./src/v1/index.mjs', 'TinyEssentials');
+addModule('./src/v1/basics/index.mjs', 'TinyBasicsEs');
+
+addModule('./src/v1/build/TinyLevelUp.mjs', 'TinyLevelUp', true);
+addModule('./src/v1/build/TinyCertCrypto.mjs', 'TinyCertCrypto', true);
+addModule('./src/v1/build/TinyCrypto.mjs', 'TinyCrypto', true);
+
+export default modules;