tessl/npm-crypto-js

JavaScript library of crypto standards providing comprehensive cryptographic algorithms including hashing, encryption, HMAC, and encoding utilities.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Encoding Utilities

Name: tessl/npm-crypto-js
Author: tessl

Format conversion utilities for transforming between different data representations used in cryptographic operations. All encoders provide stringify/parse methods to convert between WordArray objects and string representations.

Capabilities

Hexadecimal Encoding

Convert between WordArray and hexadecimal string representation.

/**
 * Hexadecimal encoding object with stringify/parse methods
 */
CryptoJS.enc.Hex {
  /**
   * Converts WordArray to hexadecimal string
   * @param wordArray - WordArray to convert
   * @returns Hexadecimal string representation
   */
  stringify(wordArray): string;
  
  /**
   * Converts hexadecimal string to WordArray
   * @param hexStr - Hexadecimal string to parse
   * @returns WordArray representation
   */
  parse(hexStr): WordArray;
}

Usage Examples:

var CryptoJS = require("crypto-js");

// WordArray to hex string
var data = CryptoJS.enc.Utf8.parse("Hello World");
var hexString = CryptoJS.enc.Hex.stringify(data);
console.log("Hex:", hexString); // "48656c6c6f20576f726c64"

// Hex string to WordArray
var parsed = CryptoJS.enc.Hex.parse("48656c6c6f20576f726c64");
console.log("Parsed:", CryptoJS.enc.Utf8.stringify(parsed)); // "Hello World"

// Using with hash functions
var hash = CryptoJS.SHA256("test");
console.log("Default (hex):", hash.toString());
console.log("Explicit hex:", hash.toString(CryptoJS.enc.Hex));

Base64 Encoding

Convert between WordArray and Base64 string representation.

/**
 * Base64 encoding object with stringify/parse methods
 */
CryptoJS.enc.Base64 {
  /**
   * Converts WordArray to Base64 string
   * @param wordArray - WordArray to convert
   * @returns Base64 string representation
   */
  stringify(wordArray): string;
  
  /**
   * Converts Base64 string to WordArray
   * @param base64Str - Base64 string to parse
   * @returns WordArray representation
   */
  parse(base64Str): WordArray;
}

Usage Examples:

var CryptoJS = require("crypto-js");

// WordArray to Base64 string
var data = CryptoJS.enc.Utf8.parse("Hello World");
var base64String = CryptoJS.enc.Base64.stringify(data);
console.log("Base64:", base64String); // "SGVsbG8gV29ybGQ="

// Base64 string to WordArray
var parsed = CryptoJS.enc.Base64.parse("SGVsbG8gV29ybGQ=");
console.log("Parsed:", CryptoJS.enc.Utf8.stringify(parsed)); // "Hello World"

// Using with encryption
var encrypted = CryptoJS.AES.encrypt("message", "key");
console.log("Default (Base64):", encrypted.toString());
console.log("Explicit Base64:", encrypted.toString(CryptoJS.enc.Base64));

Base64URL Encoding

URL-safe Base64 encoding without padding characters.

/**
 * Base64URL encoding object with stringify/parse methods
 */
CryptoJS.enc.Base64url {
  /**
   * Converts WordArray to Base64URL string
   * @param wordArray - WordArray to convert
   * @returns Base64URL string representation (URL-safe, no padding)
   */
  stringify(wordArray): string;
  
  /**
   * Converts Base64URL string to WordArray
   * @param base64urlStr - Base64URL string to parse
   * @returns WordArray representation
   */
  parse(base64urlStr): WordArray;
}

Usage Examples:

var CryptoJS = require("crypto-js");

var data = CryptoJS.enc.Utf8.parse("Hello World>>>");

// Compare Base64 vs Base64URL
var base64 = CryptoJS.enc.Base64.stringify(data);
var base64url = CryptoJS.enc.Base64url.stringify(data);

console.log("Base64:", base64);     // "SGVsbG8gV29ybGQ+Pj4="
console.log("Base64URL:", base64url); // "SGVsbG8gV29ybGQ-Pj4"

// JWT token encoding example
function encodeJWTPart(obj) {
    var json = JSON.stringify(obj);
    var wordArray = CryptoJS.enc.Utf8.parse(json);
    return CryptoJS.enc.Base64url.stringify(wordArray);
}

var header = encodeJWTPart({alg: "HS256", typ: "JWT"});
var payload = encodeJWTPart({sub: "1234567890", name: "John Doe"});
console.log("JWT parts:", header + "." + payload);

UTF-8 Encoding

Convert between WordArray and UTF-8 string representation.

/**
 * UTF-8 encoding object with stringify/parse methods
 */
CryptoJS.enc.Utf8 {
  /**
   * Converts WordArray to UTF-8 string
   * @param wordArray - WordArray to convert
   * @returns UTF-8 string representation
   */
  stringify(wordArray): string;
  
  /**
   * Converts UTF-8 string to WordArray
   * @param utf8Str - UTF-8 string to parse
   * @returns WordArray representation
   */
  parse(utf8Str): WordArray;
}

Usage Examples:

var CryptoJS = require("crypto-js");

// String to WordArray
var message = "Hello 世界! 🌍";
var wordArray = CryptoJS.enc.Utf8.parse(message);
console.log("WordArray words:", wordArray.words);
console.log("Significant bytes:", wordArray.sigBytes);

// WordArray back to string
var reconstructed = CryptoJS.enc.Utf8.stringify(wordArray);
console.log("Reconstructed:", reconstructed); // "Hello 世界! 🌍"

