325 lines
7.3 KiB
TypeScript
325 lines
7.3 KiB
TypeScript
function bufferXor(a: Buffer, b: Buffer) {
|
|
const length = Math.min(a.length, b.length)
|
|
const buffer = Buffer.alloc(length)
|
|
|
|
for (let i = 0; i < length; ++i) {
|
|
buffer[i] = a[i] ^ b[i]
|
|
}
|
|
|
|
return buffer
|
|
}
|
|
|
|
function asUInt32Array(buf: Buffer) {
|
|
const len = (buf.length / 4) | 0
|
|
const out: number[] = new Array(len)
|
|
|
|
for (let i = 0; i < len; i++) {
|
|
out[i] = buf.readUInt32BE(i * 4)
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
function cryptBlock(
|
|
M: number[],
|
|
keySchedule: number[],
|
|
SUB_MIX: number[][],
|
|
SBOX: number[],
|
|
nRounds: number
|
|
) {
|
|
const SUB_MIX0 = SUB_MIX[0]
|
|
const SUB_MIX1 = SUB_MIX[1]
|
|
const SUB_MIX2 = SUB_MIX[2]
|
|
const SUB_MIX3 = SUB_MIX[3]
|
|
|
|
let s0 = M[0] ^ keySchedule[0]
|
|
let s1 = M[1] ^ keySchedule[1]
|
|
let s2 = M[2] ^ keySchedule[2]
|
|
let s3 = M[3] ^ keySchedule[3]
|
|
let t0: number
|
|
let t1: number
|
|
let t2: number
|
|
let t3: number
|
|
let ksRow = 4
|
|
|
|
for (let round = 1; round < nRounds; round++) {
|
|
t0 =
|
|
SUB_MIX0[s0 >>> 24] ^
|
|
SUB_MIX1[(s1 >>> 16) & 0xff] ^
|
|
SUB_MIX2[(s2 >>> 8) & 0xff] ^
|
|
SUB_MIX3[s3 & 0xff] ^
|
|
keySchedule[ksRow++]
|
|
t1 =
|
|
SUB_MIX0[s1 >>> 24] ^
|
|
SUB_MIX1[(s2 >>> 16) & 0xff] ^
|
|
SUB_MIX2[(s3 >>> 8) & 0xff] ^
|
|
SUB_MIX3[s0 & 0xff] ^
|
|
keySchedule[ksRow++]
|
|
t2 =
|
|
SUB_MIX0[s2 >>> 24] ^
|
|
SUB_MIX1[(s3 >>> 16) & 0xff] ^
|
|
SUB_MIX2[(s0 >>> 8) & 0xff] ^
|
|
SUB_MIX3[s1 & 0xff] ^
|
|
keySchedule[ksRow++]
|
|
t3 =
|
|
SUB_MIX0[s3 >>> 24] ^
|
|
SUB_MIX1[(s0 >>> 16) & 0xff] ^
|
|
SUB_MIX2[(s1 >>> 8) & 0xff] ^
|
|
SUB_MIX3[s2 & 0xff] ^
|
|
keySchedule[ksRow++]
|
|
s0 = t0
|
|
s1 = t1
|
|
s2 = t2
|
|
s3 = t3
|
|
}
|
|
|
|
t0 =
|
|
((SBOX[s0 >>> 24] << 24) |
|
|
(SBOX[(s1 >>> 16) & 0xff] << 16) |
|
|
(SBOX[(s2 >>> 8) & 0xff] << 8) |
|
|
SBOX[s3 & 0xff]) ^
|
|
keySchedule[ksRow++]
|
|
t1 =
|
|
((SBOX[s1 >>> 24] << 24) |
|
|
(SBOX[(s2 >>> 16) & 0xff] << 16) |
|
|
(SBOX[(s3 >>> 8) & 0xff] << 8) |
|
|
SBOX[s0 & 0xff]) ^
|
|
keySchedule[ksRow++]
|
|
t2 =
|
|
((SBOX[s2 >>> 24] << 24) |
|
|
(SBOX[(s3 >>> 16) & 0xff] << 16) |
|
|
(SBOX[(s0 >>> 8) & 0xff] << 8) |
|
|
SBOX[s1 & 0xff]) ^
|
|
keySchedule[ksRow++]
|
|
t3 =
|
|
((SBOX[s3 >>> 24] << 24) |
|
|
(SBOX[(s0 >>> 16) & 0xff] << 16) |
|
|
(SBOX[(s1 >>> 8) & 0xff] << 8) |
|
|
SBOX[s2 & 0xff]) ^
|
|
keySchedule[ksRow++]
|
|
t0 = t0 >>> 0
|
|
t1 = t1 >>> 0
|
|
t2 = t2 >>> 0
|
|
t3 = t3 >>> 0
|
|
|
|
return [t0, t1, t2, t3]
|
|
}
|
|
|
|
// AES constants
|
|
const RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]
|
|
const G = (function () {
|
|
// Compute double table
|
|
const d = new Array(256)
|
|
for (let j = 0; j < 256; j++) {
|
|
if (j < 128) {
|
|
d[j] = j << 1
|
|
} else {
|
|
d[j] = (j << 1) ^ 0x11b
|
|
}
|
|
}
|
|
|
|
const SBOX: number[] = []
|
|
const INV_SBOX: number[] = []
|
|
const SUB_MIX: number[][] = [[], [], [], []]
|
|
const INV_SUB_MIX: number[][] = [[], [], [], []]
|
|
|
|
// Walk GF(2^8)
|
|
let x = 0
|
|
let xi = 0
|
|
for (let i = 0; i < 256; ++i) {
|
|
// Compute sbox
|
|
let sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)
|
|
sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63
|
|
SBOX[x] = sx
|
|
INV_SBOX[sx] = x
|
|
|
|
// Compute multiplication
|
|
const x2 = d[x]
|
|
const x4 = d[x2]
|
|
const x8 = d[x4]
|
|
|
|
// Compute sub bytes, mix columns tables
|
|
let t = (d[sx] * 0x101) ^ (sx * 0x1010100)
|
|
SUB_MIX[0][x] = (t << 24) | (t >>> 8)
|
|
SUB_MIX[1][x] = (t << 16) | (t >>> 16)
|
|
SUB_MIX[2][x] = (t << 8) | (t >>> 24)
|
|
SUB_MIX[3][x] = t
|
|
|
|
// Compute inv sub bytes, inv mix columns tables
|
|
t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)
|
|
INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8)
|
|
INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16)
|
|
INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24)
|
|
INV_SUB_MIX[3][sx] = t
|
|
|
|
if (x === 0) {
|
|
x = xi = 1
|
|
} else {
|
|
x = x2 ^ d[d[d[x8 ^ x2]]]
|
|
xi ^= d[d[xi]]
|
|
}
|
|
}
|
|
|
|
return {
|
|
SBOX,
|
|
INV_SBOX,
|
|
SUB_MIX,
|
|
INV_SUB_MIX,
|
|
}
|
|
})()
|
|
|
|
class AES {
|
|
private _key: number[]
|
|
private _nRounds!: number
|
|
private _invKeySchedule!: number[]
|
|
|
|
constructor(key: Buffer) {
|
|
this._key = asUInt32Array(key)
|
|
this._reset()
|
|
}
|
|
|
|
_reset() {
|
|
const keyWords = this._key
|
|
const keySize = keyWords.length
|
|
const nRounds = keySize + 6
|
|
const ksRows = (nRounds + 1) * 4
|
|
|
|
const keySchedule: number[] = []
|
|
for (let k = 0; k < keySize; k++) {
|
|
keySchedule[k] = keyWords[k]
|
|
}
|
|
|
|
for (let k = keySize; k < ksRows; k++) {
|
|
let t = keySchedule[k - 1]
|
|
|
|
if (k % keySize === 0) {
|
|
t = (t << 8) | (t >>> 24)
|
|
t =
|
|
(G.SBOX[t >>> 24] << 24) |
|
|
(G.SBOX[(t >>> 16) & 0xff] << 16) |
|
|
(G.SBOX[(t >>> 8) & 0xff] << 8) |
|
|
G.SBOX[t & 0xff]
|
|
|
|
t ^= RCON[(k / keySize) | 0] << 24
|
|
} else if (keySize > 6 && k % keySize === 4) {
|
|
t =
|
|
(G.SBOX[t >>> 24] << 24) |
|
|
(G.SBOX[(t >>> 16) & 0xff] << 16) |
|
|
(G.SBOX[(t >>> 8) & 0xff] << 8) |
|
|
G.SBOX[t & 0xff]
|
|
}
|
|
|
|
keySchedule[k] = keySchedule[k - keySize] ^ t
|
|
}
|
|
|
|
const invKeySchedule = []
|
|
for (let ik = 0; ik < ksRows; ik++) {
|
|
const ksR = ksRows - ik
|
|
const tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]
|
|
|
|
if (ik < 4 || ksR <= 4) {
|
|
invKeySchedule[ik] = tt
|
|
} else {
|
|
invKeySchedule[ik] =
|
|
G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^
|
|
G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^
|
|
G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^
|
|
G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]
|
|
}
|
|
}
|
|
|
|
this._nRounds = nRounds
|
|
this._invKeySchedule = invKeySchedule
|
|
}
|
|
|
|
decryptBlock(buffer: Buffer) {
|
|
const M = asUInt32Array(buffer)
|
|
|
|
// swap
|
|
const m1 = M[1]
|
|
M[1] = M[3]
|
|
M[3] = m1
|
|
|
|
const out = cryptBlock(
|
|
M,
|
|
this._invKeySchedule,
|
|
G.INV_SUB_MIX,
|
|
G.INV_SBOX,
|
|
this._nRounds
|
|
)
|
|
|
|
const buf = Buffer.allocUnsafe(16)
|
|
buf.writeUInt32BE(out[0], 0)
|
|
buf.writeUInt32BE(out[3], 4)
|
|
buf.writeUInt32BE(out[2], 8)
|
|
buf.writeUInt32BE(out[1], 12)
|
|
return buf
|
|
}
|
|
|
|
static blockSize = 4 * 4
|
|
static keySize = 256 / 8
|
|
}
|
|
|
|
class Decipher {
|
|
private _cipher: AES
|
|
private _prev: Buffer
|
|
private _cache = new Splitter()
|
|
|
|
constructor(key: Buffer, iv: Buffer) {
|
|
this._cipher = new AES(key)
|
|
this._prev = Buffer.from(iv)
|
|
}
|
|
|
|
update(data: Buffer) {
|
|
this._cache.add(data)
|
|
let chunk: Buffer | null
|
|
let thing: Buffer
|
|
const out: Buffer[] = []
|
|
while ((chunk = this._cache.get())) {
|
|
thing = this.cbc_decrypt(chunk)
|
|
out.push(thing)
|
|
}
|
|
return Buffer.concat(out)
|
|
}
|
|
|
|
setAutoPadding(setTo: boolean) {
|
|
return this
|
|
}
|
|
|
|
cbc_decrypt(block: Buffer) {
|
|
const pad = this._prev
|
|
|
|
this._prev = block
|
|
const out = this._cipher.decryptBlock(block)
|
|
|
|
return bufferXor(out, pad)
|
|
}
|
|
}
|
|
|
|
class Splitter {
|
|
cache = Buffer.allocUnsafe(0)
|
|
|
|
add(data: Buffer) {
|
|
this.cache = Buffer.concat([this.cache, data])
|
|
}
|
|
|
|
get() {
|
|
if (this.cache.length >= 16) {
|
|
const out = this.cache.slice(0, 16)
|
|
this.cache = this.cache.slice(16)
|
|
return out
|
|
}
|
|
return null
|
|
}
|
|
}
|
|
|
|
export function createDecipheriv(_suite: any, password: Buffer, iv: Buffer) {
|
|
if (iv.length !== 16) {
|
|
throw new TypeError(`invalid iv length ${iv.length}`)
|
|
}
|
|
if (password.length !== 256 / 8) {
|
|
throw new TypeError(`invalid key length ${password.length}`)
|
|
}
|
|
return new Decipher(password, iv)
|
|
}
|