@li0ard/crapto1_ts/dist/crapto1.d.ts

Crapto1 TypeScript implement

import { Crypto1State } from "./state";
/**
 * Rollback the shift register in order to get previous states (for bits)
 * @param s State
 * @param input Input bit
 * @param isEncrypted Is input bit encrypted?
 * @returns {number} LFSR output bit
 */
export declare const lfsr_rollback_bit: (s: Crypto1State, input: number, isEncrypted?: boolean) => number;
/**
 * Rollback the shift register in order to get previous states (for bytes)
 * @param s State
 * @param input Input byte
 * @param isEncrypted Is input byte encrypted?
 * @returns {number} LFSR output byte
 */
export declare const lfsr_rollback_byte: (s: Crypto1State, input: number, isEncrypted?: boolean) => number;
/**
 * Rollback the shift register in order to get previous states (for words (uint32))
 * @param s State
 * @param input Input word
 * @param isEncrypted Is input word encrypted?
 * @returns {number} LFSR output word
 */
export declare const lfsr_rollback_word: (s: Crypto1State, input: number, isEncrypted?: boolean) => number;
/**
 * Recovery possible states from keystream from two's partial auth's
 * @param ks2 Keystream (32 -> 63)
 * @param input Value that was fed into lfsr at time keystream was generated
 * @returns {Crypto1State[]}
 */
export declare const lfsr_recovery32: (ks2: number, input: number) => Crypto1State[];
/**
 * Recovery possible states from keystreams from one full auth
 * @param ks2 Keystream (32 -> 63)
 * @param ks3 Keystream (64 -> 95)
 * @returns {Crypto1State[]}
 */
export declare const lfsr_recovery64: (ks2: number, ks3: number) => Crypto1State[];
/**
 * Recovery by two sets of 32 bit keystream authentication
 * @param uid UID
 * @param chal Tag challenge #1 (aka `nt`)
 * @param rchal Reader challenge #1 (aka `{nr_0}`)
 * @param rresp Reader response #1 (aka `{ar_0}`)
 * @param chal2 Tag challenge #2 (aka `nt1`)
 * @param rchal2 Reader challenge #2 (aka `{nr_1}`)
 * @param rresp2 Reader response #2 (aka `{ar_1}`)
 * @returns {bigint}
 */
export declare const recovery32: (uid: number, chal: number, rchal: number, rresp: number, chal2: number, rchal2: number, rresp2: number) => bigint;
/**
 * Recovery by one set of full 64 bit keystream authentication
 * @param uid UID
 * @param chal Tag challenge (aka `nt`)
 * @param rchal Reader challenge (aka `{nr}`)
 * @param rresp Reader response (aka `{ar}`)
 * @param tresp Tag response (aka `{at}`)
 * @returns {bigint}
 */
export declare const recovery64: (uid: number, chal: number, rchal: number, rresp: number, tresp: number) => bigint;
/**
 * Recovery by partial nested authentication
 *
 * @author doegox
 * @param uid UID
 * @param chal Tag challenge (aka `nt`)
 * @param enc_chal Encrypted tag challenge (aka `{nt}`)
 * @param rchal Reader challenge (aka `{nr}`)
 * @param rresp Reader response (aka `{ar}`)
 * @returns {bigint}
 */
export declare const recoveryNested: (uid: number, chal: number, enc_chal: number, rchal: number, rresp: number) => bigint;
/**
 * Recover key from tags with static nonce
 * @param uid UID
 * @param keyType Key type (`0x60` - Key A; `0x61` - Key B)
 * @param atks Nonce logs of authentication
 * @returns {bigint[]} Candidates keys
 */
export declare const staticNestedAttack: (uid: number, keyType: 96 | 97, atks: Array<{
    nt1: number;
    nt2: number;
}>) => bigint[];
/**
 * Recover key from ags with weak PRNG
 * @param uid UID
 * @param dist Nonce distance between two authentication
 * @param atks Logs of nested attack
 * @returns {bigint[]} Candidates keys
 */
export declare const nestedAttack: (uid: number, dist: number, atks: Array<{
    nt1: number;
    nt2: number;
    par: number;
}>) => bigint[];