SPECK Encryption

// SPECK Lightweight Block Cipher Implementation in JavaScript

/**
 * SPECK block cipher implementation
 * 
 * This is a JavaScript implementation of the SPECK lightweight block cipher
 * designed by the NSA for resource-constrained devices.
 * 
 * Reference: "The SIMON and SPECK Lightweight Block Ciphers" by
 * Ray Beaulieu, Douglas Shors, Jason Smith, Stefan Treatman-Clark,
 * Bryan Weeks, and Louis Wingers
 */

// Rotation constants for different word sizes
const ROTATION_CONSTANTS = {
  16: { alpha: 7, beta: 2 }, // For Speck32/64
  24: { alpha: 8, beta: 3 }, // For Speck48/72, Speck48/96
  32: { alpha: 8, beta: 3 }, // For Speck64/96, Speck64/128
  48: { alpha: 8, beta: 3 }, // For Speck96/96, Speck96/144
  64: { alpha: 8, beta: 3 }, // For Speck128/128, Speck128/192, Speck128/256
};

// Number of rounds for each variant
const ROUNDS = {
  "Speck32/64": 22,
  "Speck48/72": 22,
  "Speck48/96": 23,
  "Speck64/96": 26,
  "Speck64/128": 27,
  "Speck96/96": 28,
  "Speck96/144": 29,
  "Speck128/128": 32,
  "Speck128/192": 33,
  "Speck128/256": 34,
};

/**
 * Convert a hexadecimal string to a BigInt
 * @param {string} hex - Hexadecimal string
 * @returns {BigInt} - BigInt representation
 */
function hexToBigInt(hex) {
  return BigInt(`0x${hex}`);
}

/**
 * Convert a BigInt to a hexadecimal string with specified length
 * @param {BigInt} num - BigInt number
 * @param {number} length - Desired length of the hex string
 * @returns {string} - Hexadecimal string
 */
function bigIntToHex(num, length) {
  return num.toString(16).padStart(length, '0');
}

/**
 * Rotate right (circular right shift)
 * @param {BigInt} x - Value to rotate
 * @param {number} n - Number of bits to rotate
 * @param {number} wordSize - Word size in bits
 * @returns {BigInt} - Rotated value
 */
function ror(x, n, wordSize) {
  const mask = (BigInt(1) << BigInt(wordSize)) - BigInt(1);
  return ((x >> BigInt(n)) | ((x << BigInt(wordSize - n)) & mask)) & mask;
}

/**
 * Rotate left (circular left shift)
 * @param {BigInt} x - Value to rotate
 * @param {number} n - Number of bits to rotate
 * @param {number} wordSize - Word size in bits
 * @returns {BigInt} - Rotated value
 */
function rol(x, n, wordSize) {
  const mask = (BigInt(1) << BigInt(wordSize)) - BigInt(1);
  return ((x << BigInt(n)) | (x >> BigInt(wordSize - n))) & mask;
}

/**
 * Generate round keys for SPECK
 * @param {string} key - Key as a hex string
 * @param {number} rounds - Number of rounds
 * @param {Object} params - Parameters including wordSize and keySize
 * @returns {Array<BigInt>} - Array of round keys
 */
function generateRoundKeys(key, rounds, params) {
  const { wordSize, keySize } = params;
  const keyWords = keySize / wordSize;
  const wordSizeInHex = wordSize / 4;
  const { alpha, beta } = ROTATION_CONSTANTS[wordSize];
  const wordMask = (BigInt(1) << BigInt(wordSize)) - BigInt(1);
  
  // Split key into words
  const keyParts = [];
  for (let i = 0; i < keyWords; i++) {
    const start = i * wordSizeInHex;
    const end = start + wordSizeInHex;
    keyParts.push(hexToBigInt(key.slice(start, end)));
  }
  
  const roundKeys = [keyParts[0]];
  const l = keyParts.slice(1);
  
  for (let i = 0; i < rounds - 1; i++) {
    // Key schedule
    let li = l[i % (keyWords - 1)];
    let ki = roundKeys[i];
    
    // l[i] = (ROR(l[i], alpha) + k[i]) XOR i
    li = ror(li, alpha, wordSize);
    li = (li + ki) & wordMask;
    li = li ^ BigInt(i);
    
    // k[i+1] = ROL(k[i], beta) XOR l[i]
    ki = rol(ki, beta, wordSize);
    ki = ki ^ li;
    
    roundKeys.push(ki);
    l.push(li);
  }
  
  return roundKeys;
}

/**
 * Encrypt a block using SPECK
 * @param {string} block - Block as a hex string
 * @param {Array<BigInt>} roundKeys - Round keys
 * @param {Object} params - Parameters including wordSize
 * @returns {string} - Encrypted block as a hex string
 */
function encryptBlock(block, roundKeys, params) {
  const { wordSize } = params;
  const wordSizeInHex = wordSize / 4;
  const { alpha, beta } = ROTATION_CONSTANTS[wordSize];
  const wordMask = (BigInt(1) << BigInt(wordSize)) - BigInt(1);
  
  // Split block into two words
  let x = hexToBigInt(block.slice(0, wordSizeInHex));
  let y = hexToBigInt(block.slice(wordSizeInHex));
  
  // Apply rounds
  for (let i = 0; i < roundKeys.length; i++) {
    // x = ROR(x, alpha)
    x = ror(x, alpha, wordSize);
    
    // x = (x + y) mod 2^n
    x = (x + y) & wordMask;
    
    // x = x XOR k
    x = x ^ roundKeys[i];
    
    // y = ROL(y, beta)
    y = rol(y, beta, wordSize);
    
    // y = y XOR x
    y = y ^ x;
  }
  
  // Combine the two words
  return bigIntToHex(x, wordSizeInHex) + bigIntToHex(y, wordSizeInHex);
}

