@newfadel/libsignal-node/index.d.ts

Signal protocol implementation for Node.js - A ratcheting forward secrecy protocol for secure messaging

declare module "libsignal-node" {
  export interface KeyPair {
    pubKey: Buffer
    privKey: Buffer
  }

  export interface PreKey {
    keyId: number
    keyPair: KeyPair
  }

  export interface SignedPreKey extends PreKey {
    signature: Buffer
  }

  export interface PreKeyBundle {
    registrationId: number
    deviceId: number
    preKey?: PreKey
    signedPreKey: SignedPreKey
    identityKey: Buffer
  }

  export class ProtocolAddress {
    constructor(id: string, deviceId: number)
    static from(encodedAddress: string): ProtocolAddress
    id: string
    deviceId: number
    toString(): string
    is(other: ProtocolAddress): boolean
  }

  export class SessionBuilder {
    constructor(storage: any, protocolAddress: ProtocolAddress)
    initOutgoing(device: PreKeyBundle): Promise<void>
    initIncoming(record: SessionRecord, message: any): Promise<number | undefined>
  }

  export class SessionCipher {
    constructor(storage: any, protocolAddress: ProtocolAddress)
    encrypt(data: Buffer): Promise<{ type: number; body: Buffer; registrationId: number }>
    decryptWhisperMessage(data: Buffer): Promise<Buffer>
    decryptPreKeyWhisperMessage(data: Buffer): Promise<Buffer>
    hasOpenSession(): Promise<boolean>
    closeOpenSession(): Promise<void>
  }

  export class SessionRecord {
    static createEntry(): any
    static deserialize(data: any): SessionRecord
    serialize(): any
    haveOpenSession(): boolean
    getSession(key: Buffer): any
    setSession(session: any): void
    getSessions(): any[]
    closeSession(session: any): void
    openSession(session: any): void
    isClosed(session: any): boolean
    removeOldSessions(): void
    deleteAllSessions(): void
  }

  export namespace crypto {
    export function deriveSecrets(input: Buffer, salt: Buffer, info: Buffer, chunks?: number): Buffer[]
    export function decrypt(key: Buffer, data: Buffer, iv: Buffer): Buffer
    export function encrypt(key: Buffer, data: Buffer, iv: Buffer): Buffer
    export function hash(data: Buffer): Buffer
    export function calculateMAC(key: Buffer, data: Buffer): Buffer
    export function verifyMAC(data: Buffer, key: Buffer, mac: Buffer, length: number): void
  }

  export namespace curve {
    export function generateKeyPair(): KeyPair
    export function getPublicFromPrivateKey(privKey: Buffer): Buffer
    export function calculateAgreement(pubKey: Buffer, privKey: Buffer): Buffer
    export function calculateSignature(privKey: Buffer, message: Buffer): Buffer
    export function verifySignature(pubKey: Buffer, msg: Buffer, sig: Buffer, isInit?: boolean): boolean
  }

  export namespace keyhelper {
    export function generateIdentityKeyPair(): KeyPair
    export function generateRegistrationId(): number
    export function generateSignedPreKey(identityKeyPair: KeyPair, signedKeyId: number): SignedPreKey
    export function generatePreKey(keyId: number): PreKey
  }

  export class SignalError extends Error {}
  export class UntrustedIdentityKeyError extends SignalError {
    constructor(addr: string, identityKey: Buffer)
    addr: string
    identityKey: Buffer
  }
  export class SessionError extends SignalError {}
  export class MessageCounterError extends SessionError {}
  export class PreKeyError extends SessionError {}
}