Last active
April 4, 2024 17:59
-
-
Save atoponce/1a8531e62704fd3487c08122382cc781 to your computer and use it in GitHub Desktop.
Trivium stream cipher with test vectors
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
"use strict" | |
/** Class representing the Trivium stream cipher. */ | |
module.exports = class Trivium { | |
#state // Trivium 288-bit state. | |
#keystream // Trivium keystream. | |
/** | |
* Initialize Trivium with key and IV. | |
* @param {Uint8Array} key - An 8-bit array of 10 unsigned integers. | |
* @param {Uint8Array} iv - An 8-bit array of 10 unsigned integers. | |
* @throws {Error} | |
*/ | |
constructor(key, iv) { | |
if (typeof key === "undefined") { | |
key = new Uint8Array([ | |
0x53, 0x65, 0x74, 0x20, 0x54, 0x72, 0x69, 0x76, 0x69, 0x75 // "Set Triviu" | |
]) | |
} | |
if (typeof iv === "undefined") { | |
iv = new Uint8Array([ | |
0x6d, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x26, 0x20, 0x49, 0x56 // "m key & IV" | |
]) | |
} | |
if (!(key instanceof Uint8Array) || key.length !== 10) { | |
throw new Error("Key should be a 10-element Uint8Array.") | |
} | |
if (!(iv instanceof Uint8Array) || iv.length !== 10) { | |
throw new Error("IV should be a 10-element Uint8Array.") | |
} | |
this.#state = new Array(288).fill(0) | |
const keyBits = [] | |
const ivBits = [] | |
for (let i = 0; i < 10; i++) { | |
let tmpBits = this.#byteToBits(key[i]) | |
tmpBits.reverse() | |
for (let j = 0; j < 8; j++) { | |
keyBits.push(tmpBits[j]) | |
} | |
tmpBits = this.#byteToBits(iv[i]) | |
tmpBits.reverse() | |
for (let j = 0; j < 8; j++) { | |
ivBits.push(tmpBits[j]) | |
} | |
} | |
keyBits.reverse() | |
ivBits.reverse() | |
for (let i = 0; i < 80; i++) { | |
this.#state[i] = keyBits[i] | |
this.#state[i + 93] = ivBits[i] | |
} | |
this.#state[285] = 1 | |
this.#state[286] = 1 | |
this.#state[287] = 1 | |
for (let i = 0; i < (288 << 2); i++) { | |
this.#genKeyStream() | |
} | |
} | |
/** | |
* Generates a keystream bit and manipulates the Trivium state. The Trivium | |
* state is defined with three non-linear feedback shift registers: s1 (93 | |
* bits), s2 (84 bits), and s3 (111 bits). Each state is modified | |
* independently and each state depends on a single bit from the other, | |
* creating a circular dependency on itself. | |
* @returns {number} z - A single keystream bit. | |
*/ | |
#genKeyStream() { | |
let t1 = this.#state[65] ^ this.#state[92] | |
let t2 = this.#state[161] ^ this.#state[176] | |
let t3 = this.#state[242] ^ this.#state[287] | |
let z = t1 ^ t2 ^ t3 | |
t1 ^= (this.#state[90] & this.#state[91]) ^ this.#state[170] | |
t2 ^= (this.#state[174] & this.#state[175]) ^ this.#state[263] | |
t3 ^= (this.#state[285] & this.#state[286]) ^ this.#state[68] | |
this.#state.pop() | |
this.#state.unshift(t3) | |
this.#state[93] = t1 | |
this.#state[177] = t2 | |
return z | |
} | |
/** | |
* Convert an unsigned 8-bit integer to a bit-array. | |
* @param{number} byte - An 8-bit unsigned integer. | |
* @returns {Uint8Array} bits - An 8-element bit array. | |
*/ | |
#byteToBits(byte) { | |
const bits = new Uint8Array(8) | |
for (let i = 0; i < 8; i++) { | |
bits[i] = (byte >> (7 - i)) & 1 | |
} | |
return bits | |
} | |
/** | |
* Convert a bit-array to a an unsigned 8-bit integer. | |
* @param{Uint8Array} bits - An 8-element bit array. | |
* @returns {number} byte - An 8-bit unsigned integer. | |
*/ | |
#bitsToByte(bits) { | |
let byte = 0 | |
for (let i = 0; i < 8; i++) { | |
byte |= (bits[i] << (7 - i)) | |
} | |
return byte | |
} | |
/** | |
* Encrypting and decrypting data is done by applying XOR to the data and | |
* Trivium keystream. | |
* @param {Uint8Array} data - Array of data to XOR with the keystream. | |
* @return {Uint8Array} output - Array of plaintext or ciphertext bytes. | |
* @throws {Error} | |
*/ | |
#update(data) { | |
if (!(data instanceof Uint8Array)) { | |
throw new Error("Data should be a Uint8Array.") | |
} | |
const output = new Uint8Array(data.length) | |
for (let i = 0; i < data.length; i++) { | |
const inputBits = this.#byteToBits(data[i]) | |
const outputBits = new Uint8Array(8) | |
for (let j = 7; j >= 0; j--) { | |
outputBits[j] = inputBits[j] ^ this.#genKeyStream() | |
} | |
output[i] = this.#bitsToByte(outputBits) | |
} | |
return output | |
} | |
/** | |
* Encryption | |
* @param {Uint8Array} data - Array of data to encrypt. | |
* @returns {Uint8Array} - Array of ciphertext bytes. | |
*/ | |
encrypt(data) { | |
return this.#update(data) | |
} | |
/** | |
* Decryption | |
* @param {Uint8Array} data - Array of data to decrypt. | |
* @returns {Uint8Array} - Array of plaintext bytes. | |
*/ | |
decrypt(data) { | |
return this.#update(data) | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
const Trivium = require('./trivium.js') | |
const pt = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
let key = new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
let iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
let testVector = new Uint8Array([0x38, 0xEB, 0x86, 0xFF, 0x73, 0x0D, 0x7A, 0x9C, 0xAF, 0x8D, 0xF1, 0x3A, 0x44, 0x20, 0x54, 0x0D, 0xBB, 0x7B, 0x65, 0x14, 0x64, 0xC8, 0x75, 0x01, 0x55, 0x20, 0x41, 0xC2, 0x49, 0xF2, 0x9A, 0x64, 0xD2, 0xFB, 0xF5, 0x15, 0x61, 0x09, 0x21, 0xEB, 0xE0, 0x6C, 0x8F, 0x92, 0xCE, 0xCF, 0x7F, 0x80, 0x98, 0xFF, 0x20, 0xCC, 0xCC, 0x6A, 0x62, 0xB9, 0x7B, 0xE8, 0xEF, 0x74, 0x54, 0xFC, 0x80, 0xF9]) | |
let cipher = new Trivium(key, iv) | |
let ct = cipher.encrypt(pt) | |
console.log(1, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x61, 0x20, 0x8D, 0x28, 0x6B, 0xC1, 0xDC, 0x43, 0x11, 0x71, 0xED, 0xA5, 0xCA, 0xF7, 0x9D, 0x95, 0x60, 0xB1, 0x8A, 0xCE, 0xF2, 0x64, 0x84, 0x41, 0x7B, 0x65, 0x1A, 0x47, 0xA3, 0xF7, 0xA8, 0x03, 0x53, 0xF7, 0x9A, 0xF8, 0x65, 0x6D, 0xA4, 0x30, 0x1A, 0x5E, 0x5A, 0x02, 0xE0, 0x42, 0x65, 0xB1, 0x82, 0xC6, 0x7F, 0x58, 0x91, 0x22, 0x03, 0x49, 0xF8, 0xCD, 0x1C, 0xD0, 0x65, 0x97, 0xB7, 0x7E]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(2, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xC8, 0xF9, 0x03, 0x1D, 0xAB, 0xF8, 0xDB, 0x03, 0xFF, 0x12, 0x0D, 0x05, 0x51, 0x2B, 0x5F, 0x24, 0xEA, 0xEA, 0x1B, 0xAB, 0x43, 0x20, 0x1A, 0x5E, 0x93, 0xBF, 0x17, 0xF6, 0x28, 0xE5, 0xB2, 0x16, 0xD5, 0x85, 0x77, 0x11, 0x2F, 0x58, 0x1A, 0x67, 0xDD, 0x5F, 0x96, 0x24, 0x84, 0xED, 0x4A, 0xC5, 0x92, 0x02, 0xBA, 0x35, 0x09, 0xA7, 0x3E, 0x11, 0x96, 0x80, 0xB5, 0x62, 0xF8, 0x6D, 0xF0, 0xDC]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(3, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xF7, 0xE5, 0x23, 0x04, 0x0E, 0x86, 0xEA, 0x2C, 0x46, 0xA2, 0xBE, 0x70, 0x5B, 0xFC, 0x62, 0x59, 0x7F, 0x77, 0xE4, 0x64, 0x9C, 0x0E, 0x71, 0xD5, 0x1B, 0x28, 0x8E, 0xDD, 0x4F, 0xC1, 0x69, 0xBC, 0xD6, 0x81, 0xF4, 0x60, 0x3E, 0x19, 0x2A, 0x79, 0x71, 0xE7, 0x32, 0x90, 0x13, 0x3E, 0x1E, 0x32, 0xF9, 0x16, 0xD9, 0x8B, 0x0D, 0x77, 0xF3, 0x79, 0x27, 0xE1, 0x21, 0x5C, 0x1D, 0x6A, 0xE0, 0x37]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(4, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x4B, 0x43, 0x0B, 0xDE, 0x0F, 0x57, 0x4C, 0x7D, 0xE0, 0x6E, 0x6A, 0x19, 0x18, 0xBF, 0xB4, 0xDE, 0xC0, 0xE2, 0x83, 0x60, 0x71, 0xEB, 0x44, 0x6C, 0x59, 0x3E, 0xE1, 0xF2, 0x59, 0x45, 0x33, 0x27, 0x2E, 0x72, 0x0E, 0x2A, 0x27, 0x99, 0x27, 0x30, 0xE6, 0x7D, 0x50, 0x9E, 0xDF, 0x7B, 0xB0, 0xE6, 0x2A, 0xEA, 0x85, 0xED, 0x87, 0xB9, 0x98, 0xFA, 0x6F, 0x53, 0xA0, 0xB7, 0x7D, 0x26, 0xBB, 0xA2]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(5, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x4E, 0xAC, 0x0C, 0x5C, 0x7A, 0xD3, 0x27, 0x08, 0x4C, 0xFE, 0xD7, 0xEA, 0xF7, 0x2F, 0x6E, 0xB7, 0xFF, 0x20, 0xE1, 0x1C, 0x65, 0xDF, 0xC1, 0x47, 0x0C, 0x1D, 0x2E, 0xFA, 0xFC, 0xE2, 0xB1, 0xFA, 0x3E, 0xD6, 0xAF, 0xBE, 0x7C, 0xBE, 0xB6, 0x77, 0xDB, 0x11, 0x89, 0xCB, 0x68, 0x92, 0xE8, 0x10, 0x93, 0xB1, 0x6F, 0xDC, 0x34, 0x19, 0x9D, 0x0A, 0x26, 0xB8, 0x9F, 0x06, 0xC8, 0x6A, 0xC9, 0xD7]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(6, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x2D, 0x97, 0xF2, 0x27, 0xF2, 0x46, 0x3F, 0x27, 0x1F, 0x85, 0x3B, 0xA1, 0x08, 0x06, 0x88, 0x8F, 0x8B, 0xA5, 0x73, 0x35, 0x64, 0x55, 0x7D, 0x51, 0x74, 0xA1, 0x61, 0x72, 0xBD, 0x89, 0xD7, 0xE3, 0x2A, 0xDF, 0x9C, 0x5B, 0x25, 0x7D, 0xCC, 0x16, 0x93, 0xAB, 0x7C, 0xA6, 0x24, 0x8F, 0x7A, 0x33, 0xD3, 0x11, 0xFA, 0xD4, 0xD8, 0x9D, 0x1C, 0x6E, 0xB7, 0xFC, 0xF8, 0x89, 0x6D, 0x94, 0xE7, 0x9C]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(7, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x9E, 0xB8, 0xF6, 0xBD, 0x37, 0x47, 0x4B, 0x5C, 0x2A, 0xC0, 0x1B, 0xA1, 0xB3, 0xEE, 0xA5, 0xE1, 0xFB, 0xD4, 0xD4, 0xD1, 0xAE, 0x63, 0xEA, 0xFD, 0x81, 0xA4, 0xD2, 0xC9, 0x00, 0xB5, 0x93, 0x12, 0x73, 0xB3, 0x78, 0x20, 0xBC, 0x68, 0xFC, 0xD6, 0x9E, 0xD1, 0x8F, 0x1E, 0xD4, 0xEC, 0x93, 0x34, 0xF3, 0x9F, 0xEB, 0x33, 0x0B, 0xAA, 0xED, 0xEF, 0x2A, 0x1E, 0x51, 0xB2, 0x18, 0xB3, 0x85, 0xC8]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(8, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x5D, 0x49, 0x2E, 0x77, 0xF8, 0xFE, 0x62, 0xD7, 0x69, 0xC6, 0xA1, 0x42, 0x05, 0x6B, 0xE9, 0x36, 0x1F, 0xA0, 0xAD, 0xD8, 0xA5, 0x46, 0x01, 0xDE, 0x61, 0x5E, 0xBC, 0x04, 0xC4, 0xF8, 0xB2, 0xC1, 0x2A, 0x8E, 0xD2, 0xDC, 0x9A, 0xB2, 0x86, 0xA0, 0xF6, 0xC4, 0x9C, 0x7A, 0xB3, 0x19, 0xBA, 0x6A, 0xAF, 0xAA, 0xF0, 0xCD, 0x42, 0xD0, 0xA4, 0x4C, 0x7D, 0xAC, 0xBC, 0x90, 0x79, 0x18, 0x55, 0xD8]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(9, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xFB, 0xE0, 0xBF, 0x26, 0x58, 0x59, 0x05, 0x1B, 0x51, 0x7A, 0x2E, 0x4E, 0x23, 0x9F, 0xC9, 0x7F, 0x56, 0x32, 0x03, 0x16, 0x19, 0x07, 0xCF, 0x2D, 0xE7, 0xA8, 0x79, 0x0F, 0xA1, 0xB2, 0xE9, 0xCD, 0xF7, 0x52, 0x92, 0x03, 0x02, 0x68, 0xB7, 0x38, 0x2B, 0x4C, 0x1A, 0x75, 0x9A, 0xA2, 0x59, 0x9A, 0x28, 0x55, 0x49, 0x98, 0x6E, 0x74, 0x80, 0x59, 0x03, 0x80, 0x1A, 0x4C, 0xB5, 0xA5, 0xD4, 0xF2]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(10, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xAB, 0x97, 0x61, 0x6E, 0x7B, 0xAF, 0x09, 0x21, 0xF4, 0x24, 0xB2, 0x57, 0x3B, 0xFA, 0x15, 0xBD, 0xCA, 0x01, 0x89, 0x8A, 0xBB, 0xE6, 0xAB, 0x77, 0x27, 0x9A, 0xB1, 0xD7, 0x32, 0xAB, 0xD1, 0x05, 0x12, 0x76, 0x9C, 0xC6, 0x9F, 0xAB, 0x34, 0xE0, 0x3B, 0x80, 0x7F, 0x92, 0xC9, 0x66, 0x27, 0xC1, 0x76, 0x56, 0xBC, 0xC9, 0xBD, 0x9D, 0x37, 0x72, 0x40, 0xA2, 0xB6, 0xFD, 0xBD, 0x78, 0x44, 0x53]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(11, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xAD, 0x35, 0xE1, 0x7B, 0x19, 0x71, 0xAF, 0x6B, 0x5B, 0x3E, 0x36, 0x5F, 0xA6, 0x4E, 0xB4, 0xCF, 0x7E, 0xBF, 0x02, 0x3D, 0x52, 0x08, 0x89, 0xAD, 0x71, 0xF1, 0xA0, 0x7A, 0xA2, 0xE0, 0xFF, 0x44, 0xCE, 0xE3, 0x2D, 0x09, 0xCF, 0x77, 0x36, 0x0C, 0x52, 0x43, 0x4D, 0x46, 0x2B, 0x53, 0xA4, 0x05, 0xEF, 0x5A, 0x60, 0xD8, 0x2A, 0x0F, 0x5E, 0x3C, 0xF3, 0x32, 0x1B, 0x37, 0x27, 0xA3, 0xD6, 0x1E]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(12, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x57, 0x5A, 0xC7, 0x7D, 0xCD, 0x54, 0xE7, 0xF4, 0x8D, 0x83, 0x7A, 0xDE, 0x0A, 0x88, 0xC7, 0x0D, 0x77, 0x78, 0x39, 0xB3, 0x10, 0xC2, 0x97, 0x83, 0x5F, 0x5B, 0xB8, 0x8C, 0x1A, 0x5F, 0xFD, 0x15, 0x69, 0xA4, 0xC4, 0x67, 0x6E, 0x7D, 0x7C, 0xEA, 0x86, 0x4F, 0xA1, 0xAD, 0x2F, 0x78, 0xE3, 0xE0, 0x44, 0xE7, 0xD1, 0x45, 0x82, 0x7D, 0xD6, 0xE4, 0x09, 0x5C, 0xB3, 0x08, 0x11, 0x1F, 0x5C, 0x72]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(13, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x55, 0x02, 0xDF, 0x80, 0x70, 0x38, 0x7D, 0x12, 0x37, 0xEF, 0x52, 0x13, 0xB5, 0xF1, 0x9E, 0xB7, 0x9B, 0x9C, 0xC3, 0x08, 0x10, 0xDB, 0x96, 0x6D, 0xD2, 0xB2, 0x5C, 0x92, 0x49, 0xC0, 0x37, 0x8B, 0x17, 0x42, 0x3F, 0x4E, 0x78, 0x8B, 0xC3, 0xE8, 0x2F, 0xBF, 0xC7, 0xFA, 0x3F, 0xED, 0x4A, 0x57, 0x04, 0xBA, 0x35, 0xCF, 0x9C, 0xBD, 0x12, 0xDC, 0xFD, 0x56, 0xCB, 0x6D, 0xD4, 0x31, 0xA4, 0xD5]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(14, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D, 0x2D]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xFC, 0x87, 0x84, 0x96, 0x24, 0x21, 0x75, 0x31, 0x38, 0x58, 0x50, 0xAB, 0xE1, 0xCA, 0x16, 0xD5, 0x79, 0x2A, 0x45, 0xF8, 0xFC, 0x40, 0x63, 0x8B, 0x0B, 0xDF, 0xB7, 0xA3, 0x2D, 0x5B, 0x53, 0xCC, 0x67, 0x51, 0xFE, 0x1C, 0xBE, 0x1B, 0xA6, 0x73, 0xD2, 0x11, 0x3A, 0xB9, 0x00, 0xCF, 0xC9, 0xC3, 0x09, 0x5C, 0xA8, 0x5E, 0xAA, 0xF1, 0x7D, 0xC6, 0x17, 0x24, 0x9F, 0xEB, 0x36, 0x2A, 0x3F, 0x43]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(15, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x1F, 0x9A, 0x14, 0xB9, 0x8C, 0xB4, 0x48, 0xD4, 0x00, 0x2A, 0x37, 0x70, 0x36, 0x14, 0x47, 0xF8, 0xD0, 0xFC, 0xA7, 0xB2, 0xBC, 0xFA, 0x40, 0xD6, 0x18, 0xAB, 0x18, 0x33, 0xFF, 0x19, 0xDF, 0x6F, 0xB9, 0xBE, 0x5D, 0x7A, 0x47, 0xB6, 0x92, 0xFE, 0x64, 0xC7, 0xCA, 0x52, 0x0D, 0x60, 0xDA, 0x1C, 0x35, 0xAC, 0x0B, 0x9E, 0x60, 0x8C, 0x5E, 0x45, 0x90, 0x37, 0xF8, 0xE9, 0xE6, 0x8B, 0x8C, 0xD8]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(16, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xF2, 0xD9, 0x79, 0x2B, 0x78, 0xC2, 0xD3, 0xEC, 0x67, 0xD8, 0xC8, 0x0A, 0x71, 0x0D, 0x19, 0xEA, 0xDB, 0x16, 0x31, 0x99, 0xC6, 0xD9, 0xA1, 0xCB, 0x8F, 0x30, 0x62, 0x4D, 0x4B, 0x30, 0xD9, 0x16, 0xE4, 0xC2, 0x01, 0xE0, 0x13, 0xEF, 0x6F, 0x4E, 0x0B, 0xA5, 0x82, 0x96, 0xBA, 0xB2, 0xC5, 0x61, 0xE7, 0x37, 0xED, 0xAB, 0xD0, 0x55, 0xF5, 0x17, 0xCD, 0x54, 0x6B, 0x2B, 0x22, 0xF2, 0x7C, 0x66]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(17, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x43, 0x5E, 0x47, 0x29, 0x82, 0x0B, 0x9E, 0xF9, 0x67, 0x0D, 0xAC, 0xC0, 0x74, 0x44, 0x21, 0x15, 0x00, 0xC1, 0xF4, 0xA1, 0x81, 0x34, 0xB8, 0xFA, 0x1B, 0x08, 0x06, 0x70, 0x50, 0x69, 0x8D, 0x2F, 0xA1, 0x8B, 0x38, 0x27, 0xF5, 0xBE, 0x7D, 0xD0, 0x6B, 0x75, 0xAF, 0x49, 0xCA, 0x44, 0x27, 0x88, 0x0B, 0x47, 0xFA, 0x46, 0xE7, 0x4D, 0x48, 0xF4, 0x24, 0xED, 0x5C, 0x98, 0x1B, 0xE1, 0xB9, 0xBF]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(18, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x0F, 0xC8, 0x05, 0xC2, 0x82, 0x9B, 0x79, 0xF1, 0x5F, 0x34, 0xAC, 0x30, 0x80, 0x18, 0xC3, 0xE7, 0x34, 0xB1, 0x40, 0x05, 0xBE, 0x04, 0x73, 0xB1, 0x93, 0x78, 0xCE, 0x11, 0x51, 0x46, 0xA0, 0x94, 0x0D, 0xAE, 0x4D, 0xA3, 0x49, 0x90, 0x56, 0x37, 0xC3, 0x98, 0x1F, 0x68, 0xE4, 0x30, 0x04, 0x7A, 0xA3, 0x05, 0x6E, 0xEF, 0x32, 0x17, 0x41, 0x20, 0xD9, 0xDA, 0x49, 0xB2, 0xCF, 0x8C, 0x0E, 0xA7]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(19, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x2C, 0x7F, 0x53, 0xF2, 0xFD, 0x7C, 0xC9, 0x34, 0x2E, 0xBD, 0xB2, 0x6E, 0x82, 0x45, 0xBB, 0x9F, 0x29, 0x8D, 0x54, 0xB7, 0x4A, 0x7E, 0x7C, 0x60, 0x8E, 0x4E, 0xE6, 0xFD, 0x7A, 0x66, 0x08, 0xB6, 0x9E, 0xE7, 0x1B, 0x83, 0xD9, 0x63, 0x5C, 0x45, 0x7D, 0xD9, 0xD0, 0x5F, 0xE9, 0x09, 0x0F, 0xBA, 0x05, 0xE2, 0x49, 0xD4, 0x42, 0x18, 0xE9, 0x7D, 0x1B, 0x90, 0x5E, 0x4F, 0x08, 0x10, 0xA9, 0x12]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(20, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xF6, 0x65, 0x2E, 0x27, 0xAC, 0x1B, 0x27, 0x05, 0xB9, 0x0E, 0xAA, 0xC5, 0x1D, 0x79, 0xFE, 0x00, 0x09, 0x3F, 0xD0, 0xFA, 0x2D, 0xC6, 0x0E, 0x74, 0x37, 0x68, 0xB4, 0x74, 0x77, 0xE0, 0x12, 0x9A, 0x2F, 0xD2, 0x3E, 0x0F, 0xF6, 0x56, 0xF5, 0x6A, 0x39, 0xBA, 0x26, 0x0F, 0xA2, 0xD4, 0x5B, 0xB3, 0x5B, 0xA1, 0x06, 0x50, 0x7C, 0xF6, 0xA0, 0x02, 0x7F, 0x86, 0xC9, 0x2E, 0x01, 0x74, 0xDB, 0x1A]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(21, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C, 0x6C]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x7E, 0x1A, 0x2E, 0x71, 0x19, 0x9A, 0x17, 0xB0, 0xBB, 0x9A, 0x8B, 0x9B, 0x81, 0x02, 0xA9, 0xAD, 0xDA, 0x23, 0xAB, 0x46, 0x42, 0xAA, 0x19, 0x22, 0xB3, 0x34, 0xD0, 0xA6, 0xB5, 0xD6, 0x2F, 0x37, 0x10, 0x00, 0x55, 0xCC, 0xCC, 0x7D, 0x4D, 0x56, 0x94, 0xDE, 0x27, 0x45, 0x22, 0x1B, 0x6B, 0xDF, 0x02, 0xED, 0x1F, 0x56, 0xB8, 0x1B, 0xDD, 0xA0, 0x70, 0xC0, 0xE0, 0x96, 0x43, 0xFB, 0x31, 0xDE]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(22, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xEA, 0xD8, 0xFB, 0xE6, 0x3C, 0x18, 0x29, 0x04, 0xDD, 0x66, 0xED, 0xB3, 0x53, 0x79, 0x15, 0x03, 0x8D, 0xDE, 0xE8, 0xEE, 0xAA, 0xE4, 0x4F, 0x9D, 0xB8, 0x7D, 0xEF, 0x80, 0xD9, 0xDC, 0xFA, 0xA7, 0x10, 0x17, 0x33, 0x32, 0x58, 0xA8, 0xCA, 0xDA, 0x82, 0xD3, 0x52, 0x92, 0xA4, 0x8C, 0xB4, 0x9B, 0x48, 0x38, 0xD8, 0x4E, 0x0C, 0x95, 0xA1, 0x2B, 0xD5, 0xB9, 0x80, 0x5F, 0xE7, 0x26, 0xA8, 0x04]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(23, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x7C, 0xC8, 0x9F, 0xF6, 0xF0, 0xDF, 0x4C, 0x88, 0x34, 0x36, 0x22, 0x53, 0x5F, 0x87, 0x66, 0x88, 0x4F, 0xB2, 0xA2, 0x77, 0x60, 0xEC, 0x4E, 0xA0, 0xAC, 0xA7, 0x5C, 0xC5, 0x90, 0x7D, 0xB2, 0x54, 0xEE, 0x37, 0xDF, 0x12, 0xE5, 0xC8, 0x9C, 0xB0, 0xA7, 0x8A, 0x56, 0x92, 0x79, 0xBB, 0xCD, 0xB1, 0x21, 0xC3, 0x4E, 0xFB, 0xBA, 0xC3, 0x31, 0x10, 0x06, 0xA6, 0xDD, 0x01, 0xDC, 0x28, 0x36, 0xC3]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(24, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x01, 0xDA, 0x3D, 0xC2, 0xC0, 0x2D, 0xF6, 0xFF, 0x26, 0xDB, 0xAE, 0xFA, 0x1A, 0x6C, 0x27, 0x80, 0xA6, 0x6E, 0xCF, 0x53, 0x95, 0x27, 0xB0, 0xFD, 0xC7, 0x3D, 0x44, 0x68, 0x79, 0x8F, 0x7D, 0x80, 0xE1, 0x5E, 0x06, 0x33, 0xC9, 0xB7, 0x1A, 0x8A, 0x5A, 0x33, 0xEB, 0xA9, 0xE2, 0x9F, 0x90, 0x35, 0xE6, 0xBF, 0x12, 0x54, 0x17, 0xBE, 0x00, 0x3D, 0x4D, 0xD5, 0x04, 0x8C, 0x8D, 0xC6, 0x4B, 0xD8]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(25, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x6A, 0xB0, 0x80, 0x26, 0x57, 0x87, 0x6C, 0x8F, 0x72, 0x11, 0xB1, 0x4C, 0xE0, 0x5E, 0x78, 0x02, 0x4A, 0xA6, 0xD1, 0xE5, 0xF9, 0x74, 0x81, 0x5D, 0x39, 0x8D, 0x7B, 0xB9, 0xE1, 0x68, 0x55, 0xC3, 0x2F, 0xB8, 0x89, 0x6F, 0x57, 0xC4, 0x38, 0x28, 0xD1, 0xAE, 0x03, 0x4B, 0xAE, 0x3F, 0x42, 0xD6, 0x1D, 0x00, 0x60, 0x22, 0xC7, 0x11, 0x03, 0xED, 0xD1, 0x12, 0x5C, 0xC5, 0xEB, 0xFD, 0xBC, 0xE0]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(26, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xD6, 0xD2, 0x5A, 0x2B, 0xE8, 0x78, 0x98, 0xCE, 0x1F, 0xEC, 0xAF, 0xCE, 0x87, 0x70, 0xB1, 0x21, 0x4C, 0x71, 0x93, 0x24, 0x09, 0x39, 0xF2, 0x95, 0x45, 0xF7, 0x62, 0x78, 0xFC, 0xB1, 0x96, 0xD5, 0xB7, 0xD9, 0xCD, 0x12, 0xFC, 0x25, 0x3C, 0x49, 0x5B, 0xE6, 0x0E, 0x0E, 0x37, 0x07, 0x43, 0x8E, 0x2C, 0xB5, 0x42, 0x14, 0x89, 0x9B, 0xFA, 0xC8, 0xF5, 0x89, 0x5A, 0xC4, 0x39, 0xD2, 0x9F, 0x25]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(27, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xEA, 0x8B, 0xD0, 0x72, 0x0E, 0x56, 0x91, 0x61, 0xE9, 0xBD, 0x39, 0x96, 0x91, 0x51, 0x8E, 0x7A, 0x54, 0x83, 0x0A, 0x6B, 0x8E, 0xA5, 0x5F, 0xA0, 0x0C, 0x65, 0x1B, 0x00, 0xB1, 0xF1, 0xEA, 0x2E, 0xC6, 0x87, 0x41, 0x91, 0x0B, 0x8F, 0x03, 0x67, 0xB7, 0x98, 0x70, 0x24, 0xD8, 0x07, 0xDB, 0x8E, 0xC7, 0x01, 0x54, 0x62, 0xE6, 0xB5, 0x35, 0x78, 0xEF, 0x12, 0x9E, 0xE6, 0x74, 0x17, 0xBF, 0x01]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(28, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xE2, 0xED, 0x94, 0x61, 0xB7, 0x19, 0x15, 0x8E, 0x3F, 0x48, 0xD2, 0xD8, 0xCD, 0xAC, 0xA1, 0xA1, 0x36, 0x26, 0xA0, 0xBF, 0x92, 0xEC, 0xC9, 0xAB, 0x92, 0x72, 0xDA, 0x04, 0xC2, 0x84, 0xA6, 0x49, 0xA2, 0x28, 0xB3, 0x2C, 0x46, 0x07, 0xC6, 0xD0, 0xFD, 0xA5, 0x18, 0xEC, 0xD5, 0xD9, 0x54, 0x8C, 0x80, 0x44, 0xDC, 0xE2, 0x23, 0x6F, 0x0B, 0x94, 0x15, 0xBE, 0xF8, 0xBB, 0x0E, 0x41, 0x4E, 0xB6]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(29, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x73, 0x66, 0x40, 0xC5, 0x55, 0x21, 0x4B, 0x9D, 0x30, 0xC2, 0x68, 0xB8, 0xB6, 0x51, 0xF6, 0x14, 0xC8, 0x72, 0x43, 0x14, 0x62, 0x4A, 0x4F, 0xDB, 0xA7, 0x5D, 0x6D, 0xC8, 0xC1, 0x5D, 0xF9, 0x3B, 0xEB, 0x80, 0xE8, 0x32, 0x52, 0x18, 0xEA, 0x48, 0x91, 0x28, 0xBB, 0xFD, 0xA1, 0x9A, 0x64, 0x13, 0x95, 0x10, 0xDE, 0x9B, 0x6A, 0xC0, 0x06, 0xDF, 0x3B, 0x29, 0xCF, 0x7A, 0x67, 0x30, 0x16, 0xBF]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(30, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x7F, 0xE2, 0x6D, 0x4E, 0xD7, 0x62, 0xAC, 0x9D, 0x9C, 0x1D, 0x45, 0xDC, 0x11, 0x6A, 0x39, 0x3C, 0x1C, 0x98, 0xF3, 0xF7, 0x18, 0x1A, 0x81, 0x09, 0x47, 0x5C, 0x97, 0xAE, 0x3D, 0x5F, 0xAA, 0x38, 0x1F, 0x82, 0x86, 0xA5, 0x5A, 0x7A, 0x9A, 0x7E, 0xAD, 0x34, 0x9E, 0xB0, 0x35, 0x4E, 0x89, 0x14, 0x90, 0xF7, 0xEE, 0x0C, 0x54, 0x96, 0xE3, 0xFC, 0xF2, 0x17, 0xD1, 0xE7, 0x1A, 0x28, 0x63, 0x8A]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(31, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xCA, 0xCC, 0xB9, 0xA2, 0xE2, 0x8A, 0xA2, 0x2B, 0x80, 0x63, 0x4B, 0xBA, 0x85, 0x72, 0xF2, 0x7E, 0x8B, 0xBF, 0x72, 0xF7, 0x6F, 0x54, 0xFD, 0xF9, 0x3F, 0x66, 0x92, 0x82, 0x4A, 0xEB, 0x1D, 0x35, 0x96, 0x5A, 0xD3, 0x5E, 0xD0, 0x15, 0x71, 0x12, 0x5E, 0x6E, 0xA8, 0xDE, 0xEC, 0xC2, 0x12, 0x90, 0xF5, 0x30, 0x74, 0x8C, 0xB2, 0xB4, 0x3D, 0xF3, 0x40, 0x81, 0xA9, 0x3C, 0x8B, 0xA9, 0xF6, 0x52]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(32, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x91, 0x14, 0x6F, 0x16, 0x05, 0xC9, 0xF8, 0xB0, 0xB1, 0xBA, 0xA7, 0x1E, 0x77, 0xC6, 0x60, 0xBB, 0x77, 0x84, 0x63, 0x61, 0xF4, 0x32, 0x50, 0xC1, 0xF7, 0xAA, 0x9B, 0x56, 0x13, 0xE3, 0x92, 0x8F, 0x4D, 0x3A, 0xFE, 0xDF, 0x6A, 0x48, 0x9C, 0xC4, 0x71, 0xD3, 0x37, 0x54, 0x91, 0x34, 0xFC, 0xCB, 0xB5, 0x60, 0xA9, 0x9F, 0x27, 0x5B, 0xCF, 0x86, 0x04, 0xE0, 0x39, 0xA3, 0x38, 0x56, 0x6E, 0x32]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(33, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x9B, 0x45, 0x2E, 0x88, 0x53, 0x9B, 0x47, 0xCF, 0xE4, 0xAC, 0xC7, 0x71, 0x3C, 0x3C, 0xCB, 0x76, 0xD1, 0x5B, 0xBB, 0xF3, 0x6A, 0x82, 0x80, 0x91, 0x7D, 0x70, 0x1A, 0x9A, 0x51, 0x62, 0x04, 0xFF, 0x0D, 0x0A, 0x21, 0xA3, 0x8E, 0x62, 0x21, 0xE7, 0xE6, 0x4F, 0x41, 0x6A, 0x38, 0x1F, 0xE6, 0xE0, 0x48, 0xFA, 0xDF, 0x96, 0xED, 0x9E, 0x55, 0x99, 0xF5, 0xC0, 0x1D, 0x97, 0xD3, 0xE2, 0xC8, 0xFD]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(34, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE1]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x1D, 0x34, 0x75, 0x0D, 0x13, 0xD4, 0xC2, 0x8B, 0xE0, 0x3D, 0x95, 0x68, 0x8A, 0x98, 0xFB, 0x00, 0x0A, 0xE0, 0x65, 0xF9, 0x28, 0x9E, 0x5F, 0x48, 0xE0, 0x70, 0x11, 0x3A, 0x1F, 0xD2, 0xA7, 0xE5, 0x7F, 0xDB, 0xE7, 0x41, 0x0C, 0x40, 0xF4, 0xD3, 0x92, 0x40, 0x32, 0x49, 0x6F, 0x06, 0x9B, 0xD0, 0xFA, 0x9E, 0xD7, 0x24, 0x16, 0x32, 0xAB, 0x07, 0xF3, 0x12, 0xD8, 0xFA, 0xEA, 0xC3, 0x1C, 0x59]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(35, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x14, 0xB1, 0x06, 0x25, 0x91, 0xD3, 0x8C, 0x06, 0xD5, 0x0B, 0x0B, 0xDF, 0x05, 0xBA, 0x59, 0x4B, 0x8A, 0xDF, 0x25, 0x98, 0x14, 0x55, 0x94, 0xFC, 0x06, 0xAE, 0xBB, 0xC3, 0xC1, 0x80, 0x3A, 0x9F, 0x72, 0xB6, 0xD3, 0xA9, 0xBA, 0x54, 0x9B, 0x35, 0xE0, 0x1D, 0xC5, 0x2A, 0x8B, 0x14, 0xEC, 0x66, 0xDC, 0x70, 0xDC, 0xA3, 0xBD, 0xD9, 0x72, 0x8D, 0xFA, 0x03, 0x0E, 0xB1, 0xBC, 0x8C, 0x3E, 0xB8]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(36, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3, 0xF3]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x6F, 0x91, 0xE5, 0x0A, 0x18, 0x12, 0xC4, 0x2C, 0x60, 0x71, 0x1F, 0x10, 0x64, 0x4D, 0xF0, 0x0B, 0xC2, 0xC6, 0xD0, 0xEE, 0x78, 0xB1, 0xC0, 0xD8, 0x1E, 0x7F, 0xFD, 0x6A, 0xB4, 0xE2, 0xC6, 0x1F, 0xAC, 0x4A, 0x3E, 0xCF, 0x2C, 0x67, 0x65, 0x69, 0x3C, 0xF4, 0x12, 0xE7, 0x04, 0x35, 0x51, 0x18, 0x69, 0x82, 0xF0, 0x05, 0x1D, 0xD1, 0x82, 0x0B, 0xF9, 0xA8, 0xE5, 0x85, 0x11, 0xB4, 0xF1, 0xB1]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(37, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC, 0xFC]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x0F, 0x5E, 0x42, 0x87, 0x67, 0x22, 0xC2, 0x00, 0x40, 0x4C, 0xCF, 0xB4, 0x21, 0xC0, 0xFC, 0x7A, 0xB7, 0x8C, 0xA2, 0x98, 0xFF, 0xA9, 0x24, 0x3F, 0xD7, 0x61, 0x81, 0xFE, 0xE0, 0xC8, 0x06, 0xEC, 0xDB, 0x28, 0xBB, 0x29, 0x6E, 0xEA, 0xAC, 0xA1, 0xAA, 0xAD, 0x27, 0xBC, 0x5B, 0xC5, 0x2A, 0x25, 0x77, 0x79, 0xE1, 0x0A, 0x1F, 0xB2, 0xF6, 0xD1, 0xD6, 0x2D, 0xC8, 0xD9, 0x1B, 0xA6, 0x7F, 0xEA]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(38, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xD2, 0xA8, 0x74, 0x0B, 0xBA, 0x6F, 0xD9, 0x06, 0x70, 0x77, 0xF9, 0xAF, 0xC0, 0xC2, 0x7D, 0x40, 0x32, 0xB6, 0xAE, 0xAE, 0x50, 0xC4, 0x2E, 0xCE, 0xFF, 0x25, 0x5C, 0x58, 0x4C, 0x01, 0x43, 0xE7, 0x8C, 0xFA, 0x4E, 0x3E, 0xBE, 0x03, 0x07, 0x4F, 0x23, 0xD7, 0x62, 0xD0, 0xA7, 0x56, 0x35, 0x21, 0xBE, 0x75, 0x5B, 0x21, 0x66, 0xCD, 0x92, 0x0E, 0xEC, 0xBB, 0x5D, 0xB8, 0x47, 0x37, 0xFA, 0x01]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(39, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x18, 0x49, 0xD8, 0xF8, 0xD0, 0x0D, 0x4F, 0xD4, 0x9C, 0xA8, 0x25, 0xC4, 0x06, 0x54, 0xB4, 0x9A, 0xCD, 0x75, 0xDD, 0x14, 0x36, 0x61, 0xF0, 0x99, 0xA1, 0x29, 0x11, 0xE1, 0x4A, 0xFB, 0x9A, 0x35, 0xE6, 0xA1, 0x93, 0x03, 0x80, 0x9D, 0xE3, 0xB5, 0x95, 0x61, 0x78, 0xA9, 0xCC, 0x6E, 0x29, 0xA8, 0xCC, 0x97, 0xF1, 0xA3, 0xC4, 0x7A, 0xA3, 0x36, 0x0B, 0x48, 0x19, 0xAD, 0xDF, 0x4F, 0xFF, 0x7D]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(40, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xD2, 0x4D, 0x36, 0xA0, 0x7F, 0x26, 0xA0, 0x32, 0x80, 0xCE, 0x4C, 0x2A, 0x67, 0x1F, 0xC7, 0xB6, 0x17, 0xE9, 0x2D, 0x23, 0x1F, 0x64, 0x91, 0x28, 0xEB, 0x4D, 0x17, 0x07, 0x00, 0x03, 0xC8, 0xD3, 0x65, 0xDA, 0x16, 0x66, 0x2E, 0xFF, 0xA8, 0x76, 0x79, 0xE6, 0xC4, 0xE5, 0x57, 0xF8, 0x4E, 0x12, 0xE6, 0x9F, 0xB6, 0x5A, 0x49, 0x63, 0x94, 0xD3, 0x5D, 0xEC, 0xBC, 0x97, 0x14, 0xC1, 0x6B, 0xB1]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(41, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xCC, 0x84, 0xF1, 0x64, 0x80, 0x27, 0x15, 0xC0, 0x20, 0x42, 0x5A, 0x7F, 0xF6, 0x4C, 0x1A, 0x0B, 0x03, 0x3D, 0x52, 0xB9, 0x40, 0xAC, 0x2C, 0xC9, 0x1F, 0x07, 0x37, 0x59, 0x29, 0x51, 0x82, 0x6A, 0x76, 0xD1, 0x90, 0xB9, 0x26, 0x61, 0xE4, 0xFA, 0xD4, 0x75, 0x04, 0x51, 0xD6, 0xE3, 0x65, 0xCE, 0xFF, 0x04, 0x1F, 0xAB, 0x35, 0x8A, 0x09, 0xB5, 0xDD, 0xDA, 0xD4, 0xAA, 0xD6, 0xFA, 0x46, 0x0E]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(42, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x2D, 0xE8, 0xD0, 0xF2, 0xBC, 0x81, 0x76, 0xD6, 0x33, 0xCA, 0x10, 0x52, 0xE1, 0x55, 0x4C, 0x4D, 0x54, 0xA2, 0x11, 0x8E, 0x47, 0x76, 0x44, 0x52, 0x51, 0x19, 0x3C, 0xE6, 0xC1, 0xA4, 0x39, 0x59, 0x4D, 0xAE, 0x11, 0x26, 0xEF, 0x6A, 0x78, 0xE6, 0x2A, 0xA1, 0x9B, 0x84, 0x3B, 0xF6, 0x0D, 0xEC, 0x26, 0x1D, 0x6D, 0xA1, 0xEA, 0x64, 0xC1, 0x44, 0x9D, 0x83, 0xE8, 0x3D, 0x29, 0x26, 0x77, 0x47]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(43, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x0B, 0x4A, 0x17, 0x3B, 0x35, 0xC6, 0x70, 0x5A, 0x4D, 0xB9, 0x8C, 0x4D, 0x0F, 0xC7, 0x0B, 0x8F, 0x4C, 0x1E, 0xB7, 0x7A, 0x82, 0x3B, 0x55, 0x0C, 0x29, 0x67, 0x70, 0xF2, 0xC0, 0xCE, 0xED, 0x87, 0xB4, 0x7B, 0x66, 0xE8, 0x28, 0xCD, 0x39, 0x72, 0x36, 0x63, 0xD6, 0x05, 0x78, 0xC6, 0x76, 0xAB, 0x39, 0xAD, 0x5F, 0x3B, 0xE5, 0xD2, 0x67, 0x6E, 0x68, 0x5C, 0x11, 0x43, 0xBF, 0xF1, 0x9A, 0x52]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(44, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xBE, 0x00, 0x6E, 0xB1, 0x6B, 0x35, 0x54, 0xB2, 0xF3, 0xB4, 0x4E, 0x22, 0xF6, 0xFA, 0x65, 0x7A, 0x35, 0x67, 0xA9, 0xB6, 0x2F, 0x96, 0x13, 0x3F, 0x30, 0x0E, 0xD2, 0x84, 0x3A, 0xE6, 0xE5, 0x24, 0x7B, 0xAB, 0xD8, 0x52, 0x1C, 0x20, 0x99, 0xDF, 0x40, 0x80, 0xA5, 0x1B, 0x02, 0x2B, 0xC5, 0x3D, 0x88, 0x1B, 0xB6, 0x37, 0x66, 0x15, 0x0D, 0x26, 0xEA, 0x52, 0x58, 0xA1, 0xB4, 0x41, 0x2F, 0xBC]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(45, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x6A, 0x3E, 0x21, 0x5F, 0xD1, 0xA2, 0xA5, 0x5A, 0xEC, 0x4C, 0x84, 0xBB, 0x21, 0x64, 0x94, 0xFD, 0x81, 0xC1, 0x72, 0x79, 0xD1, 0x31, 0x52, 0x7A, 0x9F, 0xD4, 0xF3, 0xB0, 0x43, 0x50, 0xB0, 0xC7, 0x36, 0x5B, 0x37, 0x58, 0x27, 0x95, 0x0A, 0xD4, 0x5E, 0xE8, 0x38, 0x8E, 0x00, 0xF8, 0xA8, 0xFC, 0xF0, 0x21, 0xB3, 0xD6, 0x3F, 0xE0, 0x31, 0xA7, 0xCF, 0x4E, 0x8D, 0x0E, 0xB4, 0x6B, 0x01, 0x55]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(46, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x86, 0x3A, 0xFB, 0x90, 0x6F, 0x2A, 0x73, 0xDF, 0xCA, 0xDF, 0xBC, 0x47, 0xEE, 0xEE, 0x20, 0x31, 0xCE, 0xE0, 0xAF, 0x88, 0x47, 0x77, 0x78, 0x25, 0xAF, 0xD1, 0x41, 0xD8, 0x89, 0x7A, 0x9E, 0x96, 0xC5, 0xF9, 0x28, 0x4A, 0x39, 0x1C, 0xCE, 0xC3, 0x4A, 0x19, 0x9E, 0xE8, 0x22, 0x8B, 0x0B, 0x98, 0x1A, 0xDC, 0xC8, 0x59, 0xB9, 0x00, 0x87, 0x54, 0xD3, 0xD0, 0xB9, 0x9F, 0x13, 0x6E, 0xF4, 0xE9]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(47, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x25, 0x2C, 0x40, 0x21, 0xB2, 0xFE, 0x2C, 0x61, 0x76, 0x37, 0x6D, 0x4D, 0x90, 0x5D, 0xCC, 0x59, 0xC5, 0x02, 0x88, 0x4E, 0x87, 0xE2, 0xE2, 0x7F, 0x54, 0xAC, 0x46, 0xF3, 0x7B, 0x62, 0x23, 0x4B, 0x46, 0xC7, 0x86, 0x3F, 0x75, 0x43, 0x88, 0x84, 0xDB, 0x12, 0x4A, 0x3A, 0xAC, 0x25, 0x8D, 0x50, 0x61, 0x12, 0x75, 0xFF, 0xC8, 0xF2, 0x0F, 0xB9, 0x4E, 0x8F, 0xC4, 0x53, 0x06, 0xA7, 0xA8, 0x6E]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(48, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x34, 0xE3, 0x00, 0x06, 0xE6, 0x2A, 0xF3, 0x94, 0xAD, 0xF5, 0x04, 0x2E, 0xAF, 0x6F, 0x85, 0x98, 0x39, 0xF1, 0x3E, 0xD4, 0x51, 0x9A, 0xB0, 0xCE, 0xE2, 0x59, 0x0F, 0x93, 0xD8, 0x02, 0x01, 0x1E, 0x1C, 0x1F, 0x25, 0x78, 0x39, 0x05, 0x40, 0x60, 0xA5, 0x5B, 0x28, 0xBF, 0x15, 0x7E, 0xD8, 0xB5, 0xDD, 0x8E, 0x54, 0xE9, 0x24, 0x15, 0xAB, 0x12, 0x84, 0x4C, 0xAF, 0x90, 0x49, 0x8C, 0x20, 0x23]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(49, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x41, 0xDF, 0x60, 0x61, 0x20, 0xC6, 0x44, 0x78, 0x01, 0xEF, 0x9B, 0xCE, 0x34, 0xC6, 0x59, 0xFB, 0x18, 0x55, 0xA5, 0x9B, 0xF5, 0x75, 0x37, 0x9C, 0x34, 0xCA, 0x36, 0x4D, 0x02, 0x9C, 0x72, 0x2B, 0xDA, 0x10, 0x7F, 0x61, 0x92, 0x95, 0xD2, 0x12, 0xB7, 0xE2, 0x3F, 0x9C, 0xA0, 0x78, 0x8F, 0x85, 0xEB, 0xA7, 0x49, 0xFD, 0x9D, 0xAC, 0x94, 0x90, 0x29, 0x43, 0xAC, 0x65, 0xC7, 0x68, 0xB5, 0x79]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(50, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x4D, 0x0E, 0x81, 0x4E, 0xBB, 0xC4, 0x0E, 0x61, 0xB3, 0x30, 0xC8, 0xA4, 0x67, 0x8D, 0xEB, 0xF9, 0xFC, 0xED, 0x0C, 0x71, 0x29, 0x8E, 0x11, 0x59, 0xCB, 0x90, 0x3D, 0xEE, 0x6E, 0xBD, 0xC2, 0x94, 0xD9, 0xAC, 0x00, 0x44, 0x14, 0x38, 0x44, 0x1D, 0x61, 0xF6, 0x1F, 0xE4, 0x21, 0xC4, 0xF8, 0xA8, 0x39, 0xC7, 0x15, 0xB0, 0xA9, 0x08, 0x2F, 0xE8, 0x92, 0x1D, 0xB5, 0x1E, 0x14, 0xB1, 0x88, 0xDA]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(51, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x89, 0x58, 0xE8, 0xAC, 0xAC, 0x75, 0x56, 0x78, 0xCE, 0x2D, 0x4F, 0x5C, 0x48, 0x2A, 0xD7, 0x1A, 0xC7, 0xAF, 0xE4, 0xCF, 0x8E, 0x50, 0x62, 0x55, 0x59, 0x06, 0xEF, 0x8D, 0xEB, 0xBA, 0x30, 0xA6, 0xEB, 0xF0, 0x9D, 0x9F, 0xDF, 0xD2, 0xAC, 0xBD, 0xC4, 0x61, 0x91, 0x99, 0xBA, 0x95, 0xC6, 0xB6, 0xB1, 0x45, 0xD0, 0x84, 0xE6, 0x1B, 0x4E, 0xDF, 0x02, 0x69, 0x3D, 0xFC, 0x3D, 0xE7, 0x6A, 0x54]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(52, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xCA, 0xE3, 0xF9, 0x79, 0x4B, 0xE6, 0x05, 0x73, 0x9E, 0x8B, 0x13, 0x3E, 0x4D, 0xD9, 0x7A, 0xE0, 0x6D, 0x00, 0x78, 0x0A, 0x66, 0xF1, 0xBD, 0xC3, 0xB8, 0x56, 0xD1, 0x78, 0xD2, 0x63, 0xEC, 0x28, 0x2E, 0xC6, 0x77, 0x5E, 0x89, 0xB1, 0x5A, 0x42, 0x93, 0x07, 0x64, 0x3B, 0xAD, 0x60, 0x42, 0xCF, 0xFC, 0x24, 0x8E, 0x8D, 0x08, 0x24, 0x75, 0xFB, 0x5F, 0xFF, 0xF8, 0x4E, 0xC5, 0xE2, 0xF5, 0xC7]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(53, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xC2, 0x04, 0x86, 0x13, 0x94, 0xC3, 0xB2, 0x73, 0x01, 0xD2, 0xB2, 0x16, 0xAF, 0x74, 0xF0, 0x1B, 0x36, 0xCD, 0x63, 0xEA, 0xCC, 0x07, 0xA6, 0xFB, 0x8F, 0xB6, 0x09, 0x71, 0xF3, 0xC4, 0x16, 0x0C, 0x72, 0xE0, 0x09, 0xD7, 0x95, 0xB7, 0x4B, 0x9F, 0x82, 0x6B, 0x26, 0x4D, 0xFC, 0x1F, 0xFB, 0x9D, 0x33, 0x4C, 0xC9, 0xCA, 0x88, 0xC0, 0x30, 0x09, 0xB6, 0xAC, 0x5E, 0xD5, 0x9F, 0x70, 0xA2, 0x59]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(54, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x09, 0x72, 0xB6, 0xF8, 0xB7, 0xCE, 0xC5, 0x40, 0xEA, 0xF2, 0x30, 0xE2, 0x46, 0x5A, 0xC6, 0xA3, 0x05, 0xD7, 0x8A, 0x9E, 0x5C, 0xCB, 0xB3, 0x8A, 0x01, 0x3F, 0x66, 0x74, 0xA3, 0x6D, 0xFF, 0x22, 0x7E, 0x29, 0x27, 0x60, 0xC6, 0x37, 0x62, 0x9C, 0x3B, 0xEC, 0x82, 0xE5, 0x6A, 0xB5, 0x50, 0x90, 0x3E, 0x3D, 0x55, 0x9D, 0x16, 0x48, 0x46, 0x2B, 0x8E, 0x25, 0x35, 0xE2, 0xB2, 0x13, 0x2E, 0x3A]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(55, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x1C, 0x35, 0xDA, 0x85, 0x26, 0xE8, 0x4D, 0x18, 0xF9, 0xF3, 0x19, 0xDB, 0xC6, 0x48, 0x85, 0x48, 0xFF, 0xB3, 0xA4, 0x60, 0xDE, 0x4C, 0x70, 0xE8, 0xCD, 0x95, 0xEF, 0x7C, 0x0A, 0x34, 0x26, 0x20, 0xD7, 0x61, 0x19, 0xF1, 0x7C, 0x4E, 0x56, 0xB1, 0x72, 0x39, 0xFC, 0x17, 0x85, 0x46, 0x9A, 0x07, 0x0A, 0xE6, 0x8D, 0x91, 0x79, 0x31, 0xF7, 0x3E, 0x19, 0x09, 0x36, 0xD0, 0xB9, 0x18, 0xEE, 0x5B]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(56, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x41, 0x2A, 0xB1, 0xD1, 0x8E, 0x67, 0x5A, 0xE9, 0x62, 0x65, 0x53, 0x23, 0x5C, 0xB4, 0xEB, 0x93, 0x90, 0x69, 0x4F, 0x9E, 0x1B, 0x79, 0x3E, 0xA6, 0x4E, 0xE1, 0xEB, 0xB9, 0xCA, 0x31, 0x52, 0x92, 0xEE, 0x9A, 0xFE, 0x32, 0x82, 0x7F, 0xA7, 0x99, 0x3F, 0x35, 0x5F, 0x02, 0x6C, 0x87, 0x4E, 0xEB, 0x6B, 0x89, 0xEF, 0x05, 0xD0, 0xEB, 0xE2, 0xBC, 0x0D, 0x8C, 0xC7, 0xCC, 0xDF, 0x04, 0xA1, 0x77]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(57, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x01, 0xE7, 0x59, 0xB7, 0x1C, 0x1E, 0xB6, 0x9C, 0x81, 0x58, 0x06, 0x10, 0x00, 0x6B, 0xBA, 0x1A, 0xE6, 0x96, 0x2D, 0x7E, 0xD9, 0xFB, 0x6F, 0x80, 0x46, 0x11, 0xD2, 0x0D, 0xFB, 0xBE, 0x47, 0xF6, 0x25, 0x27, 0xB3, 0xF8, 0x10, 0x28, 0x76, 0xC5, 0x46, 0x7C, 0xB4, 0x84, 0x47, 0x23, 0xC9, 0x79, 0xCA, 0x4A, 0x91, 0xFD, 0xCF, 0xEC, 0x86, 0x37, 0x57, 0x8F, 0x7E, 0x46, 0xB8, 0x30, 0x1F, 0x10]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(58, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xA1, 0xC1, 0xEE, 0x5C, 0x63, 0xAB, 0x5C, 0x06, 0x55, 0xEB, 0x69, 0x57, 0xC4, 0xB6, 0xC8, 0x46, 0x58, 0x5A, 0x43, 0x2D, 0x6E, 0xE6, 0xF4, 0x26, 0x61, 0xB4, 0xEB, 0xDE, 0xA3, 0x63, 0xCA, 0x1E, 0xCB, 0x99, 0x50, 0xBD, 0x1C, 0x59, 0xB8, 0xD7, 0x5C, 0x13, 0x62, 0xE0, 0x76, 0x89, 0x58, 0xCE, 0x00, 0x47, 0x71, 0x53, 0x35, 0xDE, 0x0A, 0xCC, 0x42, 0x28, 0xB8, 0xEB, 0xE4, 0x01, 0x70, 0x36]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(59, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xB7, 0xBE, 0x8B, 0xF5, 0xD0, 0x2E, 0x37, 0x87, 0x1E, 0x62, 0x57, 0x09, 0x22, 0x32, 0xE6, 0xB4, 0x7D, 0xB4, 0x02, 0x6F, 0x9F, 0x52, 0x27, 0xF1, 0x09, 0x67, 0x31, 0xFC, 0x3C, 0xD6, 0x6A, 0xFA, 0x9B, 0x3D, 0x04, 0x52, 0x0B, 0xA8, 0x77, 0x85, 0xC4, 0x3F, 0x40, 0x1F, 0x40, 0x30, 0x27, 0x58, 0x19, 0x4B, 0xE4, 0x9C, 0xA8, 0xCF, 0x00, 0xA5, 0x8D, 0x99, 0x1F, 0x40, 0xB9, 0x66, 0x2F, 0x56]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(60, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x10, 0xFB, 0xD1, 0x33, 0x6E, 0x81, 0xB0, 0xD1, 0x49, 0xA9, 0xFD, 0x88, 0xCC, 0xA7, 0xDA, 0xA9, 0x17, 0xCC, 0xFF, 0x08, 0xB8, 0xB1, 0xD3, 0x67, 0x5C, 0x27, 0xFD, 0x62, 0x70, 0x13, 0x01, 0x34, 0xC2, 0x48, 0x47, 0xEC, 0xF7, 0xEE, 0x5C, 0x1D, 0xC0, 0x2E, 0x6E, 0x66, 0x34, 0xFF, 0x1E, 0xE2, 0xF0, 0x88, 0x9F, 0x60, 0x7F, 0x2A, 0xB0, 0x72, 0xDC, 0x81, 0x79, 0x9B, 0x8B, 0x86, 0x1D, 0x4E]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(61, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x90, 0xB1, 0x47, 0xBB, 0x4C, 0xE3, 0x84, 0x46, 0x64, 0xE7, 0x56, 0x78, 0xB7, 0x8F, 0x02, 0xC2, 0x92, 0x56, 0x87, 0xA9, 0x1C, 0x44, 0x81, 0x91, 0x8E, 0x87, 0x84, 0xEA, 0x4C, 0x51, 0xA6, 0x98, 0xD5, 0x2B, 0x2D, 0x16, 0xC6, 0xC2, 0xA8, 0xB5, 0x8C, 0x61, 0xA7, 0x78, 0x6E, 0x4A, 0x3B, 0xE7, 0x15, 0x68, 0x9B, 0xFE, 0x8E, 0x25, 0x1A, 0x46, 0xEB, 0xEE, 0xE2, 0xE4, 0x22, 0x05, 0x6F, 0x9C]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(62, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x1A, 0xDB, 0x5D, 0x07, 0xC8, 0x85, 0x93, 0x63, 0x94, 0xFD, 0xD0, 0x86, 0x66, 0x83, 0x0F, 0x5E, 0x3F, 0x30, 0xCD, 0xD1, 0xB9, 0x4D, 0x9B, 0x18, 0x04, 0x10, 0x8B, 0x79, 0xE5, 0x94, 0xD3, 0x91, 0x1E, 0x0D, 0x19, 0x5B, 0x80, 0x99, 0xE6, 0x76, 0x62, 0x77, 0xDE, 0x88, 0xA7, 0xC2, 0xB8, 0x10, 0x60, 0x94, 0xB6, 0x43, 0x59, 0xDD, 0xAD, 0x8B, 0x77, 0xE1, 0x99, 0x16, 0x7C, 0xFA, 0x13, 0x43]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(63, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xB6, 0x20, 0x61, 0x4F, 0x87, 0x44, 0x9D, 0xFE, 0x64, 0xBE, 0x90, 0xAE, 0x86, 0xF6, 0x12, 0x16, 0xE3, 0x42, 0x83, 0x84, 0x90, 0xC1, 0x08, 0x38, 0xAC, 0xFE, 0x1B, 0xDD, 0xF6, 0x48, 0x17, 0x63, 0x93, 0x6D, 0xA9, 0xE1, 0xFE, 0xB6, 0xDC, 0xB6, 0x35, 0x60, 0x5C, 0x94, 0xCC, 0xB0, 0xE1, 0x67, 0x96, 0x2B, 0x84, 0x03, 0x7C, 0xC2, 0x74, 0xEE, 0x96, 0x4D, 0xEE, 0xE4, 0x1C, 0xAF, 0x0F, 0x85]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(64, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x8E, 0x9E, 0x13, 0xAE, 0x97, 0xE1, 0x40, 0x98, 0xB9, 0xDF, 0x86, 0x72, 0xAE, 0x24, 0x52, 0x86, 0xCE, 0x43, 0x71, 0x59, 0x90, 0x5F, 0x02, 0x65, 0x15, 0x49, 0x8E, 0xCA, 0x6F, 0x91, 0x22, 0xB5, 0xEE, 0xD9, 0x0A, 0xF2, 0x33, 0x0D, 0xF4, 0x48, 0xD1, 0x8E, 0xE4, 0xD6, 0x38, 0xD8, 0xBE, 0xA3, 0xCB, 0xE9, 0x34, 0x97, 0x31, 0x9C, 0xFC, 0x8E, 0x5D, 0xD3, 0x87, 0xB6, 0x12, 0x91, 0x21, 0xC9]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(65, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xAE, 0xF7, 0x34, 0x17, 0xAE, 0x81, 0x20, 0xFE, 0x8B, 0x78, 0x5E, 0x0C, 0x66, 0x71, 0xC6, 0x89, 0xC5, 0x88, 0x92, 0xD3, 0x94, 0xE8, 0xAB, 0x8E, 0xF6, 0xB9, 0x26, 0x55, 0x8D, 0xCA, 0x31, 0xD0, 0xF9, 0x74, 0xE2, 0x6B, 0x13, 0xEA, 0xA4, 0x17, 0xD9, 0x32, 0xAA, 0x9A, 0x7B, 0xE2, 0x70, 0xFA, 0xF8, 0xAC, 0xCB, 0x4C, 0x0C, 0xBD, 0x39, 0x60, 0x40, 0xDD, 0xE6, 0xC9, 0x12, 0x49, 0x06, 0x43]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(66, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0xFC, 0xFD, 0xFE, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x49, 0x61, 0x91, 0xDC, 0x1E, 0xDC, 0x22, 0xDE, 0x84, 0x8E, 0x61, 0xCA, 0x62, 0x5E, 0x3A, 0x7A, 0xAA, 0x40, 0x7E, 0x45, 0x9D, 0xA4, 0x13, 0xBD, 0x1D, 0x19, 0x40, 0x1D, 0xC1, 0x31, 0x60, 0xAB, 0xF7, 0x4F, 0x38, 0x4A, 0x9D, 0xC9, 0x21, 0x15, 0x72, 0x13, 0x37, 0x3E, 0x26, 0x84, 0x79, 0xB5, 0x70, 0x9A, 0x13, 0x2C, 0x11, 0xC4, 0x79, 0x8C, 0x5B, 0x1D, 0x28, 0x5D, 0x95, 0x30, 0x8E, 0xAC]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(67, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x53, 0xA6, 0xF9, 0x4C, 0x9F, 0xF2, 0x45, 0x98, 0xEB]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xA1, 0x80, 0x96, 0x40, 0xCE, 0x79, 0xC5, 0x40, 0x80, 0x2F, 0x49, 0xD3, 0x20, 0x23, 0xB2, 0xEA, 0x8A, 0x39, 0x84, 0x28, 0xF4, 0xA5, 0xEF, 0xDB, 0x0A, 0x12, 0x4F, 0xDD, 0xF3, 0x9D, 0x23, 0xCE, 0xFE, 0x52, 0x57, 0xEE, 0x1B, 0xCA, 0xDC, 0x09, 0x54, 0x04, 0x91, 0x02, 0x82, 0x6E, 0x14, 0x4C, 0xA9, 0x6E, 0x65, 0xD4, 0xA1, 0x69, 0x82, 0x3F, 0xFF, 0x20, 0xE8, 0x32, 0x88, 0x0B, 0x7B, 0x8E]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(68, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x05, 0x58, 0xAB, 0xFE, 0x51, 0xA4, 0xF7, 0x4A, 0x9D, 0xF0]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x20, 0x36, 0x12, 0xE1, 0xD1, 0xF2, 0x2B, 0xD4, 0x73, 0x14, 0xE9, 0xC0, 0x3D, 0xDA, 0x5B, 0xB7, 0x57, 0x9F, 0x5C, 0x49, 0x99, 0x83, 0xA4, 0x81, 0xF8, 0xFE, 0x21, 0xC9, 0x49, 0x00, 0x93, 0xD5, 0xEC, 0x7C, 0x63, 0xFD, 0xAC, 0x95, 0xAD, 0x95, 0x37, 0xDC, 0x9E, 0x87, 0xCD, 0x14, 0x39, 0x88, 0xD9, 0x7B, 0xBC, 0xCD, 0xB9, 0xE3, 0x48, 0x51, 0x9D, 0x07, 0xDB, 0x0C, 0x43, 0xE4, 0xA0, 0x69]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(69, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x0A, 0x5D, 0xB0, 0x03, 0x56, 0xA9, 0xFC, 0x4F, 0xA2, 0xF5]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x22, 0xE1, 0xC6, 0x92, 0xC7, 0x6E, 0xE1, 0x98, 0x11, 0x3F, 0x84, 0xA3, 0xD7, 0x3B, 0x6C, 0x5A, 0x2E, 0xC7, 0xCB, 0x8B, 0x77, 0x5A, 0xA6, 0x87, 0x59, 0x47, 0x1E, 0xFC, 0x86, 0xB3, 0xFA, 0x32, 0x03, 0xBB, 0xED, 0x11, 0x81, 0x7C, 0xDF, 0xCC, 0x82, 0xFF, 0xDE, 0x2E, 0xA2, 0xFD, 0xE7, 0xD1, 0x46, 0x66, 0x36, 0x96, 0x36, 0xC6, 0x95, 0x8C, 0x89, 0x6B, 0xBA, 0xE5, 0xEB, 0x0C, 0x51, 0xC1]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(70, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x0F, 0x62, 0xB5, 0x08, 0x5B, 0xAE, 0x01, 0x54, 0xA7, 0xFA]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x12, 0x4B, 0x35, 0xE1, 0xF1, 0x61, 0xA9, 0xFF, 0xE3, 0xD6, 0x5A, 0x90, 0x41, 0xD5, 0x23, 0x5F, 0xA3, 0x65, 0x9D, 0xC9, 0xBE, 0x65, 0x9A, 0x47, 0xC1, 0x6A, 0x0C, 0x2E, 0x6A, 0x75, 0x19, 0xCE, 0x88, 0x92, 0x74, 0x4E, 0x88, 0xFD, 0xD4, 0x03, 0x23, 0x95, 0xC0, 0x2A, 0x07, 0xB7, 0xBB, 0xD6, 0xCF, 0x78, 0x0F, 0xCF, 0xAB, 0x6B, 0x17, 0x9E, 0x60, 0x8E, 0xC9, 0xB0, 0x7B, 0x9A, 0xE6, 0x1F]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(71, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xF8, 0x90, 0x17, 0x36, 0x64, 0x05, 0x49, 0xE3, 0xBA, 0x7D, 0x42, 0xEA, 0x2D, 0x07, 0xB9, 0xF4, 0x92, 0x33, 0xC1, 0x8D, 0x77, 0x30, 0x08, 0xBD, 0x75, 0x55, 0x85, 0xB1, 0xA8, 0xCB, 0xAB, 0x86, 0xC1, 0xE9, 0xA9, 0xB9, 0x1F, 0x1A, 0xD3, 0x34, 0x83, 0xFD, 0x6E, 0xE3, 0x69, 0x6D, 0x65, 0x9C, 0x93, 0x74, 0x26, 0x04, 0x56, 0xA3, 0x6A, 0xAE, 0x11, 0xF0, 0x33, 0xA5, 0x19, 0xCB, 0xD5, 0xD7]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(72, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xAC, 0xBB, 0x38, 0x68, 0x76, 0x65, 0x3D, 0x15, 0x01, 0x0D, 0xEF, 0xA7, 0xC6, 0x5B, 0x36, 0xD7, 0x01, 0xCF, 0xAF, 0x92, 0x7B, 0x41, 0x75, 0x50, 0xBE, 0x32, 0xD0, 0x44, 0x4A, 0x24, 0xDE, 0xB5, 0x89, 0x15, 0x9B, 0x96, 0x5C, 0x67, 0x40, 0x82, 0x3F, 0x6B, 0xDF, 0xC3, 0x78, 0x17, 0x4A, 0xE2, 0xF6, 0x64, 0xDC, 0xA0, 0xB6, 0x8C, 0x62, 0x1D, 0x27, 0x75, 0xBD, 0x13, 0xE6, 0xA7, 0x88, 0xDF]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(73, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x88, 0xBD, 0x48, 0x94, 0x5D, 0xEA, 0x0B, 0xEB, 0x94, 0xD1, 0xF1, 0x3F, 0xC5, 0x89, 0xD6, 0x1F, 0x49, 0x61, 0x04, 0x6D, 0x40, 0x54, 0xB2, 0xEC, 0x27, 0x47, 0x09, 0xDB, 0x1D, 0x8C, 0xC5, 0x47, 0x2D, 0x1C, 0xD0, 0x7D, 0x3C, 0xEB, 0xFC, 0x31, 0xE5, 0x6D, 0xFE, 0xD5, 0x80, 0x29, 0xE5, 0x98, 0xFB, 0x45, 0xD1, 0x95, 0x4B, 0x6C, 0x86, 0xC9, 0xCC, 0x5E, 0xF4, 0x22, 0xFF, 0xAD, 0xFE, 0x32]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(74, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x89, 0x07, 0x82, 0x47, 0x1E, 0x32, 0xE0, 0x42, 0xC1, 0x47, 0x67, 0x28, 0x5A, 0x9B, 0xBD, 0x89, 0x60, 0x5F, 0xEE, 0x5E, 0x38, 0xB9, 0xE7, 0x8E, 0x3D, 0x75, 0x08, 0x21, 0xAC, 0x7B, 0x48, 0x64, 0xA2, 0x8D, 0xA2, 0x7E, 0xB2, 0xEB, 0xBD, 0x64, 0x13, 0xCC, 0x6A, 0x50, 0x66, 0xE5, 0x24, 0x05, 0x06, 0xE3, 0xF3, 0x7C, 0x22, 0x87, 0x6A, 0x7E, 0x95, 0x57, 0xC6, 0xB1, 0xBE, 0x1C, 0xE3, 0x00]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(75, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x33, 0x39, 0x4D, 0x41, 0x64, 0x1D, 0x0D, 0x8E, 0x57, 0x78, 0xCB, 0x72, 0x2C, 0x14, 0x36, 0x30, 0x09, 0x23, 0xF4, 0x01, 0x94, 0xB9, 0x51, 0x21, 0x6F, 0xAA, 0x8B, 0xBE, 0x0A, 0x6E, 0xC7, 0xFC, 0x23, 0x72, 0x4F, 0x8D, 0xD4, 0xE4, 0xE9, 0x22, 0xF9, 0xD9, 0xB9, 0x95, 0x79, 0xC5, 0x76, 0x5D, 0xFC, 0x5A, 0x8C, 0x26, 0x8C, 0x1C, 0xAF, 0x0C, 0x11, 0x4C, 0xF8, 0x14, 0xDB, 0x22, 0x39, 0xD8]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(76, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0x27, 0x88, 0x2D, 0xB2, 0x65, 0xB8, 0x9E, 0x59, 0xAD, 0x89, 0x61, 0x18, 0x80, 0xFE, 0x6D, 0x12, 0x5A, 0x4E, 0x98, 0x74, 0x4C, 0x91, 0xCB, 0xFE, 0x17, 0x06, 0xE6, 0x5A, 0x0A, 0x00, 0xA1, 0xEE, 0x3C, 0x02, 0x00, 0x04, 0xAA, 0x28, 0x7E, 0xCC, 0x20, 0x9E, 0xA7, 0x76, 0x50, 0x45, 0x98, 0x40, 0xD7, 0x3B, 0xB2, 0x89, 0x48, 0x2C, 0x73, 0x2A, 0x02, 0x49, 0x41, 0xE7, 0x2E, 0x32, 0x44, 0xF0]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(77, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00]) | |
testVector = new Uint8Array([0xFD, 0xF2, 0x7A, 0x99, 0xD3, 0x14, 0x40, 0x24, 0xD2, 0x36, 0x3B, 0x98, 0x82, 0xD3, 0x6D, 0x82, 0xC5, 0x05, 0xDA, 0x7B, 0x71, 0x34, 0xC0, 0xD9, 0x3E, 0xA0, 0xC3, 0x5B, 0xC9, 0x09, 0xD9, 0x0E, 0xFB, 0x59, 0xB3, 0xE6, 0x31, 0xF7, 0x17, 0x29, 0x7C, 0x7E, 0xBD, 0x7F, 0xE4, 0xF2, 0x0F, 0xC2, 0x4E, 0x83, 0x8C, 0x36, 0x51, 0xB5, 0xB6, 0xAC, 0x38, 0x64, 0x8C, 0x4B, 0x79, 0x22, 0x8B, 0x3A]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(78, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00]) | |
testVector = new Uint8Array([0xAE, 0x7F, 0x06, 0x0A, 0xC8, 0xB0, 0x05, 0x1C, 0x1A, 0xCB, 0xCB, 0xB2, 0xE7, 0xF1, 0x0E, 0x6F, 0xAD, 0x4C, 0x98, 0x0F, 0xB8, 0x6F, 0x62, 0xFE, 0xAF, 0xCD, 0x73, 0x45, 0xD6, 0x24, 0x48, 0x5E, 0xC4, 0xD7, 0x77, 0x3C, 0x1F, 0xA4, 0x5F, 0xFA, 0x52, 0x34, 0xD2, 0x11, 0x4B, 0xD4, 0xC4, 0x8B, 0xC2, 0x57, 0xD7, 0x7B, 0xC5, 0x24, 0x51, 0x9B, 0xF0, 0x0E, 0x1E, 0x93, 0x47, 0xB1, 0x98, 0x58]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(79, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) | |
iv = new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]) | |
testVector = new Uint8Array([0x82, 0xE7, 0xFC, 0xB2, 0x19, 0x3D, 0xD7, 0xCC, 0xBD, 0xFB, 0x30, 0xE4, 0xA1, 0xBC, 0x74, 0x0E, 0x27, 0x56, 0xEF, 0x94, 0x67, 0x6A, 0x6D, 0x4B, 0x01, 0xB1, 0xDD, 0x2F, 0x2A, 0x33, 0x5B, 0xB6, 0xBC, 0xB8, 0x5B, 0x10, 0x86, 0xD6, 0xA3, 0x6B, 0xBA, 0x4F, 0x98, 0x48, 0x8F, 0x2A, 0x74, 0xB8, 0xF8, 0x5E, 0xFB, 0xFC, 0x80, 0x82, 0x34, 0x7B, 0xB8, 0xC7, 0x1B, 0x1B, 0xD8, 0x68, 0x2D, 0x1D]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(80, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x00, 0x53, 0xA6, 0xF9, 0x4C, 0x9F, 0xF2, 0x45, 0x98, 0xEB]) | |
iv = new Uint8Array([0x0D, 0x74, 0xDB, 0x42, 0xA9, 0x10, 0x77, 0xDE, 0x45, 0xAC]) | |
testVector = new Uint8Array([0xF4, 0xCD, 0x95, 0x4A, 0x71, 0x7F, 0x26, 0xA7, 0xD6, 0x93, 0x08, 0x30, 0xC4, 0xE7, 0xCF, 0x08, 0x19, 0xF8, 0x0E, 0x03, 0xF2, 0x5F, 0x34, 0x2C, 0x64, 0xAD, 0xC6, 0x6A, 0xBA, 0x7F, 0x8A, 0x8E, 0x6E, 0xAA, 0x49, 0xF2, 0x36, 0x32, 0xAE, 0x3C, 0xD4, 0x1A, 0x7B, 0xD2, 0x90, 0xA0, 0x13, 0x2F, 0x81, 0xC6, 0xD4, 0x04, 0x3B, 0x6E, 0x39, 0x7D, 0x73, 0x88, 0xF3, 0xA0, 0x3B, 0x5F, 0xE3, 0x58]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(81, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x05, 0x58, 0xAB, 0xFE, 0x51, 0xA4, 0xF7, 0x4A, 0x9D, 0xF0]) | |
iv = new Uint8Array([0x16, 0x7D, 0xE4, 0x4B, 0xB2, 0x19, 0x80, 0xE7, 0x4E, 0xB5]) | |
testVector = new Uint8Array([0xA8, 0x50, 0xA9, 0x70, 0xAB, 0xCF, 0x5F, 0x73, 0xBC, 0xC5, 0xDB, 0x76, 0xF6, 0xB5, 0xE8, 0x56, 0x36, 0x2F, 0x1B, 0x36, 0xAC, 0x49, 0x8D, 0x05, 0xC2, 0x0F, 0xBE, 0x77, 0x63, 0x59, 0x8D, 0xE1, 0xFD, 0x98, 0xB0, 0x3C, 0xC5, 0x40, 0x60, 0xE8, 0xC9, 0xC1, 0x9B, 0x16, 0x49, 0x0C, 0x66, 0x5C, 0x36, 0x36, 0xA0, 0x3B, 0xAB, 0x46, 0x65, 0x6A, 0x69, 0x5E, 0xD7, 0x5F, 0x0E, 0x65, 0x9F, 0x04]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(82, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x0A, 0x5D, 0xB0, 0x03, 0x56, 0xA9, 0xFC, 0x4F, 0xA2, 0xF5]) | |
iv = new Uint8Array([0x1F, 0x86, 0xED, 0x54, 0xBB, 0x22, 0x89, 0xF0, 0x57, 0xBE]) | |
testVector = new Uint8Array([0xDE, 0x94, 0x10, 0xC5, 0x13, 0x4B, 0xCB, 0xAD, 0xD0, 0xD2, 0xD9, 0x56, 0x84, 0xE8, 0x38, 0x18, 0x3B, 0x91, 0xB0, 0xE8, 0xC1, 0xFA, 0x17, 0x3C, 0x38, 0xF5, 0xB7, 0x51, 0x03, 0xAB, 0xF0, 0xB8, 0x54, 0x6E, 0xDD, 0xE2, 0x2D, 0x6B, 0xFB, 0x3B, 0xF1, 0xC0, 0x75, 0x4C, 0x6C, 0x42, 0x98, 0x2F, 0xAE, 0xA5, 0xA3, 0xBD, 0x03, 0xDA, 0xFC, 0x0D, 0x15, 0x86, 0xE3, 0x89, 0xB7, 0x8C, 0x58, 0x72]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(83, JSON.stringify(ct) === JSON.stringify(testVector)) | |
key = new Uint8Array([0x0F, 0x62, 0xB5, 0x08, 0x5B, 0xAE, 0x01, 0x54, 0xA7, 0xFA]) | |
iv = new Uint8Array([0x28, 0x8F, 0xF6, 0x5D, 0xC4, 0x2B, 0x92, 0xF9, 0x60, 0xC7]) | |
testVector = new Uint8Array([0xA4, 0x38, 0x6C, 0x6D, 0x76, 0x24, 0x98, 0x3F, 0xEA, 0x8D, 0xBE, 0x73, 0x14, 0xE5, 0xFE, 0x1F, 0x9D, 0x10, 0x20, 0x04, 0xC2, 0xCE, 0xC9, 0x9A, 0xC3, 0xBF, 0xBF, 0x00, 0x3A, 0x66, 0x43, 0x3F, 0x30, 0x89, 0xA9, 0x8F, 0xAD, 0x85, 0x12, 0xC4, 0x9D, 0x7A, 0xAB, 0xC0, 0x63, 0x9F, 0x90, 0xC5, 0xFF, 0xED, 0x06, 0xF9, 0xD3, 0x5A, 0xA8, 0xC8, 0x66, 0x30, 0xE7, 0x6A, 0x83, 0x8E, 0x26, 0xD7]) | |
cipher = new Trivium(key, iv) | |
ct = cipher.encrypt(pt) | |
console.log(84, JSON.stringify(ct) === JSON.stringify(testVector)) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment