0.3.0 release
This commit is contained in:
Jack Lloyd
parent
23edaad30d
commit
3ea4c5e646
@ -25,6 +25,10 @@ the Android NDK/SDK, and add the Android targets to the Rust compiler, using
|
||||
|
||||
```rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android```
|
||||
|
||||
as well as the Cargo NDK tool using
|
||||
|
||||
```cargo install --version=1.0.0 cargo-ndk```
|
||||
|
||||
To build the Java/Android ``jar`` and ``aar``, and run the tests:
|
||||
|
||||
```shell
|
||||
|
||||
Binary file not shown.
BIN
build/libsignal_client_darwin_x64.node
Normal file
BIN
build/libsignal_client_darwin_x64.node
Normal file
Binary file not shown.
Binary file not shown.
BIN
build/libsignal_client_linux_x64.node
Normal file
BIN
build/libsignal_client_linux_x64.node
Normal file
Binary file not shown.
Binary file not shown.
BIN
build/libsignal_client_win32_x64.node
Normal file
BIN
build/libsignal_client_win32_x64.node
Normal file
Binary file not shown.
282
dist/index.d.ts
vendored
282
dist/index.d.ts
vendored
@ -1,17 +1,71 @@
|
||||
/// <reference types="node" />
|
||||
import * as SignalClient from './libsignal_client';
|
||||
export declare class PublicKey {
|
||||
private readonly nativeHandle;
|
||||
export declare const initLogger: typeof SignalClient.initLogger, LogLevel: typeof SignalClient.LogLevel;
|
||||
export declare const enum CiphertextMessageType {
|
||||
Whisper = 2,
|
||||
PreKey = 3,
|
||||
SenderKey = 4,
|
||||
SenderKeyDistribution = 5
|
||||
}
|
||||
export declare const enum Direction {
|
||||
Sending = 0,
|
||||
Receiving = 1
|
||||
}
|
||||
export declare class HKDF {
|
||||
private readonly version;
|
||||
private constructor();
|
||||
static fromNativeHandle(handle: SignalClient.PublicKey): PublicKey;
|
||||
static new(version: number): HKDF;
|
||||
deriveSecrets(outputLength: number, keyMaterial: Buffer, label: Buffer, salt: Buffer | null): Buffer;
|
||||
}
|
||||
export declare class ScannableFingerprint {
|
||||
private readonly scannable;
|
||||
private constructor();
|
||||
static _fromBuffer(scannable: Buffer): ScannableFingerprint;
|
||||
compare(other: ScannableFingerprint): boolean;
|
||||
toBuffer(): Buffer;
|
||||
}
|
||||
export declare class DisplayableFingerprint {
|
||||
private readonly display;
|
||||
private constructor();
|
||||
static _fromString(display: string): DisplayableFingerprint;
|
||||
toString(): string;
|
||||
}
|
||||
export declare class Fingerprint {
|
||||
readonly _nativeHandle: SignalClient.Fingerprint;
|
||||
private constructor();
|
||||
static new(iterations: number, version: number, localIdentifier: Buffer, localKey: PublicKey, remoteIdentifier: Buffer, remoteKey: PublicKey): Fingerprint;
|
||||
displayableFingerprint(): DisplayableFingerprint;
|
||||
scannableFingerprint(): ScannableFingerprint;
|
||||
}
|
||||
export declare class Aes256GcmSiv {
|
||||
readonly _nativeHandle: SignalClient.Aes256GcmSiv;
|
||||
private constructor();
|
||||
static new(key: Buffer): Aes256GcmSiv;
|
||||
encrypt(message: Buffer, nonce: Buffer, associated_data: Buffer): Buffer;
|
||||
decrypt(message: Buffer, nonce: Buffer, associated_data: Buffer): Buffer;
|
||||
}
|
||||
export declare class ProtocolAddress {
|
||||
readonly _nativeHandle: SignalClient.ProtocolAddress;
|
||||
private constructor();
|
||||
static _fromNativeHandle(handle: SignalClient.ProtocolAddress): ProtocolAddress;
|
||||
static new(name: string, deviceId: number): ProtocolAddress;
|
||||
name(): string;
|
||||
deviceId(): number;
|
||||
}
|
||||
export declare class PublicKey {
|
||||
readonly _nativeHandle: SignalClient.PublicKey;
|
||||
private constructor();
|
||||
static _fromNativeHandle(handle: SignalClient.PublicKey): PublicKey;
|
||||
static deserialize(buf: Buffer): PublicKey;
|
||||
compare(other: PublicKey): number;
|
||||
serialize(): Buffer;
|
||||
getPublicKeyBytes(): Buffer;
|
||||
verify(msg: Buffer, sig: Buffer): boolean;
|
||||
_unsafeGetNativeHandle(): SignalClient.PublicKey;
|
||||
}
|
||||
export declare class PrivateKey {
|
||||
private readonly nativeHandle;
|
||||
readonly _nativeHandle: SignalClient.PrivateKey;
|
||||
private constructor();
|
||||
static _fromNativeHandle(handle: SignalClient.PrivateKey): PrivateKey;
|
||||
static generate(): PrivateKey;
|
||||
static deserialize(buf: Buffer): PrivateKey;
|
||||
serialize(): Buffer;
|
||||
@ -19,3 +73,221 @@ export declare class PrivateKey {
|
||||
agree(other_key: PublicKey): Buffer;
|
||||
getPublicKey(): PublicKey;
|
||||
}
|
||||
export declare class IdentityKeyPair {
|
||||
private readonly publicKey;
|
||||
private readonly privateKey;
|
||||
constructor(publicKey: PublicKey, privateKey: PrivateKey);
|
||||
static new(publicKey: PublicKey, privateKey: PrivateKey): IdentityKeyPair;
|
||||
serialize(): Buffer;
|
||||
}
|
||||
export declare class PreKeyBundle {
|
||||
readonly _nativeHandle: SignalClient.PreKeyBundle;
|
||||
private constructor();
|
||||
static new(registration_id: number, device_id: number, prekey_id: number | null, prekey: PublicKey | null, signed_prekey_id: number, signed_prekey: PublicKey, signed_prekey_signature: Buffer, identity_key: PublicKey): PreKeyBundle;
|
||||
deviceId(): number;
|
||||
identityKey(): PublicKey;
|
||||
preKeyId(): number | null;
|
||||
preKeyPublic(): PublicKey | null;
|
||||
registrationId(): number;
|
||||
signedPreKeyId(): number;
|
||||
signedPreKeyPublic(): PublicKey;
|
||||
signedPreKeySignature(): Buffer;
|
||||
}
|
||||
export declare class PreKeyRecord {
|
||||
readonly _nativeHandle: SignalClient.PreKeyRecord;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.PreKeyRecord): PreKeyRecord;
|
||||
static new(id: number, pubKey: PublicKey, privKey: PrivateKey): PreKeyRecord;
|
||||
static deserialize(buffer: Buffer): PreKeyRecord;
|
||||
id(): number;
|
||||
privateKey(): PrivateKey;
|
||||
publicKey(): PublicKey;
|
||||
serialize(): Buffer;
|
||||
}
|
||||
export declare class SignedPreKeyRecord {
|
||||
readonly _nativeHandle: SignalClient.SignedPreKeyRecord;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.SignedPreKeyRecord): SignedPreKeyRecord;
|
||||
static new(id: number, timestamp: number, pubKey: PublicKey, privKey: PrivateKey, signature: Buffer): SignedPreKeyRecord;
|
||||
static deserialize(buffer: Buffer): SignedPreKeyRecord;
|
||||
id(): number;
|
||||
privateKey(): PrivateKey;
|
||||
publicKey(): PublicKey;
|
||||
serialize(): Buffer;
|
||||
signature(): Buffer;
|
||||
timestamp(): number;
|
||||
}
|
||||
export declare class SignalMessage {
|
||||
readonly _nativeHandle: SignalClient.SignalMessage;
|
||||
private constructor();
|
||||
static new(messageVersion: number, macKey: Buffer, senderRatchetKey: PublicKey, counter: number, previousCounter: number, ciphertext: Buffer, senderIdentityKey: PublicKey, receiverIdentityKey: PublicKey): SignalMessage;
|
||||
static deserialize(buffer: Buffer): SignalMessage;
|
||||
body(): Buffer;
|
||||
counter(): number;
|
||||
messageVersion(): number;
|
||||
serialize(): Buffer;
|
||||
verifyMac(senderIdentityKey: PublicKey, recevierIdentityKey: PublicKey, macKey: Buffer): boolean;
|
||||
}
|
||||
export declare class PreKeySignalMessage {
|
||||
readonly _nativeHandle: SignalClient.PreKeySignalMessage;
|
||||
private constructor();
|
||||
static new(messageVersion: number, registrationId: number, preKeyId: number | null, signedPreKeyId: number, baseKey: PublicKey, identityKey: PublicKey, signalMessage: SignalMessage): PreKeySignalMessage;
|
||||
static deserialize(buffer: Buffer): PreKeySignalMessage;
|
||||
preKeyId(): number | null;
|
||||
registrationId(): number;
|
||||
signedPreKeyId(): number;
|
||||
version(): number;
|
||||
serialize(): Buffer;
|
||||
}
|
||||
export declare class SessionRecord {
|
||||
readonly _nativeHandle: SignalClient.SessionRecord;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.SessionRecord): SessionRecord;
|
||||
static deserialize(buffer: Buffer): SessionRecord;
|
||||
serialize(): Buffer;
|
||||
archiveCurrentState(): void;
|
||||
localRegistrationId(): number;
|
||||
remoteRegistrationId(): number;
|
||||
}
|
||||
export declare class SenderKeyName {
|
||||
readonly _nativeHandle: SignalClient.SenderKeyName;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.SenderKeyName): SenderKeyName;
|
||||
static new(groupId: string, senderName: string, senderDeviceId: number): SenderKeyName;
|
||||
groupId(): string;
|
||||
senderName(): string;
|
||||
senderDeviceId(): number;
|
||||
}
|
||||
export declare class ServerCertificate {
|
||||
readonly _nativeHandle: SignalClient.ServerCertificate;
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.ServerCertificate): ServerCertificate;
|
||||
private constructor();
|
||||
static new(keyId: number, serverKey: PublicKey, trustRoot: PrivateKey): ServerCertificate;
|
||||
static deserialize(buffer: Buffer): ServerCertificate;
|
||||
certificateData(): Buffer;
|
||||
key(): PublicKey;
|
||||
keyId(): number;
|
||||
serialize(): Buffer;
|
||||
signature(): Buffer;
|
||||
}
|
||||
export declare class SenderKeyRecord {
|
||||
readonly _nativeHandle: SignalClient.SenderKeyRecord;
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.SenderKeyRecord): SenderKeyRecord;
|
||||
private constructor();
|
||||
static new(): SenderKeyRecord;
|
||||
static deserialize(buffer: Buffer): SenderKeyRecord;
|
||||
serialize(): Buffer;
|
||||
}
|
||||
export declare class SenderCertificate {
|
||||
readonly _nativeHandle: SignalClient.SenderCertificate;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.SenderCertificate): SenderCertificate;
|
||||
static new(senderUuid: string, senderE164: string | null, senderDeviceId: number, senderKey: PublicKey, expiration: number, signerCert: ServerCertificate, signerKey: PrivateKey): SenderCertificate;
|
||||
static deserialize(buffer: Buffer): SenderCertificate;
|
||||
serialize(): Buffer;
|
||||
certificate(): Buffer;
|
||||
expiration(): number;
|
||||
key(): PublicKey;
|
||||
senderE164(): string | null;
|
||||
senderUuid(): string;
|
||||
senderDeviceId(): number;
|
||||
serverCertificate(): ServerCertificate;
|
||||
signature(): Buffer;
|
||||
validate(trustRoot: PublicKey, time: number): boolean;
|
||||
}
|
||||
export declare class SenderKeyDistributionMessage {
|
||||
readonly _nativeHandle: SignalClient.SenderKeyDistributionMessage;
|
||||
private constructor();
|
||||
static create(name: SenderKeyName, store: SenderKeyStore): Promise<SenderKeyDistributionMessage>;
|
||||
static new(keyId: number, iteration: number, chainKey: Buffer, pk: PublicKey): SenderKeyDistributionMessage;
|
||||
static deserialize(buffer: Buffer): SenderKeyDistributionMessage;
|
||||
serialize(): Buffer;
|
||||
chainKey(): Buffer;
|
||||
iteration(): number;
|
||||
id(): number;
|
||||
}
|
||||
export declare function processSenderKeyDistributionMessage(name: SenderKeyName, message: SenderKeyDistributionMessage, store: SenderKeyStore): Promise<void>;
|
||||
export declare class SenderKeyMessage {
|
||||
readonly _nativeHandle: SignalClient.SenderKeyMessage;
|
||||
private constructor();
|
||||
static new(keyId: number, iteration: number, ciphertext: Buffer, pk: PrivateKey): SenderKeyMessage;
|
||||
static deserialize(buffer: Buffer): SenderKeyMessage;
|
||||
serialize(): Buffer;
|
||||
ciphertext(): Buffer;
|
||||
iteration(): number;
|
||||
keyId(): number;
|
||||
verifySignature(key: PublicKey): boolean;
|
||||
}
|
||||
export declare class UnidentifiedSenderMessageContent {
|
||||
readonly _nativeHandle: SignalClient.UnidentifiedSenderMessageContent;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.UnidentifiedSenderMessageContent): UnidentifiedSenderMessageContent;
|
||||
static deserialize(buffer: Buffer): UnidentifiedSenderMessageContent;
|
||||
serialize(): Buffer;
|
||||
contents(): Buffer;
|
||||
msgType(): number;
|
||||
senderCertificate(): SenderCertificate;
|
||||
}
|
||||
export declare abstract class SessionStore implements SignalClient.SessionStore {
|
||||
_saveSession(name: SignalClient.ProtocolAddress, record: SignalClient.SessionRecord): Promise<void>;
|
||||
_getSession(name: SignalClient.ProtocolAddress): Promise<SignalClient.SessionRecord | null>;
|
||||
abstract saveSession(name: ProtocolAddress, record: SessionRecord): Promise<void>;
|
||||
abstract getSession(name: ProtocolAddress): Promise<SessionRecord | null>;
|
||||
}
|
||||
export declare abstract class IdentityKeyStore implements SignalClient.IdentityKeyStore {
|
||||
_getIdentityKey(): Promise<SignalClient.PrivateKey>;
|
||||
_getLocalRegistrationId(): Promise<number>;
|
||||
_saveIdentity(name: SignalClient.ProtocolAddress, key: SignalClient.PublicKey): Promise<boolean>;
|
||||
_isTrustedIdentity(name: SignalClient.ProtocolAddress, key: SignalClient.PublicKey, sending: boolean): Promise<boolean>;
|
||||
_getIdentity(name: SignalClient.ProtocolAddress): Promise<SignalClient.PublicKey | null>;
|
||||
abstract getIdentityKey(): Promise<PrivateKey>;
|
||||
abstract getLocalRegistrationId(): Promise<number>;
|
||||
abstract saveIdentity(name: ProtocolAddress, key: PublicKey): Promise<boolean>;
|
||||
abstract isTrustedIdentity(name: ProtocolAddress, key: PublicKey, direction: Direction): Promise<boolean>;
|
||||
abstract getIdentity(name: ProtocolAddress): Promise<PublicKey | null>;
|
||||
}
|
||||
export declare abstract class PreKeyStore implements SignalClient.PreKeyStore {
|
||||
_savePreKey(id: number, record: SignalClient.PreKeyRecord): Promise<void>;
|
||||
_getPreKey(id: number): Promise<SignalClient.PreKeyRecord>;
|
||||
_removePreKey(id: number): Promise<void>;
|
||||
abstract savePreKey(id: number, record: PreKeyRecord): Promise<void>;
|
||||
abstract getPreKey(id: number): Promise<PreKeyRecord>;
|
||||
abstract removePreKey(id: number): Promise<void>;
|
||||
}
|
||||
export declare abstract class SignedPreKeyStore implements SignalClient.SignedPreKeyStore {
|
||||
_saveSignedPreKey(id: number, record: SignalClient.SignedPreKeyRecord): Promise<void>;
|
||||
_getSignedPreKey(id: number): Promise<SignalClient.SignedPreKeyRecord>;
|
||||
abstract saveSignedPreKey(id: number, record: SignedPreKeyRecord): Promise<void>;
|
||||
abstract getSignedPreKey(id: number): Promise<SignedPreKeyRecord>;
|
||||
}
|
||||
export declare abstract class SenderKeyStore implements SignalClient.SenderKeyStore {
|
||||
_saveSenderKey(name: SignalClient.SenderKeyName, record: SignalClient.SenderKeyRecord): Promise<void>;
|
||||
_getSenderKey(name: SignalClient.SenderKeyName): Promise<SignalClient.SenderKeyRecord | null>;
|
||||
abstract saveSenderKey(name: SenderKeyName, record: SenderKeyRecord): Promise<void>;
|
||||
abstract getSenderKey(name: SenderKeyName): Promise<SenderKeyRecord | null>;
|
||||
}
|
||||
export declare function groupEncrypt(name: SenderKeyName, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
|
||||
export declare function groupDecrypt(name: SenderKeyName, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
|
||||
export declare class SealedSenderDecryptionResult {
|
||||
readonly _nativeHandle: SignalClient.SealedSenderDecryptionResult;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.SealedSenderDecryptionResult): SealedSenderDecryptionResult;
|
||||
message(): Buffer;
|
||||
senderE164(): string | null;
|
||||
senderUuid(): string;
|
||||
deviceId(): number;
|
||||
}
|
||||
export declare class CiphertextMessage {
|
||||
readonly _nativeHandle: SignalClient.CiphertextMessage;
|
||||
private constructor();
|
||||
static _fromNativeHandle(nativeHandle: SignalClient.CiphertextMessage): CiphertextMessage;
|
||||
serialize(): Buffer;
|
||||
type(): number;
|
||||
}
|
||||
export declare function processPreKeyBundle(bundle: PreKeyBundle, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<void>;
|
||||
export declare function signalEncrypt(message: Buffer, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<CiphertextMessage>;
|
||||
export declare function signalDecrypt(message: SignalMessage, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
|
||||
export declare function signalDecryptPreKey(message: PreKeySignalMessage, address: ProtocolAddress, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<Buffer>;
|
||||
export declare function sealedSenderEncryptMessage(message: Buffer, address: ProtocolAddress, senderCert: SenderCertificate, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
|
||||
export declare function sealedSenderDecryptMessage(message: Buffer, trustRoot: PublicKey, timestamp: number, localE164: string | null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<SealedSenderDecryptionResult>;
|
||||
export declare function sealedSenderDecryptToUsmc(message: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
|
||||
|
||||
723
dist/index.js
vendored
723
dist/index.js
vendored
@ -1,54 +1,743 @@
|
||||
"use strict";
|
||||
//
|
||||
// Copyright 2020 Signal Messenger, LLC.
|
||||
// Copyright 2020-2021 Signal Messenger, LLC.
|
||||
// SPDX-License-Identifier: AGPL-3.0-only
|
||||
//
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const os = require("os");
|
||||
const bindings = require("bindings"); // eslint-disable-line @typescript-eslint/no-require-imports
|
||||
const SC = bindings('libsignal_client_' + os.platform());
|
||||
const SC = bindings('libsignal_client_' + os.platform() + '_' + process.arch);
|
||||
exports.initLogger = SC.initLogger, exports.LogLevel = SC.LogLevel;
|
||||
class HKDF {
|
||||
constructor(version) {
|
||||
this.version = version;
|
||||
}
|
||||
static new(version) {
|
||||
return new HKDF(version);
|
||||
}
|
||||
deriveSecrets(outputLength, keyMaterial, label, salt) {
|
||||
return SC.HKDF_DeriveSecrets(outputLength, this.version, keyMaterial, label, salt);
|
||||
}
|
||||
}
|
||||
exports.HKDF = HKDF;
|
||||
class ScannableFingerprint {
|
||||
constructor(scannable) {
|
||||
this.scannable = scannable;
|
||||
}
|
||||
static _fromBuffer(scannable) {
|
||||
return new ScannableFingerprint(scannable);
|
||||
}
|
||||
compare(other) {
|
||||
return SC.ScannableFingerprint_Compare(this.scannable, other.scannable);
|
||||
}
|
||||
toBuffer() {
|
||||
return this.scannable;
|
||||
}
|
||||
}
|
||||
exports.ScannableFingerprint = ScannableFingerprint;
|
||||
class DisplayableFingerprint {
|
||||
constructor(display) {
|
||||
this.display = display;
|
||||
}
|
||||
static _fromString(display) {
|
||||
return new DisplayableFingerprint(display);
|
||||
}
|
||||
toString() {
|
||||
return this.display;
|
||||
}
|
||||
}
|
||||
exports.DisplayableFingerprint = DisplayableFingerprint;
|
||||
class Fingerprint {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static new(iterations, version, localIdentifier, localKey, remoteIdentifier, remoteKey) {
|
||||
return new Fingerprint(SC.Fingerprint_New(iterations, version, localIdentifier, localKey, remoteIdentifier, remoteKey));
|
||||
}
|
||||
displayableFingerprint() {
|
||||
return DisplayableFingerprint._fromString(SC.Fingerprint_DisplayString(this));
|
||||
}
|
||||
scannableFingerprint() {
|
||||
return ScannableFingerprint._fromBuffer(SC.Fingerprint_ScannableEncoding(this));
|
||||
}
|
||||
}
|
||||
exports.Fingerprint = Fingerprint;
|
||||
class Aes256GcmSiv {
|
||||
constructor(key) {
|
||||
this._nativeHandle = SC.Aes256GcmSiv_New(key);
|
||||
}
|
||||
static new(key) {
|
||||
return new Aes256GcmSiv(key);
|
||||
}
|
||||
encrypt(message, nonce, associated_data) {
|
||||
return SC.Aes256GcmSiv_Encrypt(this, message, nonce, associated_data);
|
||||
}
|
||||
decrypt(message, nonce, associated_data) {
|
||||
return SC.Aes256GcmSiv_Decrypt(this, message, nonce, associated_data);
|
||||
}
|
||||
}
|
||||
exports.Aes256GcmSiv = Aes256GcmSiv;
|
||||
class ProtocolAddress {
|
||||
constructor(handle) {
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static _fromNativeHandle(handle) {
|
||||
return new ProtocolAddress(handle);
|
||||
}
|
||||
static new(name, deviceId) {
|
||||
return new ProtocolAddress(SC.ProtocolAddress_New(name, deviceId));
|
||||
}
|
||||
name() {
|
||||
return SC.ProtocolAddress_Name(this);
|
||||
}
|
||||
deviceId() {
|
||||
return SC.ProtocolAddress_DeviceId(this);
|
||||
}
|
||||
}
|
||||
exports.ProtocolAddress = ProtocolAddress;
|
||||
class PublicKey {
|
||||
constructor(handle) {
|
||||
this.nativeHandle = handle;
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static fromNativeHandle(handle) {
|
||||
static _fromNativeHandle(handle) {
|
||||
return new PublicKey(handle);
|
||||
}
|
||||
static deserialize(buf) {
|
||||
return new PublicKey(SC.PublicKey_deserialize(buf));
|
||||
return new PublicKey(SC.PublicKey_Deserialize(buf));
|
||||
}
|
||||
/// Returns -1, 0, or 1
|
||||
compare(other) {
|
||||
return SC.PublicKey_Compare(this, other);
|
||||
}
|
||||
serialize() {
|
||||
return SC.PublicKey_serialize(this.nativeHandle);
|
||||
return SC.PublicKey_Serialize(this);
|
||||
}
|
||||
getPublicKeyBytes() {
|
||||
return SC.PublicKey_GetPublicKeyBytes(this);
|
||||
}
|
||||
verify(msg, sig) {
|
||||
return SC.PublicKey_verify(this.nativeHandle, msg, sig);
|
||||
}
|
||||
_unsafeGetNativeHandle() {
|
||||
return this.nativeHandle;
|
||||
return SC.PublicKey_Verify(this, msg, sig);
|
||||
}
|
||||
}
|
||||
exports.PublicKey = PublicKey;
|
||||
class PrivateKey {
|
||||
constructor(handle) {
|
||||
this.nativeHandle = handle;
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static _fromNativeHandle(handle) {
|
||||
return new PrivateKey(handle);
|
||||
}
|
||||
static generate() {
|
||||
return new PrivateKey(SC.PrivateKey_generate());
|
||||
return new PrivateKey(SC.PrivateKey_Generate());
|
||||
}
|
||||
static deserialize(buf) {
|
||||
return new PrivateKey(SC.PrivateKey_deserialize(buf));
|
||||
return new PrivateKey(SC.PrivateKey_Deserialize(buf));
|
||||
}
|
||||
serialize() {
|
||||
return SC.PrivateKey_serialize(this.nativeHandle);
|
||||
return SC.PrivateKey_Serialize(this);
|
||||
}
|
||||
sign(msg) {
|
||||
return SC.PrivateKey_sign(this.nativeHandle, msg);
|
||||
return SC.PrivateKey_Sign(this, msg);
|
||||
}
|
||||
agree(other_key) {
|
||||
return SC.PrivateKey_agree(this.nativeHandle, other_key._unsafeGetNativeHandle());
|
||||
return SC.PrivateKey_Agree(this, other_key);
|
||||
}
|
||||
getPublicKey() {
|
||||
return PublicKey.fromNativeHandle(SC.PrivateKey_getPublicKey(this.nativeHandle));
|
||||
return PublicKey._fromNativeHandle(SC.PrivateKey_GetPublicKey(this));
|
||||
}
|
||||
}
|
||||
exports.PrivateKey = PrivateKey;
|
||||
class IdentityKeyPair {
|
||||
constructor(publicKey, privateKey) {
|
||||
this.publicKey = publicKey;
|
||||
this.privateKey = privateKey;
|
||||
}
|
||||
static new(publicKey, privateKey) {
|
||||
return new IdentityKeyPair(publicKey, privateKey);
|
||||
}
|
||||
serialize() {
|
||||
return SC.IdentityKeyPair_Serialize(this.publicKey, this.privateKey);
|
||||
}
|
||||
}
|
||||
exports.IdentityKeyPair = IdentityKeyPair;
|
||||
class PreKeyBundle {
|
||||
constructor(handle) {
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static new(registration_id, device_id, prekey_id, prekey, signed_prekey_id, signed_prekey, signed_prekey_signature, identity_key) {
|
||||
return new PreKeyBundle(SC.PreKeyBundle_New(registration_id, device_id, prekey_id, prekey != null ? prekey : null,
|
||||
//prekey?,
|
||||
signed_prekey_id, signed_prekey, signed_prekey_signature, identity_key));
|
||||
}
|
||||
deviceId() {
|
||||
return SC.PreKeyBundle_GetDeviceId(this);
|
||||
}
|
||||
identityKey() {
|
||||
return PublicKey._fromNativeHandle(SC.PreKeyBundle_GetIdentityKey(this));
|
||||
}
|
||||
preKeyId() {
|
||||
return SC.PreKeyBundle_GetPreKeyId(this);
|
||||
}
|
||||
preKeyPublic() {
|
||||
const handle = SC.PreKeyBundle_GetPreKeyPublic(this);
|
||||
if (handle == null) {
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return PublicKey._fromNativeHandle(handle);
|
||||
}
|
||||
}
|
||||
registrationId() {
|
||||
return SC.PreKeyBundle_GetRegistrationId(this);
|
||||
}
|
||||
signedPreKeyId() {
|
||||
return SC.PreKeyBundle_GetSignedPreKeyId(this);
|
||||
}
|
||||
signedPreKeyPublic() {
|
||||
return PublicKey._fromNativeHandle(SC.PreKeyBundle_GetSignedPreKeyPublic(this));
|
||||
}
|
||||
signedPreKeySignature() {
|
||||
return SC.PreKeyBundle_GetSignedPreKeySignature(this);
|
||||
}
|
||||
}
|
||||
exports.PreKeyBundle = PreKeyBundle;
|
||||
class PreKeyRecord {
|
||||
constructor(handle) {
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new PreKeyRecord(nativeHandle);
|
||||
}
|
||||
static new(id, pubKey, privKey) {
|
||||
return new PreKeyRecord(SC.PreKeyRecord_New(id, pubKey, privKey));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new PreKeyRecord(SC.PreKeyRecord_Deserialize(buffer));
|
||||
}
|
||||
id() {
|
||||
return SC.PreKeyRecord_GetId(this);
|
||||
}
|
||||
privateKey() {
|
||||
return PrivateKey._fromNativeHandle(SC.PreKeyRecord_GetPrivateKey(this));
|
||||
}
|
||||
publicKey() {
|
||||
return PublicKey._fromNativeHandle(SC.PreKeyRecord_GetPublicKey(this));
|
||||
}
|
||||
serialize() {
|
||||
return SC.PreKeyRecord_Serialize(this);
|
||||
}
|
||||
}
|
||||
exports.PreKeyRecord = PreKeyRecord;
|
||||
class SignedPreKeyRecord {
|
||||
constructor(handle) {
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new SignedPreKeyRecord(nativeHandle);
|
||||
}
|
||||
static new(id, timestamp, pubKey, privKey, signature) {
|
||||
return new SignedPreKeyRecord(SC.SignedPreKeyRecord_New(id, timestamp, pubKey, privKey, signature));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SignedPreKeyRecord(SC.SignedPreKeyRecord_Deserialize(buffer));
|
||||
}
|
||||
id() {
|
||||
return SC.SignedPreKeyRecord_GetId(this);
|
||||
}
|
||||
privateKey() {
|
||||
return PrivateKey._fromNativeHandle(SC.SignedPreKeyRecord_GetPrivateKey(this));
|
||||
}
|
||||
publicKey() {
|
||||
return PublicKey._fromNativeHandle(SC.SignedPreKeyRecord_GetPublicKey(this));
|
||||
}
|
||||
serialize() {
|
||||
return SC.SignedPreKeyRecord_Serialize(this);
|
||||
}
|
||||
signature() {
|
||||
return SC.SignedPreKeyRecord_GetSignature(this);
|
||||
}
|
||||
timestamp() {
|
||||
return SC.SignedPreKeyRecord_GetTimestamp(this);
|
||||
}
|
||||
}
|
||||
exports.SignedPreKeyRecord = SignedPreKeyRecord;
|
||||
class SignalMessage {
|
||||
constructor(handle) {
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static new(messageVersion, macKey, senderRatchetKey, counter, previousCounter, ciphertext, senderIdentityKey, receiverIdentityKey) {
|
||||
return new SignalMessage(SC.SignalMessage_New(messageVersion, macKey, senderRatchetKey, counter, previousCounter, ciphertext, senderIdentityKey, receiverIdentityKey));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SignalMessage(SC.SignalMessage_Deserialize(buffer));
|
||||
}
|
||||
body() {
|
||||
return SC.SignalMessage_GetBody(this);
|
||||
}
|
||||
counter() {
|
||||
return SC.SignalMessage_GetCounter(this);
|
||||
}
|
||||
messageVersion() {
|
||||
return SC.SignalMessage_GetMessageVersion(this);
|
||||
}
|
||||
serialize() {
|
||||
return SC.SignalMessage_GetSerialized(this);
|
||||
}
|
||||
verifyMac(senderIdentityKey, recevierIdentityKey, macKey) {
|
||||
return SC.SignalMessage_VerifyMac(this, senderIdentityKey, recevierIdentityKey, macKey);
|
||||
}
|
||||
}
|
||||
exports.SignalMessage = SignalMessage;
|
||||
class PreKeySignalMessage {
|
||||
constructor(handle) {
|
||||
this._nativeHandle = handle;
|
||||
}
|
||||
static new(messageVersion, registrationId, preKeyId, signedPreKeyId, baseKey, identityKey, signalMessage) {
|
||||
return new PreKeySignalMessage(SC.PreKeySignalMessage_New(messageVersion, registrationId, preKeyId, signedPreKeyId, baseKey, identityKey, signalMessage));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new PreKeySignalMessage(SC.PreKeySignalMessage_Deserialize(buffer));
|
||||
}
|
||||
preKeyId() {
|
||||
return SC.PreKeySignalMessage_GetPreKeyId(this);
|
||||
}
|
||||
registrationId() {
|
||||
return SC.PreKeySignalMessage_GetRegistrationId(this);
|
||||
}
|
||||
signedPreKeyId() {
|
||||
return SC.PreKeySignalMessage_GetSignedPreKeyId(this);
|
||||
}
|
||||
version() {
|
||||
return SC.PreKeySignalMessage_GetVersion(this);
|
||||
}
|
||||
serialize() {
|
||||
return SC.PreKeySignalMessage_Serialize(this);
|
||||
}
|
||||
}
|
||||
exports.PreKeySignalMessage = PreKeySignalMessage;
|
||||
class SessionRecord {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new SessionRecord(nativeHandle);
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SessionRecord(SC.SessionRecord_Deserialize(buffer));
|
||||
}
|
||||
serialize() {
|
||||
return SC.SessionRecord_Serialize(this);
|
||||
}
|
||||
archiveCurrentState() {
|
||||
SC.SessionRecord_ArchiveCurrentState(this);
|
||||
}
|
||||
localRegistrationId() {
|
||||
return SC.SessionRecord_GetLocalRegistrationId(this);
|
||||
}
|
||||
remoteRegistrationId() {
|
||||
return SC.SessionRecord_GetRemoteRegistrationId(this);
|
||||
}
|
||||
}
|
||||
exports.SessionRecord = SessionRecord;
|
||||
class SenderKeyName {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new SenderKeyName(nativeHandle);
|
||||
}
|
||||
static new(groupId, senderName, senderDeviceId) {
|
||||
return new SenderKeyName(SC.SenderKeyName_New(groupId, senderName, senderDeviceId));
|
||||
}
|
||||
groupId() {
|
||||
return SC.SenderKeyName_GetGroupId(this);
|
||||
}
|
||||
senderName() {
|
||||
return SC.SenderKeyName_GetSenderName(this);
|
||||
}
|
||||
senderDeviceId() {
|
||||
return SC.SenderKeyName_GetSenderDeviceId(this);
|
||||
}
|
||||
}
|
||||
exports.SenderKeyName = SenderKeyName;
|
||||
class ServerCertificate {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new ServerCertificate(nativeHandle);
|
||||
}
|
||||
static new(keyId, serverKey, trustRoot) {
|
||||
return new ServerCertificate(SC.ServerCertificate_New(keyId, serverKey, trustRoot));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new ServerCertificate(SC.ServerCertificate_Deserialize(buffer));
|
||||
}
|
||||
certificateData() {
|
||||
return SC.ServerCertificate_GetCertificate(this);
|
||||
}
|
||||
key() {
|
||||
return PublicKey._fromNativeHandle(SC.ServerCertificate_GetKey(this));
|
||||
}
|
||||
keyId() {
|
||||
return SC.ServerCertificate_GetKeyId(this);
|
||||
}
|
||||
serialize() {
|
||||
return SC.ServerCertificate_GetSerialized(this);
|
||||
}
|
||||
signature() {
|
||||
return SC.ServerCertificate_GetSignature(this);
|
||||
}
|
||||
}
|
||||
exports.ServerCertificate = ServerCertificate;
|
||||
class SenderKeyRecord {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new SenderKeyRecord(nativeHandle);
|
||||
}
|
||||
static new() {
|
||||
return new SenderKeyRecord(SC.SenderKeyRecord_New());
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SenderKeyRecord(SC.SenderKeyRecord_Deserialize(buffer));
|
||||
}
|
||||
serialize() {
|
||||
return SC.SenderKeyRecord_Serialize(this);
|
||||
}
|
||||
}
|
||||
exports.SenderKeyRecord = SenderKeyRecord;
|
||||
class SenderCertificate {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new SenderCertificate(nativeHandle);
|
||||
}
|
||||
static new(senderUuid, senderE164, senderDeviceId, senderKey, expiration, signerCert, signerKey) {
|
||||
return new SenderCertificate(SC.SenderCertificate_New(senderUuid, senderE164, senderDeviceId, senderKey, expiration, signerCert, signerKey));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SenderCertificate(SC.SenderCertificate_Deserialize(buffer));
|
||||
}
|
||||
serialize() {
|
||||
return SC.SenderCertificate_GetSerialized(this);
|
||||
}
|
||||
certificate() {
|
||||
return SC.SenderCertificate_GetCertificate(this);
|
||||
}
|
||||
expiration() {
|
||||
return SC.SenderCertificate_GetExpiration(this);
|
||||
}
|
||||
key() {
|
||||
return PublicKey._fromNativeHandle(SC.SenderCertificate_GetKey(this));
|
||||
}
|
||||
senderE164() {
|
||||
return SC.SenderCertificate_GetSenderE164(this);
|
||||
}
|
||||
senderUuid() {
|
||||
return SC.SenderCertificate_GetSenderUuid(this);
|
||||
}
|
||||
senderDeviceId() {
|
||||
return SC.SenderCertificate_GetDeviceId(this);
|
||||
}
|
||||
serverCertificate() {
|
||||
return ServerCertificate._fromNativeHandle(SC.SenderCertificate_GetServerCertificate(this));
|
||||
}
|
||||
signature() {
|
||||
return SC.SenderCertificate_GetSignature(this);
|
||||
}
|
||||
validate(trustRoot, time) {
|
||||
return SC.SenderCertificate_Validate(this, trustRoot, time);
|
||||
}
|
||||
}
|
||||
exports.SenderCertificate = SenderCertificate;
|
||||
class SenderKeyDistributionMessage {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static create(name, store) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const handle = yield SC.SenderKeyDistributionMessage_Create(name, store);
|
||||
return new SenderKeyDistributionMessage(handle);
|
||||
});
|
||||
}
|
||||
static new(keyId, iteration, chainKey, pk) {
|
||||
return new SenderKeyDistributionMessage(SC.SenderKeyDistributionMessage_New(keyId, iteration, chainKey, pk));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SenderKeyDistributionMessage(SC.SenderKeyDistributionMessage_Deserialize(buffer));
|
||||
}
|
||||
serialize() {
|
||||
return SC.SenderKeyDistributionMessage_Serialize(this);
|
||||
}
|
||||
chainKey() {
|
||||
return SC.SenderKeyDistributionMessage_GetChainKey(this);
|
||||
}
|
||||
iteration() {
|
||||
return SC.SenderKeyDistributionMessage_GetIteration(this);
|
||||
}
|
||||
id() {
|
||||
return SC.SenderKeyDistributionMessage_GetId(this);
|
||||
}
|
||||
}
|
||||
exports.SenderKeyDistributionMessage = SenderKeyDistributionMessage;
|
||||
function processSenderKeyDistributionMessage(name, message, store) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
yield SC.SenderKeyDistributionMessage_Process(name, message, store);
|
||||
});
|
||||
}
|
||||
exports.processSenderKeyDistributionMessage = processSenderKeyDistributionMessage;
|
||||
class SenderKeyMessage {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static new(keyId, iteration, ciphertext, pk) {
|
||||
return new SenderKeyMessage(SC.SenderKeyMessage_New(keyId, iteration, ciphertext, pk));
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new SenderKeyMessage(SC.SenderKeyMessage_Deserialize(buffer));
|
||||
}
|
||||
serialize() {
|
||||
return SC.SenderKeyMessage_Serialize(this);
|
||||
}
|
||||
ciphertext() {
|
||||
return SC.SenderKeyMessage_GetCipherText(this);
|
||||
}
|
||||
iteration() {
|
||||
return SC.SenderKeyMessage_GetIteration(this);
|
||||
}
|
||||
keyId() {
|
||||
return SC.SenderKeyMessage_GetKeyId(this);
|
||||
}
|
||||
verifySignature(key) {
|
||||
return SC.SenderKeyMessage_VerifySignature(this, key);
|
||||
}
|
||||
}
|
||||
exports.SenderKeyMessage = SenderKeyMessage;
|
||||
class UnidentifiedSenderMessageContent {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new UnidentifiedSenderMessageContent(nativeHandle);
|
||||
}
|
||||
static deserialize(buffer) {
|
||||
return new UnidentifiedSenderMessageContent(SC.UnidentifiedSenderMessageContent_Deserialize(buffer));
|
||||
}
|
||||
serialize() {
|
||||
return SC.UnidentifiedSenderMessageContent_Serialize(this);
|
||||
}
|
||||
contents() {
|
||||
return SC.UnidentifiedSenderMessageContent_GetContents(this);
|
||||
}
|
||||
msgType() {
|
||||
return SC.UnidentifiedSenderMessageContent_GetMsgType(this);
|
||||
}
|
||||
senderCertificate() {
|
||||
return SenderCertificate._fromNativeHandle(SC.UnidentifiedSenderMessageContent_GetSenderCert(this));
|
||||
}
|
||||
}
|
||||
exports.UnidentifiedSenderMessageContent = UnidentifiedSenderMessageContent;
|
||||
class SessionStore {
|
||||
_saveSession(name, record) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.saveSession(ProtocolAddress._fromNativeHandle(name), SessionRecord._fromNativeHandle(record));
|
||||
});
|
||||
}
|
||||
_getSession(name) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const sess = yield this.getSession(ProtocolAddress._fromNativeHandle(name));
|
||||
if (sess == null) {
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return sess._nativeHandle;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.SessionStore = SessionStore;
|
||||
class IdentityKeyStore {
|
||||
_getIdentityKey() {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const key = yield this.getIdentityKey();
|
||||
return key._nativeHandle;
|
||||
});
|
||||
}
|
||||
_getLocalRegistrationId() {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.getLocalRegistrationId();
|
||||
});
|
||||
}
|
||||
_saveIdentity(name, key) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.saveIdentity(ProtocolAddress._fromNativeHandle(name), PublicKey._fromNativeHandle(key));
|
||||
});
|
||||
}
|
||||
_isTrustedIdentity(name, key, sending) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const direction = sending ? 0 /* Sending */ : 1 /* Receiving */;
|
||||
return this.isTrustedIdentity(ProtocolAddress._fromNativeHandle(name), PublicKey._fromNativeHandle(key), direction);
|
||||
});
|
||||
}
|
||||
_getIdentity(name) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const key = yield this.getIdentity(ProtocolAddress._fromNativeHandle(name));
|
||||
if (key == null) {
|
||||
return Promise.resolve(null);
|
||||
}
|
||||
else {
|
||||
return key._nativeHandle;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.IdentityKeyStore = IdentityKeyStore;
|
||||
class PreKeyStore {
|
||||
_savePreKey(id, record) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.savePreKey(id, PreKeyRecord._fromNativeHandle(record));
|
||||
});
|
||||
}
|
||||
_getPreKey(id) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const pk = yield this.getPreKey(id);
|
||||
return pk._nativeHandle;
|
||||
});
|
||||
}
|
||||
_removePreKey(id) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.removePreKey(id);
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.PreKeyStore = PreKeyStore;
|
||||
class SignedPreKeyStore {
|
||||
_saveSignedPreKey(id, record) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.saveSignedPreKey(id, SignedPreKeyRecord._fromNativeHandle(record));
|
||||
});
|
||||
}
|
||||
_getSignedPreKey(id) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const pk = yield this.getSignedPreKey(id);
|
||||
return pk._nativeHandle;
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.SignedPreKeyStore = SignedPreKeyStore;
|
||||
class SenderKeyStore {
|
||||
_saveSenderKey(name, record) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return this.saveSenderKey(SenderKeyName._fromNativeHandle(name), SenderKeyRecord._fromNativeHandle(record));
|
||||
});
|
||||
}
|
||||
_getSenderKey(name) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const skr = yield this.getSenderKey(SenderKeyName._fromNativeHandle(name));
|
||||
if (skr == null) {
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return skr._nativeHandle;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.SenderKeyStore = SenderKeyStore;
|
||||
function groupEncrypt(name, store, message) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return SC.GroupCipher_Encrypt(name, store, message);
|
||||
});
|
||||
}
|
||||
exports.groupEncrypt = groupEncrypt;
|
||||
function groupDecrypt(name, store, message) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return SC.GroupCipher_Decrypt(name, store, message);
|
||||
});
|
||||
}
|
||||
exports.groupDecrypt = groupDecrypt;
|
||||
class SealedSenderDecryptionResult {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new SealedSenderDecryptionResult(nativeHandle);
|
||||
}
|
||||
message() {
|
||||
return SC.SealedSenderDecryptionResult_Message(this);
|
||||
}
|
||||
senderE164() {
|
||||
return SC.SealedSenderDecryptionResult_GetSenderE164(this);
|
||||
}
|
||||
senderUuid() {
|
||||
return SC.SealedSenderDecryptionResult_GetSenderUuid(this);
|
||||
}
|
||||
deviceId() {
|
||||
return SC.SealedSenderDecryptionResult_GetDeviceId(this);
|
||||
}
|
||||
}
|
||||
exports.SealedSenderDecryptionResult = SealedSenderDecryptionResult;
|
||||
class CiphertextMessage {
|
||||
constructor(nativeHandle) {
|
||||
this._nativeHandle = nativeHandle;
|
||||
}
|
||||
static _fromNativeHandle(nativeHandle) {
|
||||
return new CiphertextMessage(nativeHandle);
|
||||
}
|
||||
serialize() {
|
||||
return SC.CiphertextMessage_Serialize(this);
|
||||
}
|
||||
type() {
|
||||
return SC.CiphertextMessage_Type(this);
|
||||
}
|
||||
}
|
||||
exports.CiphertextMessage = CiphertextMessage;
|
||||
function processPreKeyBundle(bundle, address, sessionStore, identityStore) {
|
||||
return SC.SessionBuilder_ProcessPreKeyBundle(bundle, address, sessionStore, identityStore);
|
||||
}
|
||||
exports.processPreKeyBundle = processPreKeyBundle;
|
||||
function signalEncrypt(message, address, sessionStore, identityStore) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
return CiphertextMessage._fromNativeHandle(yield SC.SessionCipher_EncryptMessage(message, address, sessionStore, identityStore));
|
||||
});
|
||||
}
|
||||
exports.signalEncrypt = signalEncrypt;
|
||||
function signalDecrypt(message, address, sessionStore, identityStore) {
|
||||
return SC.SessionCipher_DecryptSignalMessage(message, address, sessionStore, identityStore);
|
||||
}
|
||||
exports.signalDecrypt = signalDecrypt;
|
||||
function signalDecryptPreKey(message, address, sessionStore, identityStore, prekeyStore, signedPrekeyStore) {
|
||||
return SC.SessionCipher_DecryptPreKeySignalMessage(message, address, sessionStore, identityStore, prekeyStore, signedPrekeyStore);
|
||||
}
|
||||
exports.signalDecryptPreKey = signalDecryptPreKey;
|
||||
function sealedSenderEncryptMessage(message, address, senderCert, sessionStore, identityStore) {
|
||||
return SC.SealedSender_EncryptMessage(message, address, senderCert, sessionStore, identityStore);
|
||||
}
|
||||
exports.sealedSenderEncryptMessage = sealedSenderEncryptMessage;
|
||||
function sealedSenderDecryptMessage(message, trustRoot, timestamp, localE164, localUuid, localDeviceId, sessionStore, identityStore, prekeyStore, signedPrekeyStore) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const ssdr = yield SC.SealedSender_DecryptMessage(message, trustRoot, timestamp, localE164, localUuid, localDeviceId, sessionStore, identityStore, prekeyStore, signedPrekeyStore);
|
||||
return SealedSenderDecryptionResult._fromNativeHandle(ssdr);
|
||||
});
|
||||
}
|
||||
exports.sealedSenderDecryptMessage = sealedSenderDecryptMessage;
|
||||
function sealedSenderDecryptToUsmc(message, identityStore) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
const usmc = yield SC.SealedSender_DecryptToUsmc(message, identityStore);
|
||||
return UnidentifiedSenderMessageContent._fromNativeHandle(usmc);
|
||||
});
|
||||
}
|
||||
exports.sealedSenderDecryptToUsmc = sealedSenderDecryptToUsmc;
|
||||
//# sourceMappingURL=index.js.map
|
||||
203
dist/libsignal_client.d.ts
vendored
203
dist/libsignal_client.d.ts
vendored
@ -1,32 +1,189 @@
|
||||
//
|
||||
// Copyright 2020 Signal Messenger, LLC.
|
||||
// Copyright 2020-2021 Signal Messenger, LLC.
|
||||
// SPDX-License-Identifier: AGPL-3.0-only
|
||||
//
|
||||
|
||||
/* eslint-disable import/prefer-default-export */
|
||||
// WARNING: this file was automatically generated
|
||||
|
||||
// FIXME: Eventually we should be able to autogenerate this.
|
||||
|
||||
// Newtype pattern from https://kubyshkin.name/posts/newtype-in-typescript/
|
||||
interface PublicKey {
|
||||
readonly __type: unique symbol;
|
||||
export abstract class IdentityKeyStore {
|
||||
_getIdentityKey(): Promise<PrivateKey>;
|
||||
_getLocalRegistrationId(): Promise<number>;
|
||||
_saveIdentity(name: ProtocolAddress, key: PublicKey): Promise<boolean>;
|
||||
_isTrustedIdentity(name: ProtocolAddress, key: PublicKey, sending: boolean): Promise<boolean>;
|
||||
_getIdentity(name: ProtocolAddress): Promise<PublicKey | null>;
|
||||
}
|
||||
|
||||
export function PublicKey_deserialize(buf: Buffer): PublicKey;
|
||||
export function PublicKey_serialize(key: PublicKey): Buffer;
|
||||
export function PublicKey_verify(
|
||||
key: PublicKey,
|
||||
msg: Buffer,
|
||||
signature: Buffer
|
||||
): boolean;
|
||||
|
||||
interface PrivateKey {
|
||||
readonly __type: unique symbol;
|
||||
export abstract class SessionStore {
|
||||
_saveSession(addr: ProtocolAddress, record: SessionRecord): Promise<void>;
|
||||
_getSession(addr: ProtocolAddress): Promise<SessionRecord | null>;
|
||||
}
|
||||
|
||||
export function PrivateKey_generate(): PrivateKey;
|
||||
export function PrivateKey_deserialize(buf: Buffer): PrivateKey;
|
||||
export function PrivateKey_serialize(key: PrivateKey): Buffer;
|
||||
export function PrivateKey_sign(key: PrivateKey, msg: Buffer): Buffer;
|
||||
export function PrivateKey_agree(key: PrivateKey, other_key: PublicKey): Buffer;
|
||||
export function PrivateKey_getPublicKey(key: PrivateKey): PublicKey;
|
||||
export abstract class PreKeyStore {
|
||||
_savePreKey(preKeyId: number, record: PreKeyRecord): Promise<void>;
|
||||
_getPreKey(preKeyId: number): Promise<PreKeyRecord>;
|
||||
_removePreKey(preKeyId: number): Promise<void>;
|
||||
}
|
||||
|
||||
export abstract class SignedPreKeyStore {
|
||||
_saveSignedPreKey(signedPreKeyId: number, record: SignedPreKeyRecord): Promise<void>;
|
||||
_getSignedPreKey(signedPreKeyId: number): Promise<SignedPreKeyRecord>;
|
||||
}
|
||||
|
||||
export abstract class SenderKeyStore {
|
||||
_saveSenderKey(name: SenderKeyName, record: SenderKeyRecord): Promise<void>;
|
||||
_getSenderKey(name: SenderKeyName): Promise<SenderKeyRecord | null>;
|
||||
}
|
||||
|
||||
interface Wrapper<T> {
|
||||
readonly _nativeHandle: T
|
||||
}
|
||||
|
||||
|
||||
export const enum LogLevel { Error, Warn, Info, Debug, Trace }
|
||||
export function Aes256GcmSiv_Decrypt(aesGcmSiv: Wrapper<Aes256GcmSiv>, ctext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
|
||||
export function Aes256GcmSiv_Encrypt(aesGcmSiv: Wrapper<Aes256GcmSiv>, ptext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
|
||||
export function Aes256GcmSiv_New(key: Buffer): Aes256GcmSiv;
|
||||
export function CiphertextMessage_Serialize(obj: Wrapper<CiphertextMessage>): Buffer;
|
||||
export function CiphertextMessage_Type(msg: Wrapper<CiphertextMessage>): number;
|
||||
export function Fingerprint_DisplayString(obj: Wrapper<Fingerprint>): string;
|
||||
export function Fingerprint_New(iterations: number, version: number, localIdentifier: Buffer, localKey: Wrapper<PublicKey>, remoteIdentifier: Buffer, remoteKey: Wrapper<PublicKey>): Fingerprint;
|
||||
export function Fingerprint_ScannableEncoding(obj: Wrapper<Fingerprint>): Buffer;
|
||||
export function GroupCipher_Decrypt(name: Wrapper<SenderKeyName>, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
|
||||
export function GroupCipher_Encrypt(name: Wrapper<SenderKeyName>, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
|
||||
export function HKDF_DeriveSecrets(outputLength: number, version: number, ikm: Buffer, label: Buffer, salt: Buffer | null): Buffer;
|
||||
export function IdentityKeyPair_Serialize(publicKey: Wrapper<PublicKey>, privateKey: Wrapper<PrivateKey>): Buffer;
|
||||
export function PreKeyBundle_GetDeviceId(obj: Wrapper<PreKeyBundle>): number;
|
||||
export function PreKeyBundle_GetIdentityKey(p: Wrapper<PreKeyBundle>): PublicKey;
|
||||
export function PreKeyBundle_GetPreKeyId(obj: Wrapper<PreKeyBundle>): number | null;
|
||||
export function PreKeyBundle_GetPreKeyPublic(obj: Wrapper<PreKeyBundle>): PublicKey | null;
|
||||
export function PreKeyBundle_GetRegistrationId(obj: Wrapper<PreKeyBundle>): number;
|
||||
export function PreKeyBundle_GetSignedPreKeyId(obj: Wrapper<PreKeyBundle>): number;
|
||||
export function PreKeyBundle_GetSignedPreKeyPublic(obj: Wrapper<PreKeyBundle>): PublicKey;
|
||||
export function PreKeyBundle_GetSignedPreKeySignature(obj: Wrapper<PreKeyBundle>): Buffer;
|
||||
export function PreKeyBundle_New(registrationId: number, deviceId: number, prekeyId: number | null, prekey: Wrapper<PublicKey> | null, signedPrekeyId: number, signedPrekey: Wrapper<PublicKey>, signedPrekeySignature: Buffer, identityKey: Wrapper<PublicKey>): PreKeyBundle;
|
||||
export function PreKeyRecord_Deserialize(buffer: Buffer): PreKeyRecord;
|
||||
export function PreKeyRecord_GetId(obj: Wrapper<PreKeyRecord>): number;
|
||||
export function PreKeyRecord_GetPrivateKey(obj: Wrapper<PreKeyRecord>): PrivateKey;
|
||||
export function PreKeyRecord_GetPublicKey(obj: Wrapper<PreKeyRecord>): PublicKey;
|
||||
export function PreKeyRecord_New(id: number, pubKey: Wrapper<PublicKey>, privKey: Wrapper<PrivateKey>): PreKeyRecord;
|
||||
export function PreKeyRecord_Serialize(obj: Wrapper<PreKeyRecord>): Buffer;
|
||||
export function PreKeySignalMessage_Deserialize(buffer: Buffer): PreKeySignalMessage;
|
||||
export function PreKeySignalMessage_GetPreKeyId(obj: Wrapper<PreKeySignalMessage>): number | null;
|
||||
export function PreKeySignalMessage_GetRegistrationId(obj: Wrapper<PreKeySignalMessage>): number;
|
||||
export function PreKeySignalMessage_GetSignedPreKeyId(obj: Wrapper<PreKeySignalMessage>): number;
|
||||
export function PreKeySignalMessage_GetVersion(obj: Wrapper<PreKeySignalMessage>): number;
|
||||
export function PreKeySignalMessage_New(messageVersion: number, registrationId: number, preKeyId: number | null, signedPreKeyId: number, baseKey: Wrapper<PublicKey>, identityKey: Wrapper<PublicKey>, signalMessage: Wrapper<SignalMessage>): PreKeySignalMessage;
|
||||
export function PreKeySignalMessage_Serialize(obj: Wrapper<PreKeySignalMessage>): Buffer;
|
||||
export function PrivateKey_Agree(privateKey: Wrapper<PrivateKey>, publicKey: Wrapper<PublicKey>): Buffer;
|
||||
export function PrivateKey_Deserialize(buffer: Buffer): PrivateKey;
|
||||
export function PrivateKey_Generate(): PrivateKey;
|
||||
export function PrivateKey_GetPublicKey(k: Wrapper<PrivateKey>): PublicKey;
|
||||
export function PrivateKey_Serialize(obj: Wrapper<PrivateKey>): Buffer;
|
||||
export function PrivateKey_Sign(key: Wrapper<PrivateKey>, message: Buffer): Buffer;
|
||||
export function ProtocolAddress_DeviceId(obj: Wrapper<ProtocolAddress>): number;
|
||||
export function ProtocolAddress_Name(obj: Wrapper<ProtocolAddress>): string;
|
||||
export function ProtocolAddress_New(name: string, deviceId: number): ProtocolAddress;
|
||||
export function PublicKey_Compare(key1: Wrapper<PublicKey>, key2: Wrapper<PublicKey>): number;
|
||||
export function PublicKey_Deserialize(buffer: Buffer): PublicKey;
|
||||
export function PublicKey_GetPublicKeyBytes(obj: Wrapper<PublicKey>): Buffer;
|
||||
export function PublicKey_Serialize(obj: Wrapper<PublicKey>): Buffer;
|
||||
export function PublicKey_Verify(key: Wrapper<PublicKey>, message: Buffer, signature: Buffer): boolean;
|
||||
export function ScannableFingerprint_Compare(fprint1: Buffer, fprint2: Buffer): boolean;
|
||||
export function SealedSenderDecryptionResult_GetDeviceId(obj: Wrapper<SealedSenderDecryptionResult>): number;
|
||||
export function SealedSenderDecryptionResult_GetSenderE164(obj: Wrapper<SealedSenderDecryptionResult>): string | null;
|
||||
export function SealedSenderDecryptionResult_GetSenderUuid(obj: Wrapper<SealedSenderDecryptionResult>): string;
|
||||
export function SealedSenderDecryptionResult_Message(obj: Wrapper<SealedSenderDecryptionResult>): Buffer;
|
||||
export function SealedSender_DecryptMessage(message: Buffer, trustRoot: Wrapper<PublicKey>, timestamp: number, localE164: string|null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<SealedSenderDecryptionResult>;
|
||||
export function SealedSender_DecryptToUsmc(message: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
|
||||
export function SealedSender_EncryptMessage(message: Buffer, address: Wrapper<ProtocolAddress>, senderCert: Wrapper<SenderCertificate>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
|
||||
export function SenderCertificate_Deserialize(buffer: Buffer): SenderCertificate;
|
||||
export function SenderCertificate_GetCertificate(obj: Wrapper<SenderCertificate>): Buffer;
|
||||
export function SenderCertificate_GetDeviceId(obj: Wrapper<SenderCertificate>): number;
|
||||
export function SenderCertificate_GetExpiration(obj: Wrapper<SenderCertificate>): number;
|
||||
export function SenderCertificate_GetKey(obj: Wrapper<SenderCertificate>): PublicKey;
|
||||
export function SenderCertificate_GetSenderE164(obj: Wrapper<SenderCertificate>): string | null;
|
||||
export function SenderCertificate_GetSenderUuid(obj: Wrapper<SenderCertificate>): string;
|
||||
export function SenderCertificate_GetSerialized(obj: Wrapper<SenderCertificate>): Buffer;
|
||||
export function SenderCertificate_GetServerCertificate(cert: Wrapper<SenderCertificate>): ServerCertificate;
|
||||
export function SenderCertificate_GetSignature(obj: Wrapper<SenderCertificate>): Buffer;
|
||||
export function SenderCertificate_New(senderUuid: string, senderE164: string | null, senderDeviceId: number, senderKey: Wrapper<PublicKey>, expiration: number, signerCert: Wrapper<ServerCertificate>, signerKey: Wrapper<PrivateKey>): SenderCertificate;
|
||||
export function SenderCertificate_Validate(cert: Wrapper<SenderCertificate>, key: Wrapper<PublicKey>, time: number): boolean;
|
||||
export function SenderKeyDistributionMessage_Create(name: Wrapper<SenderKeyName>, store: SenderKeyStore): Promise<SenderKeyDistributionMessage>;
|
||||
export function SenderKeyDistributionMessage_Deserialize(buffer: Buffer): SenderKeyDistributionMessage;
|
||||
export function SenderKeyDistributionMessage_GetChainKey(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
|
||||
export function SenderKeyDistributionMessage_GetId(obj: Wrapper<SenderKeyDistributionMessage>): number;
|
||||
export function SenderKeyDistributionMessage_GetIteration(obj: Wrapper<SenderKeyDistributionMessage>): number;
|
||||
export function SenderKeyDistributionMessage_New(keyId: number, iteration: number, chainkey: Buffer, pk: Wrapper<PublicKey>): SenderKeyDistributionMessage;
|
||||
export function SenderKeyDistributionMessage_Process(name: Wrapper<SenderKeyName>, msg: Wrapper<SenderKeyDistributionMessage>, store: SenderKeyStore): Promise<void>;
|
||||
export function SenderKeyDistributionMessage_Serialize(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
|
||||
export function SenderKeyMessage_Deserialize(buffer: Buffer): SenderKeyMessage;
|
||||
export function SenderKeyMessage_GetCipherText(obj: Wrapper<SenderKeyMessage>): Buffer;
|
||||
export function SenderKeyMessage_GetIteration(obj: Wrapper<SenderKeyMessage>): number;
|
||||
export function SenderKeyMessage_GetKeyId(obj: Wrapper<SenderKeyMessage>): number;
|
||||
export function SenderKeyMessage_New(keyId: number, iteration: number, ciphertext: Buffer, pk: Wrapper<PrivateKey>): SenderKeyMessage;
|
||||
export function SenderKeyMessage_Serialize(obj: Wrapper<SenderKeyMessage>): Buffer;
|
||||
export function SenderKeyMessage_VerifySignature(skm: Wrapper<SenderKeyMessage>, pubkey: Wrapper<PublicKey>): boolean;
|
||||
export function SenderKeyName_GetGroupId(obj: Wrapper<SenderKeyName>): string;
|
||||
export function SenderKeyName_GetSenderDeviceId(skn: Wrapper<SenderKeyName>): number;
|
||||
export function SenderKeyName_GetSenderName(obj: Wrapper<SenderKeyName>): string;
|
||||
export function SenderKeyName_New(groupId: string, senderName: string, senderDeviceId: number): SenderKeyName;
|
||||
export function SenderKeyRecord_Deserialize(buffer: Buffer): SenderKeyRecord;
|
||||
export function SenderKeyRecord_New(): SenderKeyRecord;
|
||||
export function SenderKeyRecord_Serialize(obj: Wrapper<SenderKeyRecord>): Buffer;
|
||||
export function ServerCertificate_Deserialize(buffer: Buffer): ServerCertificate;
|
||||
export function ServerCertificate_GetCertificate(obj: Wrapper<ServerCertificate>): Buffer;
|
||||
export function ServerCertificate_GetKey(obj: Wrapper<ServerCertificate>): PublicKey;
|
||||
export function ServerCertificate_GetKeyId(obj: Wrapper<ServerCertificate>): number;
|
||||
export function ServerCertificate_GetSerialized(obj: Wrapper<ServerCertificate>): Buffer;
|
||||
export function ServerCertificate_GetSignature(obj: Wrapper<ServerCertificate>): Buffer;
|
||||
export function ServerCertificate_New(keyId: number, serverKey: Wrapper<PublicKey>, trustRoot: Wrapper<PrivateKey>): ServerCertificate;
|
||||
export function SessionBuilder_ProcessPreKeyBundle(bundle: Wrapper<PreKeyBundle>, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<void>;
|
||||
export function SessionCipher_DecryptPreKeySignalMessage(message: Wrapper<PreKeySignalMessage>, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<Buffer>;
|
||||
export function SessionCipher_DecryptSignalMessage(message: Wrapper<SignalMessage>, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
|
||||
export function SessionCipher_EncryptMessage(message: Buffer, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<CiphertextMessage>;
|
||||
export function SessionRecord_ArchiveCurrentState(sessionRecord: Wrapper<SessionRecord>): void;
|
||||
export function SessionRecord_Deserialize(buffer: Buffer): SessionRecord;
|
||||
export function SessionRecord_GetLocalRegistrationId(obj: Wrapper<SessionRecord>): number;
|
||||
export function SessionRecord_GetRemoteRegistrationId(obj: Wrapper<SessionRecord>): number;
|
||||
export function SessionRecord_Serialize(obj: Wrapper<SessionRecord>): Buffer;
|
||||
export function SignalMessage_Deserialize(buffer: Buffer): SignalMessage;
|
||||
export function SignalMessage_GetBody(obj: Wrapper<SignalMessage>): Buffer;
|
||||
export function SignalMessage_GetCounter(obj: Wrapper<SignalMessage>): number;
|
||||
export function SignalMessage_GetMessageVersion(obj: Wrapper<SignalMessage>): number;
|
||||
export function SignalMessage_GetSerialized(obj: Wrapper<SignalMessage>): Buffer;
|
||||
export function SignalMessage_New(messageVersion: number, macKey: Buffer, senderRatchetKey: Wrapper<PublicKey>, counter: number, previousCounter: number, ciphertext: Buffer, senderIdentityKey: Wrapper<PublicKey>, receiverIdentityKey: Wrapper<PublicKey>): SignalMessage;
|
||||
export function SignalMessage_VerifyMac(msg: Wrapper<SignalMessage>, senderIdentityKey: Wrapper<PublicKey>, receiverIdentityKey: Wrapper<PublicKey>, macKey: Buffer): boolean;
|
||||
export function SignedPreKeyRecord_Deserialize(buffer: Buffer): SignedPreKeyRecord;
|
||||
export function SignedPreKeyRecord_GetId(obj: Wrapper<SignedPreKeyRecord>): number;
|
||||
export function SignedPreKeyRecord_GetPrivateKey(obj: Wrapper<SignedPreKeyRecord>): PrivateKey;
|
||||
export function SignedPreKeyRecord_GetPublicKey(obj: Wrapper<SignedPreKeyRecord>): PublicKey;
|
||||
export function SignedPreKeyRecord_GetSignature(obj: Wrapper<SignedPreKeyRecord>): Buffer;
|
||||
export function SignedPreKeyRecord_GetTimestamp(obj: Wrapper<SignedPreKeyRecord>): number;
|
||||
export function SignedPreKeyRecord_New(id: number, timestamp: number, pubKey: Wrapper<PublicKey>, privKey: Wrapper<PrivateKey>, signature: Buffer): SignedPreKeyRecord;
|
||||
export function SignedPreKeyRecord_Serialize(obj: Wrapper<SignedPreKeyRecord>): Buffer;
|
||||
export function UnidentifiedSenderMessageContent_Deserialize(buffer: Buffer): UnidentifiedSenderMessageContent;
|
||||
export function UnidentifiedSenderMessageContent_GetContents(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
|
||||
export function UnidentifiedSenderMessageContent_GetMsgType(m: Wrapper<UnidentifiedSenderMessageContent>): number;
|
||||
export function UnidentifiedSenderMessageContent_GetSenderCert(m: Wrapper<UnidentifiedSenderMessageContent>): SenderCertificate;
|
||||
export function UnidentifiedSenderMessageContent_Serialize(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
|
||||
export function initLogger(maxLevel: LogLevel, callback: (level: LogLevel, target: string, file: string | null, line: number | null, message: string) => void): void
|
||||
interface Aes256GcmSiv { readonly __type: unique symbol; }
|
||||
interface CiphertextMessage { readonly __type: unique symbol; }
|
||||
interface Fingerprint { readonly __type: unique symbol; }
|
||||
interface PreKeyBundle { readonly __type: unique symbol; }
|
||||
interface PreKeyRecord { readonly __type: unique symbol; }
|
||||
interface PreKeySignalMessage { readonly __type: unique symbol; }
|
||||
interface PrivateKey { readonly __type: unique symbol; }
|
||||
interface ProtocolAddress { readonly __type: unique symbol; }
|
||||
interface PublicKey { readonly __type: unique symbol; }
|
||||
interface SealedSenderDecryptionResult { readonly __type: unique symbol; }
|
||||
interface SenderCertificate { readonly __type: unique symbol; }
|
||||
interface SenderKeyDistributionMessage { readonly __type: unique symbol; }
|
||||
interface SenderKeyMessage { readonly __type: unique symbol; }
|
||||
interface SenderKeyName { readonly __type: unique symbol; }
|
||||
interface SenderKeyRecord { readonly __type: unique symbol; }
|
||||
interface ServerCertificate { readonly __type: unique symbol; }
|
||||
interface SessionRecord { readonly __type: unique symbol; }
|
||||
interface SignalMessage { readonly __type: unique symbol; }
|
||||
interface SignedPreKeyRecord { readonly __type: unique symbol; }
|
||||
interface UnidentifiedSenderMessageContent { readonly __type: unique symbol; }
|
||||
|
||||
203
libsignal_client.d.ts
vendored
203
libsignal_client.d.ts
vendored
@ -1,32 +1,189 @@
|
||||
//
|
||||
// Copyright 2020 Signal Messenger, LLC.
|
||||
// Copyright 2020-2021 Signal Messenger, LLC.
|
||||
// SPDX-License-Identifier: AGPL-3.0-only
|
||||
//
|
||||
|
||||
/* eslint-disable import/prefer-default-export */
|
||||
// WARNING: this file was automatically generated
|
||||
|
||||
// FIXME: Eventually we should be able to autogenerate this.
|
||||
|
||||
// Newtype pattern from https://kubyshkin.name/posts/newtype-in-typescript/
|
||||
interface PublicKey {
|
||||
readonly __type: unique symbol;
|
||||
export abstract class IdentityKeyStore {
|
||||
_getIdentityKey(): Promise<PrivateKey>;
|
||||
_getLocalRegistrationId(): Promise<number>;
|
||||
_saveIdentity(name: ProtocolAddress, key: PublicKey): Promise<boolean>;
|
||||
_isTrustedIdentity(name: ProtocolAddress, key: PublicKey, sending: boolean): Promise<boolean>;
|
||||
_getIdentity(name: ProtocolAddress): Promise<PublicKey | null>;
|
||||
}
|
||||
|
||||
export function PublicKey_deserialize(buf: Buffer): PublicKey;
|
||||
export function PublicKey_serialize(key: PublicKey): Buffer;
|
||||
export function PublicKey_verify(
|
||||
key: PublicKey,
|
||||
msg: Buffer,
|
||||
signature: Buffer
|
||||
): boolean;
|
||||
|
||||
interface PrivateKey {
|
||||
readonly __type: unique symbol;
|
||||
export abstract class SessionStore {
|
||||
_saveSession(addr: ProtocolAddress, record: SessionRecord): Promise<void>;
|
||||
_getSession(addr: ProtocolAddress): Promise<SessionRecord | null>;
|
||||
}
|
||||
|
||||
export function PrivateKey_generate(): PrivateKey;
|
||||
export function PrivateKey_deserialize(buf: Buffer): PrivateKey;
|
||||
export function PrivateKey_serialize(key: PrivateKey): Buffer;
|
||||
export function PrivateKey_sign(key: PrivateKey, msg: Buffer): Buffer;
|
||||
export function PrivateKey_agree(key: PrivateKey, other_key: PublicKey): Buffer;
|
||||
export function PrivateKey_getPublicKey(key: PrivateKey): PublicKey;
|
||||
export abstract class PreKeyStore {
|
||||
_savePreKey(preKeyId: number, record: PreKeyRecord): Promise<void>;
|
||||
_getPreKey(preKeyId: number): Promise<PreKeyRecord>;
|
||||
_removePreKey(preKeyId: number): Promise<void>;
|
||||
}
|
||||
|
||||
export abstract class SignedPreKeyStore {
|
||||
_saveSignedPreKey(signedPreKeyId: number, record: SignedPreKeyRecord): Promise<void>;
|
||||
_getSignedPreKey(signedPreKeyId: number): Promise<SignedPreKeyRecord>;
|
||||
}
|
||||
|
||||
export abstract class SenderKeyStore {
|
||||
_saveSenderKey(name: SenderKeyName, record: SenderKeyRecord): Promise<void>;
|
||||
_getSenderKey(name: SenderKeyName): Promise<SenderKeyRecord | null>;
|
||||
}
|
||||
|
||||
interface Wrapper<T> {
|
||||
readonly _nativeHandle: T
|
||||
}
|
||||
|
||||
|
||||
export const enum LogLevel { Error, Warn, Info, Debug, Trace }
|
||||
export function Aes256GcmSiv_Decrypt(aesGcmSiv: Wrapper<Aes256GcmSiv>, ctext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
|
||||
export function Aes256GcmSiv_Encrypt(aesGcmSiv: Wrapper<Aes256GcmSiv>, ptext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
|
||||
export function Aes256GcmSiv_New(key: Buffer): Aes256GcmSiv;
|
||||
export function CiphertextMessage_Serialize(obj: Wrapper<CiphertextMessage>): Buffer;
|
||||
export function CiphertextMessage_Type(msg: Wrapper<CiphertextMessage>): number;
|
||||
export function Fingerprint_DisplayString(obj: Wrapper<Fingerprint>): string;
|
||||
export function Fingerprint_New(iterations: number, version: number, localIdentifier: Buffer, localKey: Wrapper<PublicKey>, remoteIdentifier: Buffer, remoteKey: Wrapper<PublicKey>): Fingerprint;
|
||||
export function Fingerprint_ScannableEncoding(obj: Wrapper<Fingerprint>): Buffer;
|
||||
export function GroupCipher_Decrypt(name: Wrapper<SenderKeyName>, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
|
||||
export function GroupCipher_Encrypt(name: Wrapper<SenderKeyName>, store: SenderKeyStore, message: Buffer): Promise<Buffer>;
|
||||
export function HKDF_DeriveSecrets(outputLength: number, version: number, ikm: Buffer, label: Buffer, salt: Buffer | null): Buffer;
|
||||
export function IdentityKeyPair_Serialize(publicKey: Wrapper<PublicKey>, privateKey: Wrapper<PrivateKey>): Buffer;
|
||||
export function PreKeyBundle_GetDeviceId(obj: Wrapper<PreKeyBundle>): number;
|
||||
export function PreKeyBundle_GetIdentityKey(p: Wrapper<PreKeyBundle>): PublicKey;
|
||||
export function PreKeyBundle_GetPreKeyId(obj: Wrapper<PreKeyBundle>): number | null;
|
||||
export function PreKeyBundle_GetPreKeyPublic(obj: Wrapper<PreKeyBundle>): PublicKey | null;
|
||||
export function PreKeyBundle_GetRegistrationId(obj: Wrapper<PreKeyBundle>): number;
|
||||
export function PreKeyBundle_GetSignedPreKeyId(obj: Wrapper<PreKeyBundle>): number;
|
||||
export function PreKeyBundle_GetSignedPreKeyPublic(obj: Wrapper<PreKeyBundle>): PublicKey;
|
||||
export function PreKeyBundle_GetSignedPreKeySignature(obj: Wrapper<PreKeyBundle>): Buffer;
|
||||
export function PreKeyBundle_New(registrationId: number, deviceId: number, prekeyId: number | null, prekey: Wrapper<PublicKey> | null, signedPrekeyId: number, signedPrekey: Wrapper<PublicKey>, signedPrekeySignature: Buffer, identityKey: Wrapper<PublicKey>): PreKeyBundle;
|
||||
export function PreKeyRecord_Deserialize(buffer: Buffer): PreKeyRecord;
|
||||
export function PreKeyRecord_GetId(obj: Wrapper<PreKeyRecord>): number;
|
||||
export function PreKeyRecord_GetPrivateKey(obj: Wrapper<PreKeyRecord>): PrivateKey;
|
||||
export function PreKeyRecord_GetPublicKey(obj: Wrapper<PreKeyRecord>): PublicKey;
|
||||
export function PreKeyRecord_New(id: number, pubKey: Wrapper<PublicKey>, privKey: Wrapper<PrivateKey>): PreKeyRecord;
|
||||
export function PreKeyRecord_Serialize(obj: Wrapper<PreKeyRecord>): Buffer;
|
||||
export function PreKeySignalMessage_Deserialize(buffer: Buffer): PreKeySignalMessage;
|
||||
export function PreKeySignalMessage_GetPreKeyId(obj: Wrapper<PreKeySignalMessage>): number | null;
|
||||
export function PreKeySignalMessage_GetRegistrationId(obj: Wrapper<PreKeySignalMessage>): number;
|
||||
export function PreKeySignalMessage_GetSignedPreKeyId(obj: Wrapper<PreKeySignalMessage>): number;
|
||||
export function PreKeySignalMessage_GetVersion(obj: Wrapper<PreKeySignalMessage>): number;
|
||||
export function PreKeySignalMessage_New(messageVersion: number, registrationId: number, preKeyId: number | null, signedPreKeyId: number, baseKey: Wrapper<PublicKey>, identityKey: Wrapper<PublicKey>, signalMessage: Wrapper<SignalMessage>): PreKeySignalMessage;
|
||||
export function PreKeySignalMessage_Serialize(obj: Wrapper<PreKeySignalMessage>): Buffer;
|
||||
export function PrivateKey_Agree(privateKey: Wrapper<PrivateKey>, publicKey: Wrapper<PublicKey>): Buffer;
|
||||
export function PrivateKey_Deserialize(buffer: Buffer): PrivateKey;
|
||||
export function PrivateKey_Generate(): PrivateKey;
|
||||
export function PrivateKey_GetPublicKey(k: Wrapper<PrivateKey>): PublicKey;
|
||||
export function PrivateKey_Serialize(obj: Wrapper<PrivateKey>): Buffer;
|
||||
export function PrivateKey_Sign(key: Wrapper<PrivateKey>, message: Buffer): Buffer;
|
||||
export function ProtocolAddress_DeviceId(obj: Wrapper<ProtocolAddress>): number;
|
||||
export function ProtocolAddress_Name(obj: Wrapper<ProtocolAddress>): string;
|
||||
export function ProtocolAddress_New(name: string, deviceId: number): ProtocolAddress;
|
||||
export function PublicKey_Compare(key1: Wrapper<PublicKey>, key2: Wrapper<PublicKey>): number;
|
||||
export function PublicKey_Deserialize(buffer: Buffer): PublicKey;
|
||||
export function PublicKey_GetPublicKeyBytes(obj: Wrapper<PublicKey>): Buffer;
|
||||
export function PublicKey_Serialize(obj: Wrapper<PublicKey>): Buffer;
|
||||
export function PublicKey_Verify(key: Wrapper<PublicKey>, message: Buffer, signature: Buffer): boolean;
|
||||
export function ScannableFingerprint_Compare(fprint1: Buffer, fprint2: Buffer): boolean;
|
||||
export function SealedSenderDecryptionResult_GetDeviceId(obj: Wrapper<SealedSenderDecryptionResult>): number;
|
||||
export function SealedSenderDecryptionResult_GetSenderE164(obj: Wrapper<SealedSenderDecryptionResult>): string | null;
|
||||
export function SealedSenderDecryptionResult_GetSenderUuid(obj: Wrapper<SealedSenderDecryptionResult>): string;
|
||||
export function SealedSenderDecryptionResult_Message(obj: Wrapper<SealedSenderDecryptionResult>): Buffer;
|
||||
export function SealedSender_DecryptMessage(message: Buffer, trustRoot: Wrapper<PublicKey>, timestamp: number, localE164: string|null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<SealedSenderDecryptionResult>;
|
||||
export function SealedSender_DecryptToUsmc(message: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
|
||||
export function SealedSender_EncryptMessage(message: Buffer, address: Wrapper<ProtocolAddress>, senderCert: Wrapper<SenderCertificate>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
|
||||
export function SenderCertificate_Deserialize(buffer: Buffer): SenderCertificate;
|
||||
export function SenderCertificate_GetCertificate(obj: Wrapper<SenderCertificate>): Buffer;
|
||||
export function SenderCertificate_GetDeviceId(obj: Wrapper<SenderCertificate>): number;
|
||||
export function SenderCertificate_GetExpiration(obj: Wrapper<SenderCertificate>): number;
|
||||
export function SenderCertificate_GetKey(obj: Wrapper<SenderCertificate>): PublicKey;
|
||||
export function SenderCertificate_GetSenderE164(obj: Wrapper<SenderCertificate>): string | null;
|
||||
export function SenderCertificate_GetSenderUuid(obj: Wrapper<SenderCertificate>): string;
|
||||
export function SenderCertificate_GetSerialized(obj: Wrapper<SenderCertificate>): Buffer;
|
||||
export function SenderCertificate_GetServerCertificate(cert: Wrapper<SenderCertificate>): ServerCertificate;
|
||||
export function SenderCertificate_GetSignature(obj: Wrapper<SenderCertificate>): Buffer;
|
||||
export function SenderCertificate_New(senderUuid: string, senderE164: string | null, senderDeviceId: number, senderKey: Wrapper<PublicKey>, expiration: number, signerCert: Wrapper<ServerCertificate>, signerKey: Wrapper<PrivateKey>): SenderCertificate;
|
||||
export function SenderCertificate_Validate(cert: Wrapper<SenderCertificate>, key: Wrapper<PublicKey>, time: number): boolean;
|
||||
export function SenderKeyDistributionMessage_Create(name: Wrapper<SenderKeyName>, store: SenderKeyStore): Promise<SenderKeyDistributionMessage>;
|
||||
export function SenderKeyDistributionMessage_Deserialize(buffer: Buffer): SenderKeyDistributionMessage;
|
||||
export function SenderKeyDistributionMessage_GetChainKey(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
|
||||
export function SenderKeyDistributionMessage_GetId(obj: Wrapper<SenderKeyDistributionMessage>): number;
|
||||
export function SenderKeyDistributionMessage_GetIteration(obj: Wrapper<SenderKeyDistributionMessage>): number;
|
||||
export function SenderKeyDistributionMessage_New(keyId: number, iteration: number, chainkey: Buffer, pk: Wrapper<PublicKey>): SenderKeyDistributionMessage;
|
||||
export function SenderKeyDistributionMessage_Process(name: Wrapper<SenderKeyName>, msg: Wrapper<SenderKeyDistributionMessage>, store: SenderKeyStore): Promise<void>;
|
||||
export function SenderKeyDistributionMessage_Serialize(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
|
||||
export function SenderKeyMessage_Deserialize(buffer: Buffer): SenderKeyMessage;
|
||||
export function SenderKeyMessage_GetCipherText(obj: Wrapper<SenderKeyMessage>): Buffer;
|
||||
export function SenderKeyMessage_GetIteration(obj: Wrapper<SenderKeyMessage>): number;
|
||||
export function SenderKeyMessage_GetKeyId(obj: Wrapper<SenderKeyMessage>): number;
|
||||
export function SenderKeyMessage_New(keyId: number, iteration: number, ciphertext: Buffer, pk: Wrapper<PrivateKey>): SenderKeyMessage;
|
||||
export function SenderKeyMessage_Serialize(obj: Wrapper<SenderKeyMessage>): Buffer;
|
||||
export function SenderKeyMessage_VerifySignature(skm: Wrapper<SenderKeyMessage>, pubkey: Wrapper<PublicKey>): boolean;
|
||||
export function SenderKeyName_GetGroupId(obj: Wrapper<SenderKeyName>): string;
|
||||
export function SenderKeyName_GetSenderDeviceId(skn: Wrapper<SenderKeyName>): number;
|
||||
export function SenderKeyName_GetSenderName(obj: Wrapper<SenderKeyName>): string;
|
||||
export function SenderKeyName_New(groupId: string, senderName: string, senderDeviceId: number): SenderKeyName;
|
||||
export function SenderKeyRecord_Deserialize(buffer: Buffer): SenderKeyRecord;
|
||||
export function SenderKeyRecord_New(): SenderKeyRecord;
|
||||
export function SenderKeyRecord_Serialize(obj: Wrapper<SenderKeyRecord>): Buffer;
|
||||
export function ServerCertificate_Deserialize(buffer: Buffer): ServerCertificate;
|
||||
export function ServerCertificate_GetCertificate(obj: Wrapper<ServerCertificate>): Buffer;
|
||||
export function ServerCertificate_GetKey(obj: Wrapper<ServerCertificate>): PublicKey;
|
||||
export function ServerCertificate_GetKeyId(obj: Wrapper<ServerCertificate>): number;
|
||||
export function ServerCertificate_GetSerialized(obj: Wrapper<ServerCertificate>): Buffer;
|
||||
export function ServerCertificate_GetSignature(obj: Wrapper<ServerCertificate>): Buffer;
|
||||
export function ServerCertificate_New(keyId: number, serverKey: Wrapper<PublicKey>, trustRoot: Wrapper<PrivateKey>): ServerCertificate;
|
||||
export function SessionBuilder_ProcessPreKeyBundle(bundle: Wrapper<PreKeyBundle>, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<void>;
|
||||
export function SessionCipher_DecryptPreKeySignalMessage(message: Wrapper<PreKeySignalMessage>, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<Buffer>;
|
||||
export function SessionCipher_DecryptSignalMessage(message: Wrapper<SignalMessage>, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<Buffer>;
|
||||
export function SessionCipher_EncryptMessage(message: Buffer, address: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityStore: IdentityKeyStore): Promise<CiphertextMessage>;
|
||||
export function SessionRecord_ArchiveCurrentState(sessionRecord: Wrapper<SessionRecord>): void;
|
||||
export function SessionRecord_Deserialize(buffer: Buffer): SessionRecord;
|
||||
export function SessionRecord_GetLocalRegistrationId(obj: Wrapper<SessionRecord>): number;
|
||||
export function SessionRecord_GetRemoteRegistrationId(obj: Wrapper<SessionRecord>): number;
|
||||
export function SessionRecord_Serialize(obj: Wrapper<SessionRecord>): Buffer;
|
||||
export function SignalMessage_Deserialize(buffer: Buffer): SignalMessage;
|
||||
export function SignalMessage_GetBody(obj: Wrapper<SignalMessage>): Buffer;
|
||||
export function SignalMessage_GetCounter(obj: Wrapper<SignalMessage>): number;
|
||||
export function SignalMessage_GetMessageVersion(obj: Wrapper<SignalMessage>): number;
|
||||
export function SignalMessage_GetSerialized(obj: Wrapper<SignalMessage>): Buffer;
|
||||
export function SignalMessage_New(messageVersion: number, macKey: Buffer, senderRatchetKey: Wrapper<PublicKey>, counter: number, previousCounter: number, ciphertext: Buffer, senderIdentityKey: Wrapper<PublicKey>, receiverIdentityKey: Wrapper<PublicKey>): SignalMessage;
|
||||
export function SignalMessage_VerifyMac(msg: Wrapper<SignalMessage>, senderIdentityKey: Wrapper<PublicKey>, receiverIdentityKey: Wrapper<PublicKey>, macKey: Buffer): boolean;
|
||||
export function SignedPreKeyRecord_Deserialize(buffer: Buffer): SignedPreKeyRecord;
|
||||
export function SignedPreKeyRecord_GetId(obj: Wrapper<SignedPreKeyRecord>): number;
|
||||
export function SignedPreKeyRecord_GetPrivateKey(obj: Wrapper<SignedPreKeyRecord>): PrivateKey;
|
||||
export function SignedPreKeyRecord_GetPublicKey(obj: Wrapper<SignedPreKeyRecord>): PublicKey;
|
||||
export function SignedPreKeyRecord_GetSignature(obj: Wrapper<SignedPreKeyRecord>): Buffer;
|
||||
export function SignedPreKeyRecord_GetTimestamp(obj: Wrapper<SignedPreKeyRecord>): number;
|
||||
export function SignedPreKeyRecord_New(id: number, timestamp: number, pubKey: Wrapper<PublicKey>, privKey: Wrapper<PrivateKey>, signature: Buffer): SignedPreKeyRecord;
|
||||
export function SignedPreKeyRecord_Serialize(obj: Wrapper<SignedPreKeyRecord>): Buffer;
|
||||
export function UnidentifiedSenderMessageContent_Deserialize(buffer: Buffer): UnidentifiedSenderMessageContent;
|
||||
export function UnidentifiedSenderMessageContent_GetContents(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
|
||||
export function UnidentifiedSenderMessageContent_GetMsgType(m: Wrapper<UnidentifiedSenderMessageContent>): number;
|
||||
export function UnidentifiedSenderMessageContent_GetSenderCert(m: Wrapper<UnidentifiedSenderMessageContent>): SenderCertificate;
|
||||
export function UnidentifiedSenderMessageContent_Serialize(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
|
||||
export function initLogger(maxLevel: LogLevel, callback: (level: LogLevel, target: string, file: string | null, line: number | null, message: string) => void): void
|
||||
interface Aes256GcmSiv { readonly __type: unique symbol; }
|
||||
interface CiphertextMessage { readonly __type: unique symbol; }
|
||||
interface Fingerprint { readonly __type: unique symbol; }
|
||||
interface PreKeyBundle { readonly __type: unique symbol; }
|
||||
interface PreKeyRecord { readonly __type: unique symbol; }
|
||||
interface PreKeySignalMessage { readonly __type: unique symbol; }
|
||||
interface PrivateKey { readonly __type: unique symbol; }
|
||||
interface ProtocolAddress { readonly __type: unique symbol; }
|
||||
interface PublicKey { readonly __type: unique symbol; }
|
||||
interface SealedSenderDecryptionResult { readonly __type: unique symbol; }
|
||||
interface SenderCertificate { readonly __type: unique symbol; }
|
||||
interface SenderKeyDistributionMessage { readonly __type: unique symbol; }
|
||||
interface SenderKeyMessage { readonly __type: unique symbol; }
|
||||
interface SenderKeyName { readonly __type: unique symbol; }
|
||||
interface SenderKeyRecord { readonly __type: unique symbol; }
|
||||
interface ServerCertificate { readonly __type: unique symbol; }
|
||||
interface SessionRecord { readonly __type: unique symbol; }
|
||||
interface SignalMessage { readonly __type: unique symbol; }
|
||||
interface SignedPreKeyRecord { readonly __type: unique symbol; }
|
||||
interface UnidentifiedSenderMessageContent { readonly __type: unique symbol; }
|
||||
|
||||
10
package.json
10
package.json
@ -1,13 +1,14 @@
|
||||
{
|
||||
"name": "signal-client",
|
||||
"version": "0.2.0",
|
||||
"version": "0.3.0",
|
||||
"license": "AGPL-3.0-only",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"scripts": {
|
||||
"tsc": "tsc && cp *.d.ts dist",
|
||||
"build": "node-gyp build",
|
||||
"tsc": "tsc",
|
||||
"clean": "rimraf dist build",
|
||||
"test": "electron-mocha --recursive dist/test",
|
||||
"test": "electron-mocha --recursive dist/test --require source-map-support/register",
|
||||
"lint": "eslint . --ext .js,.jsx,.ts,.tsx",
|
||||
"format": "p() { prettier ${@:- --write} package.json '*.js' '**/*.{css,js,json,md,scss,ts,tsx}'; }; p"
|
||||
},
|
||||
@ -22,7 +23,7 @@
|
||||
"@typescript-eslint/eslint-plugin": "^4.6.0",
|
||||
"@typescript-eslint/parser": "^4.6.0",
|
||||
"chai": "4.2.0",
|
||||
"electron": "8.2.5",
|
||||
"electron": "11.2.3",
|
||||
"electron-mocha": "8.1.1",
|
||||
"eslint": "^7.12.1",
|
||||
"eslint-config-prettier": "6.15.0",
|
||||
@ -34,6 +35,7 @@
|
||||
"node-gyp": "^7.1.2",
|
||||
"prettier": "1.19.1",
|
||||
"rimraf": "3.0.1",
|
||||
"source-map-support": "^0.5.19",
|
||||
"typescript": "3.7.4"
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user