Skip to content

Commit

Permalink
docs: improve docs for functions
Browse files Browse the repository at this point in the history
  • Loading branch information
@li0ard
li0ard committed Mar 2, 2025
1 parent 25835e9 commit b9dc9bd
Show file tree
Hide file tree
Showing 3 changed files with 82 additions and 48 deletions.
42 changes: 21 additions & 21 deletions src/crapto1.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,11 +6,11 @@ import { bebit, binsearch, bit, evenParity32, extend_table, extend_table_simple,
/**
* Rollback the shift register in order to get previous states (for bits)
* @param s State
* @param in_ Input bit
* @param input Input bit
* @param isEncrypted Is input bit encrypted?
* @returns {number}
* @returns {number} LFSR output bit
*/
export const lfsr_rollback_bit = (s: Crypto1State, in_: number, isEncrypted: boolean = false): number => {
export const lfsr_rollback_bit = (s: Crypto1State, input: number, isEncrypted: boolean = false): number => {
let ret: number;
let t: number;
s.odd &= 0xffffff;
Expand All @@ -20,7 +20,7 @@ export const lfsr_rollback_bit = (s: Crypto1State, in_: number, isEncrypted: boo
let out = s.even & 1;
out ^= LF_POLY_EVEN & (s.even >>= 1);
out ^= LF_POLY_ODD & s.odd;
out ^= (in_ !== 0) ? 1 : 0;
out ^= (input !== 0) ? 1 : 0;
out ^= (ret = s.peekCrypto1Bit) & ((isEncrypted) ? 1 : 0);
s.even |= parity(out) << 23;
return ret;
Expand All @@ -29,39 +29,39 @@ export const lfsr_rollback_bit = (s: Crypto1State, in_: number, isEncrypted: boo
/**
* Rollback the shift register in order to get previous states (for bytes)
* @param s State
* @param in_ Input byte
* @param input Input byte
* @param isEncrypted Is input byte encrypted?
* @returns {number}
* @returns {number} LFSR output byte
*/
export const lfsr_rollback_byte = (s: Crypto1State, in_: number, isEncrypted: boolean = false): number => {
export const lfsr_rollback_byte = (s: Crypto1State, input: number, isEncrypted: boolean = false): number => {
let ret: number = 0;
for (let i = 7; i >= 0; --i) {
ret |= lfsr_rollback_bit(s, bit(in_, i), isEncrypted) << i;
ret |= lfsr_rollback_bit(s, bit(input, i), isEncrypted) << i;
}
return ret;
}

/**
* Rollback the shift register in order to get previous states (for words (uint32))
* @param s State
* @param in_ Input word
* @param input Input word
* @param isEncrypted Is input word encrypted?
* @returns {number}
* @returns {number} LFSR output word
*/
export const lfsr_rollback_word = (s: Crypto1State, in_: number, isEncrypted: boolean = false): number => {
export const lfsr_rollback_word = (s: Crypto1State, input: number, isEncrypted: boolean = false): number => {
let ret: number = 0;
for (let i = 31; i >= 0; --i) {
ret |= lfsr_rollback_bit(s, bebit(in_, i), isEncrypted) << (i ^ 24);
ret |= lfsr_rollback_bit(s, bebit(input, i), isEncrypted) << (i ^ 24);
}
return ret;
}

/** Recursively narrow down the search space, 4 bits of keystream at a time */
const recover = (odd: number[], o_head: number, o_tail: number, oks: number, even: number[], e_head: number, e_tail: number, eks: number, rem: number, sl: Crypto1State[], s: number, in_: number): number => {
const recover = (odd: number[], o_head: number, o_tail: number, oks: number, even: number[], e_head: number, e_tail: number, eks: number, rem: number, sl: Crypto1State[], s: number, input: number): number => {
let o: number, e: number, i: number;
if (rem === -1) {
for (e = e_head; e <= e_tail; ++e) {
even[e] = even[e] << 1 ^ parity(even[e] & LF_POLY_EVEN) ^ (((in_ & 4) !== 0) ? 1 : 0);
even[e] = even[e] << 1 ^ parity(even[e] & LF_POLY_EVEN) ^ (((input & 4) !== 0) ? 1 : 0);
for (o = o_head; o <= o_tail; ++o, ++s) {
sl[s].even = odd[o];
sl[s].odd = even[e] ^ parity(odd[o] & LF_POLY_ODD);
Expand All @@ -73,10 +73,10 @@ const recover = (odd: number[], o_head: number, o_tail: number, oks: number, eve
for (i = 0; (i < 4) && (rem-- !== 0); i++) {
oks >>>= 1;
eks >>>= 1;
in_ >>>= 2;
input >>>= 2;
o_tail = extend_table(odd, o_head, o_tail, oks & 1, LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0);
if (o_head > o_tail) return s;
e_tail = extend_table(even, e_head, e_tail, eks & 1, LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, in_ & 3);
e_tail = extend_table(even, e_head, e_tail, eks & 1, LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, input & 3);
if (e_head > e_tail) return s;
}
quicksort(odd, o_head, o_tail);
Expand All @@ -85,7 +85,7 @@ const recover = (odd: number[], o_head: number, o_tail: number, oks: number, eve
if (((odd[o_tail] ^ even[e_tail]) >>> 24) === 0) {
o_tail = binsearch(odd, o_head, o = o_tail);
e_tail = binsearch(even, e_head, e = e_tail);
s = recover(odd, o_tail--, o, oks, even, e_tail--, e, eks, rem, sl, s, in_);
s = recover(odd, o_tail--, o, oks, even, e_tail--, e, eks, rem, sl, s, input);
} else if ((odd[o_tail] ^ 0x80000000) > (even[e_tail] ^ 0x80000000)) {
o_tail = binsearch(odd, o_head, o_tail) - 1;
} else {
Expand All @@ -98,10 +98,10 @@ const recover = (odd: number[], o_head: number, o_tail: number, oks: number, eve
/**
* Recovery possible states from keystream from two's partial auth's
* @param ks2 Keystream (32 -> 63)
* @param in_ Input
* @param input Value that was fed into lfsr at time keystream was generated
* @returns {Crypto1State[]}
*/
export const lfsr_recovery32 = (ks2: number, in_: number): Crypto1State[] => {
export const lfsr_recovery32 = (ks2: number, input: number): Crypto1State[] => {
const statelist: Crypto1State[] = Array.from({ length: 1 << 18 }, () => new Crypto1State());
let stl: number = 0;
const odd: number[] = Array(1 << 21).fill(0);
Expand Down Expand Up @@ -132,8 +132,8 @@ export const lfsr_recovery32 = (ks2: number, in_: number): Crypto1State[] => {
even_tail = extend_table_simple(even, even_tail, (eks >>>= 1) & 1);
}

in_ = (in_ >>> 16 & 0xff) | (in_ << 16) | (in_ & 0xff00);
recover(odd, odd_head, odd_tail, oks, even, even_head, even_tail, eks, 11, statelist, 0, in_ << 1);
input = (input >>> 16 & 0xff) | (input << 16) | (input & 0xff00);
recover(odd, odd_head, odd_tail, oks, even, even_head, even_tail, eks, 11, statelist, 0, input << 1);
return statelist;
}

Expand Down
18 changes: 9 additions & 9 deletions src/crypto1.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,45 +21,45 @@ export const prng_successor = (x: number, n: number): number => {
/**
* Generate keystream for words (uint32)
* @param s State
* @param in_ Input word
* @param input Input word
* @param isEncrypted Is input word encrypted?
* @returns {number}
*/
export const crypto1_word = (s: Crypto1State, in_: number, isEncrypted: boolean = false): number => {
export const crypto1_word = (s: Crypto1State, input: number, isEncrypted: boolean = false): number => {
let i: number, ret: number = 0;
for (i = 0; i < 32; ++i) {
ret |= crypto1_bit(s, bebit(in_, i), isEncrypted) << (i ^ 24);
ret |= crypto1_bit(s, bebit(input, i), isEncrypted) << (i ^ 24);
}
return ret;
}

/**
* Generate keystream for bytes
* @param s State
* @param in_ Input byte
* @param input Input byte
* @param isEncrypted Is input byte encrypted?
* @returns {number}
*/
export const crypto1_byte = (s: Crypto1State, in_: number, isEncrypted: boolean = false): number => {
export const crypto1_byte = (s: Crypto1State, input: number, isEncrypted: boolean = false): number => {
let i: number, ret: number = 0;
for (i = 0; i < 8; ++i) {
ret |= crypto1_bit(s, bit(in_, i), isEncrypted) << i;
ret |= crypto1_bit(s, bit(input, i), isEncrypted) << i;
}
return ret;
}

/**
* Generate keystream for bits
* @param s State
* @param in_ Input bit
* @param input Input bit
* @param isEncrypted Is input bit encrypted?
* @returns {number}
*/
export const crypto1_bit = (s: Crypto1State, in_: number, isEncrypted: boolean = false): number => {
export const crypto1_bit = (s: Crypto1State, input: number, isEncrypted: boolean = false): number => {
let feedin: number;
let ret: number = filter(s.odd);
feedin = ret & ((isEncrypted) ? 1 : 0);
feedin ^= ((in_ !== 0) ? 1 : 0);
feedin ^= ((input !== 0) ? 1 : 0);
feedin ^= LF_POLY_ODD & s.odd;
feedin ^= LF_POLY_EVEN & s.even;
s.even = s.even << 1 | parity(feedin);
Expand Down
70 changes: 52 additions & 18 deletions src/utils.ts
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
/**
* Get bit from number by index
* Get bit of `num` at position `index`
* @param num Number
* @param index Index
* @returns {number}
Expand All @@ -9,7 +9,7 @@ export const bit = (num: number, index: number): number => {
}

/**
* Get bit from Crypto-1 word (uint32) by index
* Get bit of reversed endian 32-bit `num` at position `index`
* @param num Word
* @param index Index
* @returns {number}
Expand All @@ -19,6 +19,8 @@ export const bebit = (num: number, index: number): number => {
}

/**
* Filter function of Crypto1.
*
* Compute one bit of keystream from LFSR bits
* @param x LFSR bits
* @returns {number}
Expand Down Expand Up @@ -89,6 +91,11 @@ export const quicksort = (data: number[], start: number, stop: number): void =>

/**
* Helper, calculates the partial linear feedback contributions and puts in MSB
* @param data Input number
* @param item Input index
* @param mask1
* @param mask2
* @returns {void}
*/
export const update_contribution = (data: number[], item: number, mask1: number, mask2: number): void => {
let p: number = data[item] >>> 25;
Expand All @@ -98,45 +105,57 @@ export const update_contribution = (data: number[], item: number, mask1: number,
}

/**
* Using a bit of the keystream extend the table of possible lfsr states
* Using a bit of the keystream extend the table of possible lfsr states (complex version)
* @param data Result table
* @param tbl Array of even/odd bits of lfsr
* @param size Size of array
* @param bit Bit of keystream
* @param m1 mask1
* @param m2 mask2
* @param input Value that was fed into lfsr at time keystream was generated
* @returns {number}
*/
export const extend_table = (data: number[], tbl: number, end: number, bit: number, m1: number, m2: number, in_: number): number => {
in_ <<= 24;
for (data[tbl] <<= 1; tbl <= end; data[++tbl] <<= 1) {
export const extend_table = (data: number[], tbl: number, size: number, bit: number, m1: number, m2: number, input: number): number => {
input <<= 24;
for (data[tbl] <<= 1; tbl <= size; data[++tbl] <<= 1) {
if ((filter(data[tbl]) ^ filter(data[tbl] | 1)) !== 0) {
data[tbl] |= filter(data[tbl]) ^ bit;
update_contribution(data, tbl, m1, m2);
data[tbl] ^= in_;
data[tbl] ^= input;
} else if (filter(data[tbl]) === bit) {
data[++end] = data[tbl + 1];
data[++size] = data[tbl + 1];
data[tbl + 1] = data[tbl] | 1;
update_contribution(data, tbl, m1, m2);
data[tbl++] ^= in_;
data[tbl++] ^= input;
update_contribution(data, tbl, m1, m2);
data[tbl] ^= in_;
data[tbl] ^= input;
} else {
data[tbl--] = data[end--];
data[tbl--] = data[size--];
}
}
return end;
return size;
}

/**
* Using a bit of the keystream extend the table of possible lfsr states
* Using a bit of the keystream extend the table of possible lfsr states (simple version)
* @param tbl Array of even/odd bits of lfsr
* @param size Size of array
* @param bit Bit of keystream
* @returns {number}
*/
export const extend_table_simple = (tbl: number[], end: number, bit: number): number => {
export const extend_table_simple = (tbl: number[], size: number, bit: number): number => {
let i = 0;
for (tbl[i] <<= 1; i <= end; tbl[++i] <<= 1) {
for (tbl[i] <<= 1; i <= size; tbl[++i] <<= 1) {
if ((filter(tbl[i]) ^ filter(tbl[i] | 1)) !== 0) {
tbl[i] |= filter(tbl[i]) ^ bit;
} else if (filter(tbl[i]) === bit) {
tbl[++end] = tbl[++i];
tbl[++size] = tbl[++i];
tbl[i] = tbl[i - 1] | 1;
} else {
tbl[i--] = tbl[end--];
tbl[i--] = tbl[size--];
}
}
return end;
return size;
}

export const oddByteParity: number[] = [
Expand All @@ -158,14 +177,29 @@ export const oddByteParity: number[] = [
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
]

/**
* Return odd parity of unsigned 8-bit `x`
* @param x Number
* @returns {number}
*/
export const oddParity8 = (x: number): number => {
return oddByteParity[x];
}

/**
* Return even parity of unsigned 8-bit `x`
* @param x Number
* @returns {number}
*/
export const evenParity8 = (x: number): number => {
return oddParity8(x) ^ 1;
}

/**
* Return even parity of unsigned 32-bit `x`
* @param x Number
* @returns {number}
*/
export const evenParity32 = (x: number): number => {
x ^= x >> 16;
x ^= x >> 8;
Expand Down

0 comments on commit b9dc9bd

Please sign in to comment.