// @ts-nocheck /** * Hash Generator * * Generate MD5, SHA-1, SHA-256, SHA-512 hashes from text input. * Uses Web Crypto API for secure hash generation. * * Demonstrates: * - Multiple output fields * - Real-time generation * - outputControl for dynamic badges */ const app = { /** * Main execution logic */ async execute(ctx) { const { textInput, encoding, uppercase } = ctx.values; // Handle empty input if (!textInput) { return { success: true, data: { md5: '', sha1: '', sha256: '', sha512: '', inputStats: 'No input', hashLength: '-', securityLevel: '-', }, }; } // Generate all hashes const [md5, sha1, sha256, sha512] = await Promise.all([ generateHash(textInput, 'MD5', encoding, uppercase), generateHash(textInput, 'SHA-1', encoding, uppercase), generateHash(textInput, 'SHA-256', encoding, uppercase), generateHash(textInput, 'SHA-512', encoding, uppercase), ]); // Calculate input stats const byteLength = new TextEncoder().encode(textInput).length; const inputStats = `${textInput.length} chars, ${byteLength} bytes`; // Hash lengths in bits const hashLengths = { 'MD5': 128, 'SHA-1': 160, 'SHA-256': 256, 'SHA-512': 512, }; return { success: true, data: { md5, sha1, sha256, sha512, inputStats, hashLength: '128 / 160 / 256 / 512 bits', securityLevel: 'SHA-256+ recommended', }, outputControl: { inputStats: { variant: 'info' }, hashLength: { variant: 'default' }, securityLevel: { variant: 'success' }, }, }; }, /** * Provide contextual feedback */ interpret(ctx) { const { textInput } = ctx.values; const { sha256 } = ctx.results; if (!textInput) { return { variant: 'info', message: 'Enter text to generate cryptographic hashes.', }; } const byteLength = new TextEncoder().encode(textInput).length; return { variant: 'success', message: `Generated 4 hash variants for ${byteLength} bytes of input.`, insights: [ 'MD5 and SHA-1 are considered weak - use SHA-256+ for security', 'SHA-256 is recommended for most applications', 'SHA-512 provides maximum security but longer output', 'Hashes are one-way - cannot be reversed to original text', ], }; }, }; /** * Generate hash using Web Crypto API (with MD5 fallback) */ async function generateHash(text, algorithm, encoding, uppercase) { const encoder = new TextEncoder(); const data = encoder.encode(text); let hashBuffer; if (algorithm === 'MD5') { // MD5 not supported by Web Crypto, use custom implementation hashBuffer = md5(data); } else { // Use Web Crypto API for SHA algorithms hashBuffer = await crypto.subtle.digest(algorithm, data); } // Convert to desired encoding let result; if (encoding === 'base64') { result = arrayBufferToBase64(hashBuffer); } else { result = arrayBufferToHex(hashBuffer); if (uppercase) { result = result.toUpperCase(); } } return result; } /** * Convert ArrayBuffer to hex string */ function arrayBufferToHex(buffer) { const bytes = new Uint8Array(buffer); return Array.from(bytes) .map(b => b.toString(16).padStart(2, '0')) .join(''); } /** * Convert ArrayBuffer to base64 string */ function arrayBufferToBase64(buffer) { const bytes = new Uint8Array(buffer); let binary = ''; for (let i = 0; i < bytes.length; i++) { binary += String.fromCharCode(bytes[i]); } return btoa(binary); } /** * MD5 implementation (Web Crypto doesn't support MD5) * Based on RFC 1321 */ function md5(data) { // Convert Uint8Array to array of bytes const bytes = Array.from(data); // MD5 helper functions function rotateLeft(x, n) { return ((x << n) | (x >>> (32 - n))) >>> 0; } function F(x, y, z) { return ((x & y) | (~x & z)) >>> 0; } function G(x, y, z) { return ((x & z) | (y & ~z)) >>> 0; } function H(x, y, z) { return (x ^ y ^ z) >>> 0; } function I(x, y, z) { return (y ^ (x | ~z)) >>> 0; } // Pre-processing: adding padding bits const originalLength = bytes.length; bytes.push(0x80); while ((bytes.length % 64) !== 56) { bytes.push(0); } // Append original length in bits as 64-bit little-endian const bitLength = originalLength * 8; for (let i = 0; i < 8; i++) { bytes.push((bitLength >>> (i * 8)) & 0xff); } // Initialize hash values let a0 = 0x67452301; let b0 = 0xefcdab89; let c0 = 0x98badcfe; let d0 = 0x10325476; // Pre-computed constants const K = []; for (let i = 0; i < 64; i++) { K[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 0x100000000) >>> 0; } const S = [ 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 ]; // Process each 64-byte chunk for (let chunkStart = 0; chunkStart < bytes.length; chunkStart += 64) { const M = []; for (let j = 0; j < 16; j++) { const idx = chunkStart + (j * 4); M[j] = (bytes[idx] | 0) | ((bytes[idx + 1] | 0) << 8) | ((bytes[idx + 2] | 0) << 16) | ((bytes[idx + 3] | 0) << 24); M[j] = M[j] >>> 0; } let A = a0, B = b0, C = c0, D = d0; for (let i = 0; i < 64; i++) { let f, g; if (i < 16) { f = F(B, C, D); g = i; } else if (i < 32) { f = G(B, C, D); g = (5 * i + 1) % 16; } else if (i < 48) { f = H(B, C, D); g = (3 * i + 5) % 16; } else { f = I(B, C, D); g = (7 * i) % 16; } const temp = D; D = C; C = B; B = (B + rotateLeft((A + f + K[i] + M[g]) >>> 0, S[i])) >>> 0; A = temp; } a0 = (a0 + A) >>> 0; b0 = (b0 + B) >>> 0; c0 = (c0 + C) >>> 0; d0 = (d0 + D) >>> 0; } // Produce the final hash value (little-endian) const result = new Uint8Array(16); for (let i = 0; i < 4; i++) { result[i] = (a0 >>> (i * 8)) & 0xff; result[i + 4] = (b0 >>> (i * 8)) & 0xff; result[i + 8] = (c0 >>> (i * 8)) & 0xff; result[i + 12] = (d0 >>> (i * 8)) & 0xff; } return result.buffer; }