/**
 * Decrypt a block using SPECK
 * @param {string} block - Block as a hex string
 * @param {Array<BigInt>} roundKeys - Round keys
 * @param {Object} params - Parameters including wordSize
 * @returns {string} - Decrypted block as a hex string
 */
function decryptBlock(block, roundKeys, params) {
  const { wordSize } = params;
  const wordSizeInHex = wordSize / 4;
  const { alpha, beta } = ROTATION_CONSTANTS[wordSize];
  const wordMask = (BigInt(1) << BigInt(wordSize)) - BigInt(1);
  
  // Split block into two words
  let x = hexToBigInt(block.slice(0, wordSizeInHex));
  let y = hexToBigInt(block.slice(wordSizeInHex));
  
  // Apply rounds in reverse
  for (let i = roundKeys.length - 1; i >= 0; i--) {
    // y = y XOR x
    y = y ^ x;
    
    // y = ROR(y, beta)
    y = ror(y, beta, wordSize);
    
    // x = x XOR k
    x = x ^ roundKeys[i];
    
    // x = (x - y) mod 2^n
    x = (x - y) & wordMask;
    
    // x = ROL(x, alpha)
    x = rol(x, alpha, wordSize);
  }
  
  // Combine the two words
  return bigIntToHex(x, wordSizeInHex) + bigIntToHex(y, wordSizeInHex);
}

/**
 * Encrypt a message using SPECK in ECB mode
 * @param {string} message - Message to encrypt
 * @param {string} key - Key as a hex string
 * @param {string} variant - SPECK variant (e.g., "Speck64/128")
 * @param {boolean} isHex - Whether the message is already in hex format
 * @returns {string} - Encrypted message as a hex string
 */
function encryptSpeck(message, key, variant = "Speck64/128", isHex = false) {
  // Get parameters for the variant
  const [blockSizeStr, keySizeStr] = variant.substring(5).split('/');
  const blockSize = parseInt(blockSizeStr);
  const keySize = parseInt(keySizeStr);
  const wordSize = blockSize / 2;
  const blockSizeInHex = blockSize / 4;
  const rounds = ROUNDS[variant] || 27; // Default to Speck64/128 rounds
  
  // Convert message to hex if needed
  const messageHex = isHex ? message : stringToHex(message);
  
  // Pad the message to a multiple of block size
  const paddedMessage = padHex(messageHex, blockSizeInHex);
  
  // Generate round keys
  const roundKeys = generateRoundKeys(key, rounds, { wordSize, keySize });
  
  let ciphertext = '';
  
  // Encrypt each block
  for (let i = 0; i < paddedMessage.length; i += blockSizeInHex) {
    const block = paddedMessage.substr(i, blockSizeInHex);
    const encryptedBlock = encryptBlock(block, roundKeys, { wordSize });
    ciphertext += encryptedBlock;
  }
  
  return ciphertext;
}

/**
 * Decrypt a message using SPECK in ECB mode
 * @param {string} ciphertext - Ciphertext as a hex string
 * @param {string} key - Key as a hex string
 * @param {string} variant - SPECK variant (e.g., "Speck64/128")
 * @param {boolean} toHex - Whether to return the result as hex or convert to string
 * @returns {string} - Decrypted message
 */
function decryptSpeck(ciphertext, key, variant = "Speck64/128", toHex = false) {
  // Get parameters for the variant
  const [blockSizeStr, keySizeStr] = variant.substring(5).split('/');
  const blockSize = parseInt(blockSizeStr);
  const keySize = parseInt(keySizeStr);
  const wordSize = blockSize / 2;
  const blockSizeInHex = blockSize / 4;
  const rounds = ROUNDS[variant] || 27; // Default to Speck64/128 rounds
  
  // Generate round keys
  const roundKeys = generateRoundKeys(key, rounds, { wordSize, keySize });
  
  let plaintext = '';
  
  // Decrypt each block
  for (let i = 0; i < ciphertext.length; i += blockSizeInHex) {
    const block = ciphertext.substr(i, blockSizeInHex);
    const decryptedBlock = decryptBlock(block, roundKeys, { wordSize });
    plaintext += decryptedBlock;
  }
  
  // Convert from hex to string if requested
  return toHex ? plaintext : hexToString(plaintext);
}

/**
 * Convert a string to a hex string
 * @param {string} str - Input string
 * @returns {string} - Hex string
 */
function stringToHex(str) {
  let hex = '';
  for (let i = 0; i < str.length; i++) {
    const charCode = str.charCodeAt(i);
    hex += charCode.toString(16).padStart(2, '0');
  }
  return hex;
}

/**
 * Convert a hex string to a string
 * @param {string} hex - Hex string
 * @returns {string} - Decoded string
 */
function hexToString(hex) {
  let str = '';
  for (let i = 0; i < hex.length; i += 2) {
    const charCode = parseInt(hex.substr(i, 2), 16);
    if (charCode) {
      str += String.fromCharCode(charCode);
    }
  }
  return str;
}

/**
 * Pad a hex string to a multiple of specified length
 * @param {string} hex - Hex string to pad
 * @param {number} blockSize - Block size in hex characters
 * @returns {string} - Padded hex string
 */
function padHex(hex, blockSize) {
  const paddingLength = blockSize - (hex.length % blockSize);
  
  if (paddingLength < blockSize) {
    return hex + '0'.repeat(paddingLength);
  }
  
  return hex;
}

// Export the functions
module.exports = {
  encryptSpeck,
  decryptSpeck,
  encryptBlock,
  decryptBlock,
  generateRoundKeys,
  stringToHex,
  hexToString
};