SHA-224 API Reference

// File hashing example

// Browser-side file hashing
async function hashFileInBrowser() {
  const fileInput = document.getElementById('fileInput');
  const file = fileInput.files[0];
  
  if (!file) {
    console.error('No file selected');
    return;
  }
  
  try {
    // Read file as ArrayBuffer
    const arrayBuffer = await file.arrayBuffer();
    const fileData = new Uint8Array(arrayBuffer);
    
    // Generate hash
    const hash = SHA224(fileData);
    console.log(`File hash (${file.name}):`, hash);
    
    return hash;
  } catch (error) {
    console.error('Error hashing file:', error);
  }
}

// Node.js file hashing with REST API
async function hashFileWithAPI(filePath) {
  const apiKey = 'YOUR_API_KEY';
  const fs = require('fs');
  const FormData = require('form-data');
  const fetch = require('node-fetch');
  
  try {
    const form = new FormData();
    form.append('file', fs.createReadStream(filePath));
    
    const response = await fetch('https://api.sha224.com/v1/file/hash', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`
      },
      body: form
    });
    
    const result = await response.json();
    console.log('File hash result:', result.hash);
    return result.hash;
  } catch (error) {
    console.error('API error:', error);
  }
}

// Streaming data example

// Browser-side chunked processing
async function processLargeFileInChunks(file, chunkSize = 1024 * 1024) {
  return new Promise((resolve, reject) => {
    const hasher = new SHA224Class();
    const fileReader = new FileReader();
    let offset = 0;
    
    // Process the file in chunks
    const readNextChunk = () => {
      const slice = file.slice(offset, offset + chunkSize);
      fileReader.readAsArrayBuffer(slice);
    };
    
    fileReader.onload = (e) => {
      // Update hash with this chunk
      const chunk = new Uint8Array(e.target.result);
      hasher.update(chunk);
      
      // Move to next chunk or finish
      offset += chunk.length;
      if (offset < file.size) {
        // Read next chunk
        readNextChunk();
      } else {
        // We've processed the entire file
        const hash = hasher.digest();
        resolve(hash);
      }
    };
    
    fileReader.onerror = (e) => {
      reject(new Error('Error reading file'));
    };
    
    // Start reading
    readNextChunk();
  });
}

// Node.js streaming example
function hashFileStream(filePath) {
  const fs = require('fs');
  const hasher = new SHA224Class();
  
  return new Promise((resolve, reject) => {
    const stream = fs.createReadStream(filePath);
    
    stream.on('data', (chunk) => {
      hasher.update(chunk);
    });
    
    stream.on('end', () => {
      const hash = hasher.digest();
      resolve(hash);
    });
    
    stream.on('error', (err) => {
      reject(err);
    });
  });
}

// HMAC example

// REST API HMAC generation
async function generateHMAC(message, key) {
  const apiKey = 'YOUR_API_KEY';
  
  try {
    const response = await fetch('https://api.sha224.com/v1/hmac', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        data: message,
        key: key,
        encoding: 'utf8',
        keyEncoding: 'utf8'
      })
    });
    
    const result = await response.json();
    console.log('HMAC result:', result.hmac);
    return result.hmac;
  } catch (error) {
    console.error('API error:', error);
  }
}

// Node.js HMAC implementation
function generateHMACNodeJS(message, key) {
  const crypto = require('crypto');
  
  const hmac = crypto.createHmac('sha224', key);
  hmac.update(message);
  return hmac.digest('hex');
}