Hash Generator: Cryptographic Hashing at Scale

Best Practices:

• • Generate keys with cryptographically secure random generator (minimum 256 bits)
• • Never hardcode keys in source code - use environment variables or secret managers
• • Rotate keys periodically (every 90-180 days for high-security applications)
• • Use different keys for different purposes (authentication, webhooks, etc.)
• • Store keys encrypted at rest and in transit

Example:

// Generate secure key
const crypto = require(''crypto'');
const secretKey = crypto.randomBytes(32).toString(''hex'');
// Store in environment variable or secret manager

Features:

• • Streaming processing - no full file buffering
• • Constant memory usage (~10MB regardless of file size)
• • Parallel chunk processing for improved performance
• • Progress tracking for large files

Workflow:

1. 1. Generate hash of original file before distribution
2. 2. Store hash in secure location or publish publicly
3. 3. Recipients download file and generate hash
4. 4. Compare downloaded file hash with original hash
5. 5. If hashes match, file is authentic and unmodified

Use Cases:

• • Software distribution (verify downloads haven''t been modified)
• • Cloud storage integrity (detect bit rot and corruption)
• • Backup verification (confirm backups are complete and valid)
• • File deduplication (identify identical files by hash)

Implementation:

1. 1. Generate cryptographically random salt (minimum 128 bits)
2. 2. Concatenate salt with data before hashing: hash(salt + data)
3. 3. Store salt alongside hash (salt doesn''t need to be secret)
4. 4. When verifying, hash new input with same salt and compare

Example:

// Hashing with salt
const salt = crypto.randomBytes(16).toString(''hex'');
const dataWithSalt = salt + data;
const hash = await generateHash(dataWithSalt, ''sha256'');
// Store: salt + '':'' + hash

How they work:

Attackers precompute hashes of common passwords/data and look up stolen hashes to find original value.

Protection:

• • Use unique salts for each hash (makes rainbow tables ineffective)
• • Use slow hash functions for passwords (bcrypt, Argon2)
• • Use long, random salts (minimum 128 bits)
• • Never reuse salts across different data

Code:

import axios from 'axios';