// Using with encryption/decryption
var encrypted = CryptoJS.AES.encrypt(message, "key");
var decrypted = CryptoJS.AES.decrypt(encrypted, "key");
var decryptedText = CryptoJS.enc.Utf8.stringify(decrypted);
console.log("Decrypted:", decryptedText);

UTF-16 Encoding

Convert between WordArray and UTF-16 string representations.

/**
 * UTF-16 Big Endian encoding object
 */
CryptoJS.enc.Utf16 {
  stringify(wordArray): string;
  parse(utf16Str): WordArray;
}

/**
 * UTF-16 Big Endian encoding (alias for Utf16)
 */
CryptoJS.enc.Utf16BE {
  stringify(wordArray): string;
  parse(utf16Str): WordArray;
}

/**
 * UTF-16 Little Endian encoding object
 */
CryptoJS.enc.Utf16LE {
  stringify(wordArray): string;
  parse(utf16Str): WordArray;
}

Usage Examples:

var CryptoJS = require("crypto-js");

var message = "Hello World";

// UTF-16 Big Endian (default)
var utf16BE = CryptoJS.enc.Utf16.parse(message);
console.log("UTF-16 BE:", CryptoJS.enc.Hex.stringify(utf16BE));

// UTF-16 Little Endian
var utf16LE = CryptoJS.enc.Utf16LE.parse(message);
console.log("UTF-16 LE:", CryptoJS.enc.Hex.stringify(utf16LE));

// Convert back
console.log("BE to string:", CryptoJS.enc.Utf16.stringify(utf16BE));
console.log("LE to string:", CryptoJS.enc.Utf16LE.stringify(utf16LE));

Latin1 Encoding

Convert between WordArray and Latin1 (ISO-8859-1) string representation.

/**
 * Latin1 encoding object with stringify/parse methods
 */
CryptoJS.enc.Latin1 {
  /**
   * Converts WordArray to Latin1 string
   * @param wordArray - WordArray to convert
   * @returns Latin1 string representation
   */
  stringify(wordArray): string;
  
  /**
   * Converts Latin1 string to WordArray
   * @param latin1Str - Latin1 string to parse
   * @returns WordArray representation
   */
  parse(latin1Str): WordArray;
}

Common Encoding Patterns

Binary Data Handling

var CryptoJS = require("crypto-js");

// Working with binary data
var binaryArray = new Uint8Array([72, 101, 108, 108, 111]);

// Convert Uint8Array to WordArray
var wordArray = CryptoJS.lib.WordArray.create(binaryArray);
console.log("Binary as hex:", CryptoJS.enc.Hex.stringify(wordArray));

// Different representations of the same data
console.log("As UTF-8:", CryptoJS.enc.Utf8.stringify(wordArray));
console.log("As Base64:", CryptoJS.enc.Base64.stringify(wordArray));
console.log("As Latin1:", CryptoJS.enc.Latin1.stringify(wordArray));

Chain Encoding Conversions

var CryptoJS = require("crypto-js");

var message = "Secret Message";

// Chain: String -> WordArray -> Hash -> Different encodings
var wordArray = CryptoJS.enc.Utf8.parse(message);
var hash = CryptoJS.SHA256(wordArray);

console.log("Original:", message);
console.log("Hash (Hex):", hash.toString());
console.log("Hash (Base64):", CryptoJS.enc.Base64.stringify(hash));
console.log("Hash (Base64URL):", CryptoJS.enc.Base64url.stringify(hash));

// Parse Base64 hash back to WordArray
var hashFromBase64 = CryptoJS.enc.Base64.parse(CryptoJS.enc.Base64.stringify(hash));
console.log("Roundtrip match:", hash.toString() === hashFromBase64.toString());

Custom Encoding Validation

var CryptoJS = require("crypto-js");

function isValidBase64(str) {
    try {
        var parsed = CryptoJS.enc.Base64.parse(str);
        var stringified = CryptoJS.enc.Base64.stringify(parsed);
        return stringified === str;
    } catch (e) {
        return false;
    }
}

function isValidHex(str) {
    try {
        var parsed = CryptoJS.enc.Hex.parse(str);
        var stringified = CryptoJS.enc.Hex.stringify(parsed);
        return stringified.toLowerCase() === str.toLowerCase();
    } catch (e) {
        return false;
    }
}

// Test validation
console.log("Valid Base64:", isValidBase64("SGVsbG8=")); // true
console.log("Invalid Base64:", isValidBase64("Invalid!")); // false
console.log("Valid Hex:", isValidHex("48656c6c6f")); // true
console.log("Invalid Hex:", isValidHex("xyz123")); // false

Types

// Encoder Interface
Encoder {
  /**
   * Converts WordArray to string representation
   * @param wordArray - WordArray to convert
   * @returns String representation
   */
  stringify(wordArray: WordArray): string;
  
  /**
   * Converts string to WordArray representation
   * @param str - String to parse
   * @returns WordArray representation
   */
  parse(str: string): WordArray;
}

// WordArray (used by all encoders)
WordArray {
  words: number[];        // Array of 32-bit words
  sigBytes: number;       // Number of significant bytes
  toString(encoder?): string;     // Convert using encoder (hex by default)
  concat(wordArray): WordArray;   // Concatenate with another WordArray
  clamp(): void;          // Remove insignificant bytes
  clone(): WordArray;     // Create a copy
}

Install with Tessl CLI