const generateTextHash = async (text: string, algorithm = 'sha256') => {
  try {
    const response = await axios.post(
      'https://apphighway.com/api/v1/hash/generate',
      {
        input: text,
        algorithm: algorithm, // 'md5', 'sha1', 'sha256', 'sha512', 'blake2'
        outputFormat: 'hex' // or 'base64'
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log(`${algorithm.toUpperCase()} hash:`, response.data.hash);
    // Output: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"

    return response.data.hash;
  } catch (error) {
    console.error('Hash generation error:', error.response?.data);
    throw error;
  }
};

// Usage
const hash = await generateTextHash('Hello World', 'sha256');
console.log('File fingerprint:', hash);

Code:

import axios from 'axios';
import crypto from 'crypto';

const signWebhookPayload = async (payload: object, secretKey: string) => {
  try {
    // Convert payload to JSON string
    const payloadString = JSON.stringify(payload);

    const response = await axios.post(
      'https://apphighway.com/api/v1/hash/hmac',
      {
        input: payloadString,
        algorithm: 'sha256',
        secretKey: secretKey,
        outputFormat: 'hex'
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    const signature = response.data.hmac;
    console.log('HMAC signature:', signature);

    return signature;
  } catch (error) {
    console.error('HMAC generation error:', error.response?.data);
    throw error;
  }
};

// Sending webhook with signature
const sendWebhook = async (url: string, payload: object) => {
  const secretKey = process.env.WEBHOOK_SECRET;
  const signature = await signWebhookPayload(payload, secretKey);

  await axios.post(url, payload, {
    headers: {
      'X-Webhook-Signature': signature,
      'Content-Type': 'application/json'
    }
  });
};

// Verifying webhook
const verifyWebhook = async (payload: object, receivedSignature: string) => {
  const secretKey = process.env.WEBHOOK_SECRET;
  const computedSignature = await signWebhookPayload(payload, secretKey);

  if (computedSignature !== receivedSignature) {
    throw new Error('Invalid webhook signature');
  }

  console.log('Webhook signature verified');
  return true;
};

Code:

import axios from 'axios';
import FormData from 'form-data';
import fs from 'fs';
import path from 'path';

const hashLargeFile = async (filePath: string, algorithm = 'sha256') => {
  try {
    const formData = new FormData();
    const fileStream = fs.createReadStream(filePath);
    const fileName = path.basename(filePath);

    formData.append('file', fileStream, fileName);
    formData.append('algorithm', algorithm);
    formData.append('outputFormat', 'hex');

    console.log(`Hashing file: ${fileName}`);
    const startTime = Date.now();

    const response = await axios.post(
      'https://apphighway.com/api/v1/hash/file',
      formData,
      {
        headers: {
          ...formData.getHeaders(),
          'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`
        },
        maxBodyLength: Infinity,
        maxContentLength: Infinity
      }
    );

    const duration = Date.now() - startTime;
    const fileSize = fs.statSync(filePath).size;
    const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);

    console.log(`File hashed in ${duration}ms`);
    console.log(`File size: ${fileSizeMB} MB`);
    console.log(`${algorithm.toUpperCase()} hash:`, response.data.hash);

    return {
      hash: response.data.hash,
      algorithm: algorithm,
      fileName: fileName,
      fileSize: fileSize,
      duration: duration
    };
  } catch (error) {
    console.error('File hashing error:', error.response?.data);
    throw error;
  }
};

// Usage - Hash file and store checksum
const verifyFileIntegrity = async (filePath: string, expectedHash: string) => {
  const result = await hashLargeFile(filePath, 'sha256');

  if (result.hash === expectedHash) {
    console.log('✓ File integrity verified');
    return true;
  } else {
    console.error('✗ File integrity check FAILED');
    console.error(`Expected: ${expectedHash}`);
    console.error(`Got:      ${result.hash}`);
    return false;
  }
};

// Example: Verify software download
await hashLargeFile('./downloads/software-v1.2.3.exe', 'sha256');
await verifyFileIntegrity(
  './downloads/software-v1.2.3.exe',
  'a3c5f2e8b1d4c9a7f6e8d2b5c9a1f4e7d8b2c5a9f1e4d7b8c2a5f9e1d4c7b8a2'
);

Implementation Steps:

1. 1. Client computes SHA-256 hash before upload (browser JavaScript)
2. 2. Client uploads file + hash to server
3. 3. Server uses AppHighway tool to hash received file
4. 4. Server compares client hash vs. server hash
5. 5. If mismatch: reject upload, prompt retry. If match: accept and store hash
6. 6. Background job periodically rehashes stored files to detect bit rot

Server-side Upload Handler (Node.js)

import { hashLargeFile } from './apphighway';
import { saveFile, storeFileMetadata } from './storage';

const handleFileUpload = async (req, res) => {
  const { file } = req.files;
  const { clientHash, userId, fileName } = req.body;

  try {
    // Hash uploaded file on server
    const result = await hashLargeFile(file.path, 'sha256');
    const serverHash = result.hash;

    // Compare hashes
    if (serverHash !== clientHash) {
      console.error('Hash mismatch - file corrupted during upload');
      return res.status(400).json({
        error: 'File integrity check failed',
        message: 'File may be corrupted. Please try uploading again.'
      });
    }

    // Save file and metadata
    const fileUrl = await saveFile(file.path, fileName);
    await storeFileMetadata({
      userId,
      fileName,
      fileUrl,
      hash: serverHash,
      algorithm: 'sha256',
      uploadedAt: new Date(),
      fileSize: file.size
    });

    console.log(`File uploaded successfully: ${fileName}`);
    res.json({
      success: true,
      fileUrl,
      hash: serverHash
    });
  } catch (error) {
    console.error('Upload error:', error);
    res.status(500).json({ error: 'Upload failed' });
  }
};

// Background job: Verify stored file integrity
const verifyStoredFiles = async () => {
  const files = await getRecentlyUploadedFiles(100);

  for (const file of files) {
    try {
      const result = await hashLargeFile(file.path, 'sha256');

      if (result.hash !== file.storedHash) {
        console.error(`File corrupted: ${file.fileName}`);
        await alertUser(file.userId, file.fileName);
        await markFileAsCorrupted(file.id);
      }
    } catch (error) {
      console.error(`Verification failed for ${file.fileName}:`, error);
    }
  }
};

// Run daily
setInterval(verifyStoredFiles, 24 * 60 * 60 * 1000);