2020-10-23 20:44:41 +02:00
|
|
|
//
|
2022-06-17 22:10:10 +02:00
|
|
|
// Copyright 2020-2022 Signal Messenger, LLC.
|
2020-10-23 20:44:41 +02:00
|
|
|
// SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
//
|
|
|
|
|
2021-01-26 23:59:39 +01:00
|
|
|
// WARNING: this file was automatically generated
|
2020-12-04 03:01:59 +01:00
|
|
|
|
2021-03-12 20:36:24 +01:00
|
|
|
type Uuid = Buffer;
|
2022-06-17 22:10:10 +02:00
|
|
|
|
|
|
|
/// A Native.Timestamp may be measured in seconds or in milliseconds;
|
|
|
|
/// what's important is that it's an integer less than Number.MAX_SAFE_INTEGER.
|
2021-10-30 01:27:45 +02:00
|
|
|
type Timestamp = number;
|
2021-03-12 20:36:24 +01:00
|
|
|
|
2021-02-16 21:45:16 +01:00
|
|
|
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 abstract class SessionStore {
|
|
|
|
_saveSession(addr: ProtocolAddress, record: SessionRecord): Promise<void>;
|
|
|
|
_getSession(addr: ProtocolAddress): Promise<SessionRecord | null>;
|
|
|
|
}
|
|
|
|
|
|
|
|
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>;
|
|
|
|
}
|
|
|
|
|
2023-06-02 19:42:39 +02:00
|
|
|
export abstract class KyberPreKeyStore {
|
|
|
|
_saveKyberPreKey(kyberPreKeyId: number, record: KyberPreKeyRecord): Promise<void>;
|
|
|
|
_getKyberPreKey(kyberPreKeyId: number): Promise<KyberPreKeyRecord>;
|
|
|
|
_markKyberPreKeyUsed(kyberPreKeyId: number): Promise<void>;
|
|
|
|
}
|
|
|
|
|
2021-02-08 20:35:40 +01:00
|
|
|
export abstract class SenderKeyStore {
|
2021-03-12 20:36:24 +01:00
|
|
|
_saveSenderKey(sender: ProtocolAddress, distributionId: Uuid, record: SenderKeyRecord): Promise<void>;
|
|
|
|
_getSenderKey(sender: ProtocolAddress, distributionId: Uuid): Promise<SenderKeyRecord | null>;
|
2021-02-08 20:35:40 +01:00
|
|
|
}
|
|
|
|
|
2023-03-13 21:53:06 +01:00
|
|
|
export abstract class InputStream {
|
|
|
|
_read(amount: number): Promise<Buffer>;
|
|
|
|
_skip(amount: number): Promise<void>;
|
|
|
|
}
|
|
|
|
|
2021-02-10 03:34:42 +01:00
|
|
|
interface Wrapper<T> {
|
|
|
|
readonly _nativeHandle: T
|
|
|
|
}
|
|
|
|
|
2021-10-28 23:53:42 +02:00
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
|
|
type Serialized<T> = Buffer;
|
|
|
|
|
Bridge: add support for strongly-typed Node errors
Within a new 'Errors' module, we have a base class that indicates this
is a strongly-typed error, and an enum to identify what kind of error
it is and thus what extra properties it might have. TypeScript's type
narrowing support make this possible to do safely as long as all
instances of the base class do in fact have the extra properties that
match their code (and do not have an invalid code).
To expose this to Rust (via Neon):
- After loading the Rust library into Node, set an 'Errors' property
with the relevant error types on the module object.
- Whenever a bridge_fn produces an error, pass it to a new
SignalNodeError::throw API along with the 'this' object, which is
assumed to have to be the object with the 'Errors' property.
This is a little less tidy than how we do Java exceptions, but it
comes from not having access to the error classes by some kind of
absolute name. Alternate approaches considered include:
- Use an initialized-once global. Downside: would not work if you ever
had more than one Node engine live in a process, or quit and restarted
it.
- Store the errors on the global object under some long, complicated
key (like "org.signal.libsignal-client.Errors"). Downside: pollutes
the global object.
- Generate the base class using Neon instead of writing it in
TypeScript. Downsides: inconvenient, difficult to maintain, harder to
use /from/ TypeScript.
2021-03-30 03:07:59 +02:00
|
|
|
export function registerErrors(errorsModule: Record<string, unknown>): void;
|
2021-02-16 21:45:16 +01:00
|
|
|
|
2021-03-09 19:17:07 +01:00
|
|
|
export const enum LogLevel { Error = 1, Warn, Info, Debug, Trace }
|
2021-02-10 03:34:42 +01:00
|
|
|
export function Aes256GcmSiv_Decrypt(aesGcmSiv: Wrapper<Aes256GcmSiv>, ctext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
|
2021-06-17 03:36:36 +02:00
|
|
|
export function Aes256GcmSiv_Encrypt(aesGcmSivObj: Wrapper<Aes256GcmSiv>, ptext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
|
2021-01-27 00:43:02 +01:00
|
|
|
export function Aes256GcmSiv_New(key: Buffer): Aes256GcmSiv;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function AuthCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
|
2023-02-03 03:10:55 +01:00
|
|
|
export function AuthCredentialPresentation_GetPniCiphertext(presentationBytes: Buffer): Buffer | null;
|
2022-06-22 00:11:57 +02:00
|
|
|
export function AuthCredentialPresentation_GetRedemptionTime(presentationBytes: Buffer): Timestamp;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function AuthCredentialPresentation_GetUuidCiphertext(presentationBytes: Buffer): Serialized<UuidCiphertext>;
|
|
|
|
export function AuthCredentialResponse_CheckValidContents(buffer: Buffer): void;
|
2022-06-22 00:11:57 +02:00
|
|
|
export function AuthCredentialWithPniResponse_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function AuthCredentialWithPni_CheckValidContents(buffer: Buffer): void;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function AuthCredential_CheckValidContents(buffer: Buffer): void;
|
2023-04-26 02:18:05 +02:00
|
|
|
export function CallLinkAuthCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
|
|
|
|
export function CallLinkAuthCredentialPresentation_GetUserId(presentationBytes: Buffer): Serialized<UuidCiphertext>;
|
|
|
|
export function CallLinkAuthCredentialPresentation_Verify(presentationBytes: Buffer, now: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer): void;
|
|
|
|
export function CallLinkAuthCredentialResponse_CheckValidContents(responseBytes: Buffer): void;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function CallLinkAuthCredentialResponse_IssueDeterministic(userId: Buffer, redemptionTime: Timestamp, paramsBytes: Buffer, randomness: Buffer): Buffer;
|
|
|
|
export function CallLinkAuthCredentialResponse_Receive(responseBytes: Buffer, userId: Buffer, redemptionTime: Timestamp, paramsBytes: Buffer): Buffer;
|
2023-04-26 02:18:05 +02:00
|
|
|
export function CallLinkAuthCredential_CheckValidContents(credentialBytes: Buffer): void;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function CallLinkAuthCredential_PresentDeterministic(credentialBytes: Buffer, userId: Buffer, redemptionTime: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer, randomness: Buffer): Buffer;
|
zkgroup: Add a "Create Call Link" credential
This will allow a user to request to create a call link from the chat
server without revealing anything about the room, and then later
actually create it by giving the room ID to the calling server without
identifying themself.
This involves a new, stripped-down GenericServer{Secret,Public}Params,
which currently only contains a generic "zkcredential" key. Apart from
the calling server not needing to handle all the credentials that the
group storage server supports, the structure of zkcredential means it
is safe to use the same key for multiple kinds of credentials.
Similarly, CallLink{Secret,Public}Params plays the same role as
Group{Secret,Public}Params for encrypting user IDs when talking to the
calling server.
Following from that, the APIs for CreateCallLinkCredentials are
located on the individual types (RequestContext, Request, Response,
Credential, Presentation) rather than all being on the Server*Params
types; adding a new credential type won't change the API of the
Server*Params types at all.
The main Server*Params may make use of zkcredential in the future as
well, but for now it's only for new Signal servers that want to use
zero-knowledge credentials.
2023-04-26 01:53:42 +02:00
|
|
|
export function CallLinkPublicParams_CheckValidContents(paramsBytes: Buffer): void;
|
|
|
|
export function CallLinkSecretParams_CheckValidContents(paramsBytes: Buffer): void;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function CallLinkSecretParams_DecryptUserId(paramsBytes: Buffer, userId: Serialized<UuidCiphertext>): Buffer;
|
zkgroup: Add a "Create Call Link" credential
This will allow a user to request to create a call link from the chat
server without revealing anything about the room, and then later
actually create it by giving the room ID to the calling server without
identifying themself.
This involves a new, stripped-down GenericServer{Secret,Public}Params,
which currently only contains a generic "zkcredential" key. Apart from
the calling server not needing to handle all the credentials that the
group storage server supports, the structure of zkcredential means it
is safe to use the same key for multiple kinds of credentials.
Similarly, CallLink{Secret,Public}Params plays the same role as
Group{Secret,Public}Params for encrypting user IDs when talking to the
calling server.
Following from that, the APIs for CreateCallLinkCredentials are
located on the individual types (RequestContext, Request, Response,
Credential, Presentation) rather than all being on the Server*Params
types; adding a new credential type won't change the API of the
Server*Params types at all.
The main Server*Params may make use of zkcredential in the future as
well, but for now it's only for new Signal servers that want to use
zero-knowledge credentials.
2023-04-26 01:53:42 +02:00
|
|
|
export function CallLinkSecretParams_DeriveFromRootKey(rootKey: Buffer): Buffer;
|
|
|
|
export function CallLinkSecretParams_GetPublicParams(paramsBytes: Buffer): Buffer;
|
2023-02-14 16:41:51 +01:00
|
|
|
export function Cds2ClientState_New(mrenclave: Buffer, attestationMsg: Buffer, currentTimestamp: Timestamp): SgxClientState;
|
2021-05-26 04:51:55 +02:00
|
|
|
export function CiphertextMessage_FromPlaintextContent(m: Wrapper<PlaintextContent>): CiphertextMessage;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function CiphertextMessage_Serialize(obj: Wrapper<CiphertextMessage>): Buffer;
|
|
|
|
export function CiphertextMessage_Type(msg: Wrapper<CiphertextMessage>): number;
|
zkgroup: Add a "Create Call Link" credential
This will allow a user to request to create a call link from the chat
server without revealing anything about the room, and then later
actually create it by giving the room ID to the calling server without
identifying themself.
This involves a new, stripped-down GenericServer{Secret,Public}Params,
which currently only contains a generic "zkcredential" key. Apart from
the calling server not needing to handle all the credentials that the
group storage server supports, the structure of zkcredential means it
is safe to use the same key for multiple kinds of credentials.
Similarly, CallLink{Secret,Public}Params plays the same role as
Group{Secret,Public}Params for encrypting user IDs when talking to the
calling server.
Following from that, the APIs for CreateCallLinkCredentials are
located on the individual types (RequestContext, Request, Response,
Credential, Presentation) rather than all being on the Server*Params
types; adding a new credential type won't change the API of the
Server*Params types at all.
The main Server*Params may make use of zkcredential in the future as
well, but for now it's only for new Signal servers that want to use
zero-knowledge credentials.
2023-04-26 01:53:42 +02:00
|
|
|
export function CreateCallLinkCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
|
|
|
|
export function CreateCallLinkCredentialPresentation_Verify(presentationBytes: Buffer, roomId: Buffer, now: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer): void;
|
|
|
|
export function CreateCallLinkCredentialRequestContext_CheckValidContents(contextBytes: Buffer): void;
|
|
|
|
export function CreateCallLinkCredentialRequestContext_GetRequest(contextBytes: Buffer): Buffer;
|
|
|
|
export function CreateCallLinkCredentialRequestContext_NewDeterministic(roomId: Buffer, randomness: Buffer): Buffer;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function CreateCallLinkCredentialRequestContext_ReceiveResponse(contextBytes: Buffer, responseBytes: Buffer, userId: Buffer, paramsBytes: Buffer): Buffer;
|
zkgroup: Add a "Create Call Link" credential
This will allow a user to request to create a call link from the chat
server without revealing anything about the room, and then later
actually create it by giving the room ID to the calling server without
identifying themself.
This involves a new, stripped-down GenericServer{Secret,Public}Params,
which currently only contains a generic "zkcredential" key. Apart from
the calling server not needing to handle all the credentials that the
group storage server supports, the structure of zkcredential means it
is safe to use the same key for multiple kinds of credentials.
Similarly, CallLink{Secret,Public}Params plays the same role as
Group{Secret,Public}Params for encrypting user IDs when talking to the
calling server.
Following from that, the APIs for CreateCallLinkCredentials are
located on the individual types (RequestContext, Request, Response,
Credential, Presentation) rather than all being on the Server*Params
types; adding a new credential type won't change the API of the
Server*Params types at all.
The main Server*Params may make use of zkcredential in the future as
well, but for now it's only for new Signal servers that want to use
zero-knowledge credentials.
2023-04-26 01:53:42 +02:00
|
|
|
export function CreateCallLinkCredentialRequest_CheckValidContents(requestBytes: Buffer): void;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function CreateCallLinkCredentialRequest_IssueDeterministic(requestBytes: Buffer, userId: Buffer, timestamp: Timestamp, paramsBytes: Buffer, randomness: Buffer): Buffer;
|
zkgroup: Add a "Create Call Link" credential
This will allow a user to request to create a call link from the chat
server without revealing anything about the room, and then later
actually create it by giving the room ID to the calling server without
identifying themself.
This involves a new, stripped-down GenericServer{Secret,Public}Params,
which currently only contains a generic "zkcredential" key. Apart from
the calling server not needing to handle all the credentials that the
group storage server supports, the structure of zkcredential means it
is safe to use the same key for multiple kinds of credentials.
Similarly, CallLink{Secret,Public}Params plays the same role as
Group{Secret,Public}Params for encrypting user IDs when talking to the
calling server.
Following from that, the APIs for CreateCallLinkCredentials are
located on the individual types (RequestContext, Request, Response,
Credential, Presentation) rather than all being on the Server*Params
types; adding a new credential type won't change the API of the
Server*Params types at all.
The main Server*Params may make use of zkcredential in the future as
well, but for now it's only for new Signal servers that want to use
zero-knowledge credentials.
2023-04-26 01:53:42 +02:00
|
|
|
export function CreateCallLinkCredentialResponse_CheckValidContents(responseBytes: Buffer): void;
|
|
|
|
export function CreateCallLinkCredential_CheckValidContents(paramsBytes: Buffer): void;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function CreateCallLinkCredential_PresentDeterministic(credentialBytes: Buffer, roomId: Buffer, userId: Buffer, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer, randomness: Buffer): Buffer;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function DecryptionErrorMessage_Deserialize(data: Buffer): DecryptionErrorMessage;
|
2021-05-26 04:51:55 +02:00
|
|
|
export function DecryptionErrorMessage_ExtractFromSerializedContent(bytes: Buffer): DecryptionErrorMessage;
|
2021-10-30 01:27:45 +02:00
|
|
|
export function DecryptionErrorMessage_ForOriginalMessage(originalBytes: Buffer, originalType: number, originalTimestamp: Timestamp, originalSenderDeviceId: number): DecryptionErrorMessage;
|
2021-05-27 02:19:07 +02:00
|
|
|
export function DecryptionErrorMessage_GetDeviceId(obj: Wrapper<DecryptionErrorMessage>): number;
|
2021-05-26 04:51:55 +02:00
|
|
|
export function DecryptionErrorMessage_GetRatchetKey(m: Wrapper<DecryptionErrorMessage>): PublicKey | null;
|
2021-10-30 01:27:45 +02:00
|
|
|
export function DecryptionErrorMessage_GetTimestamp(obj: Wrapper<DecryptionErrorMessage>): Timestamp;
|
2021-05-26 04:51:55 +02:00
|
|
|
export function DecryptionErrorMessage_Serialize(obj: Wrapper<DecryptionErrorMessage>): Buffer;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ExpiringProfileKeyCredentialResponse_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ExpiringProfileKeyCredential_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ExpiringProfileKeyCredential_GetExpirationTime(credential: Serialized<ExpiringProfileKeyCredential>): Timestamp;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
zkgroup: Add a "Create Call Link" credential
This will allow a user to request to create a call link from the chat
server without revealing anything about the room, and then later
actually create it by giving the room ID to the calling server without
identifying themself.
This involves a new, stripped-down GenericServer{Secret,Public}Params,
which currently only contains a generic "zkcredential" key. Apart from
the calling server not needing to handle all the credentials that the
group storage server supports, the structure of zkcredential means it
is safe to use the same key for multiple kinds of credentials.
Similarly, CallLink{Secret,Public}Params plays the same role as
Group{Secret,Public}Params for encrypting user IDs when talking to the
calling server.
Following from that, the APIs for CreateCallLinkCredentials are
located on the individual types (RequestContext, Request, Response,
Credential, Presentation) rather than all being on the Server*Params
types; adding a new credential type won't change the API of the
Server*Params types at all.
The main Server*Params may make use of zkcredential in the future as
well, but for now it's only for new Signal servers that want to use
zero-knowledge credentials.
2023-04-26 01:53:42 +02:00
|
|
|
export function GenericServerPublicParams_CheckValidContents(paramsBytes: Buffer): void;
|
|
|
|
export function GenericServerSecretParams_CheckValidContents(paramsBytes: Buffer): void;
|
|
|
|
export function GenericServerSecretParams_GenerateDeterministic(randomness: Buffer): Buffer;
|
|
|
|
export function GenericServerSecretParams_GetPublicParams(paramsBytes: Buffer): Buffer;
|
2023-07-21 02:16:45 +02:00
|
|
|
export function GroupCipher_DecryptMessage(sender: Wrapper<ProtocolAddress>, message: Buffer, store: SenderKeyStore): Promise<Buffer>;
|
|
|
|
export function GroupCipher_EncryptMessage(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, message: Buffer, store: SenderKeyStore): Promise<CiphertextMessage>;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function GroupMasterKey_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function GroupPublicParams_CheckValidContents(buffer: Buffer): void;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function GroupPublicParams_GetGroupIdentifier(groupPublicParams: Serialized<GroupPublicParams>): Buffer;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function GroupSecretParams_CheckValidContents(buffer: Buffer): void;
|
2021-11-05 19:31:55 +01:00
|
|
|
export function GroupSecretParams_DecryptBlobWithPadding(params: Serialized<GroupSecretParams>, ciphertext: Buffer): Buffer;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function GroupSecretParams_DecryptProfileKey(params: Serialized<GroupSecretParams>, profileKey: Serialized<ProfileKeyCiphertext>, userId: Buffer): Serialized<ProfileKey>;
|
2023-07-13 01:29:20 +02:00
|
|
|
export function GroupSecretParams_DecryptServiceId(params: Serialized<GroupSecretParams>, ciphertext: Serialized<UuidCiphertext>): Buffer;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function GroupSecretParams_DeriveFromMasterKey(masterKey: Serialized<GroupMasterKey>): Serialized<GroupSecretParams>;
|
2021-11-05 19:31:55 +01:00
|
|
|
export function GroupSecretParams_EncryptBlobWithPaddingDeterministic(params: Serialized<GroupSecretParams>, randomness: Buffer, plaintext: Buffer, paddingLen: number): Buffer;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function GroupSecretParams_EncryptProfileKey(params: Serialized<GroupSecretParams>, profileKey: Serialized<ProfileKey>, userId: Buffer): Serialized<ProfileKeyCiphertext>;
|
2023-07-13 01:29:20 +02:00
|
|
|
export function GroupSecretParams_EncryptServiceId(params: Serialized<GroupSecretParams>, serviceId: Buffer): Serialized<UuidCiphertext>;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function GroupSecretParams_GenerateDeterministic(randomness: Buffer): Serialized<GroupSecretParams>;
|
|
|
|
export function GroupSecretParams_GetMasterKey(params: Serialized<GroupSecretParams>): Serialized<GroupMasterKey>;
|
|
|
|
export function GroupSecretParams_GetPublicParams(params: Serialized<GroupSecretParams>): Serialized<GroupPublicParams>;
|
2021-10-09 03:17:45 +02:00
|
|
|
export function HKDF_DeriveSecrets(outputLength: number, ikm: Buffer, label: Buffer | null, salt: Buffer | null): Buffer;
|
2021-10-27 02:51:25 +02:00
|
|
|
export function HsmEnclaveClient_CompleteHandshake(cli: Wrapper<HsmEnclaveClient>, handshakeReceived: Buffer): void;
|
|
|
|
export function HsmEnclaveClient_EstablishedRecv(cli: Wrapper<HsmEnclaveClient>, receivedCiphertext: Buffer): Buffer;
|
|
|
|
export function HsmEnclaveClient_EstablishedSend(cli: Wrapper<HsmEnclaveClient>, plaintextToSend: Buffer): Buffer;
|
|
|
|
export function HsmEnclaveClient_InitialRequest(obj: Wrapper<HsmEnclaveClient>): Buffer;
|
|
|
|
export function HsmEnclaveClient_New(trustedPublicKey: Buffer, trustedCodeHashes: Buffer): HsmEnclaveClient;
|
2022-07-20 02:21:58 +02:00
|
|
|
export function IdentityKeyPair_Deserialize(buffer: Buffer): {publicKey:PublicKey,privateKey:PrivateKey};
|
2021-02-10 03:34:42 +01:00
|
|
|
export function IdentityKeyPair_Serialize(publicKey: Wrapper<PublicKey>, privateKey: Wrapper<PrivateKey>): Buffer;
|
2021-11-11 00:15:08 +01:00
|
|
|
export function IdentityKeyPair_SignAlternateIdentity(publicKey: Wrapper<PublicKey>, privateKey: Wrapper<PrivateKey>, otherIdentity: Wrapper<PublicKey>): Buffer;
|
|
|
|
export function IdentityKey_VerifyAlternateIdentity(publicKey: Wrapper<PublicKey>, otherIdentity: Wrapper<PublicKey>, signature: Buffer): boolean;
|
2023-05-09 21:29:25 +02:00
|
|
|
export function IncrementalMac_CalculateChunkSize(dataSize: number): number;
|
|
|
|
export function IncrementalMac_Finalize(mac: Wrapper<IncrementalMac>): Buffer;
|
|
|
|
export function IncrementalMac_Initialize(key: Buffer, chunkSize: number): IncrementalMac;
|
|
|
|
export function IncrementalMac_Update(mac: Wrapper<IncrementalMac>, bytes: Buffer, offset: number, length: number): Buffer;
|
2023-06-02 19:42:39 +02:00
|
|
|
export function KyberKeyPair_Generate(): KyberKeyPair;
|
|
|
|
export function KyberKeyPair_GetPublicKey(keyPair: Wrapper<KyberKeyPair>): KyberPublicKey;
|
|
|
|
export function KyberKeyPair_GetSecretKey(keyPair: Wrapper<KyberKeyPair>): KyberSecretKey;
|
|
|
|
export function KyberPreKeyRecord_Deserialize(data: Buffer): KyberPreKeyRecord;
|
|
|
|
export function KyberPreKeyRecord_GetId(obj: Wrapper<KyberPreKeyRecord>): number;
|
|
|
|
export function KyberPreKeyRecord_GetKeyPair(obj: Wrapper<KyberPreKeyRecord>): KyberKeyPair;
|
|
|
|
export function KyberPreKeyRecord_GetPublicKey(obj: Wrapper<KyberPreKeyRecord>): KyberPublicKey;
|
|
|
|
export function KyberPreKeyRecord_GetSecretKey(obj: Wrapper<KyberPreKeyRecord>): KyberSecretKey;
|
|
|
|
export function KyberPreKeyRecord_GetSignature(obj: Wrapper<KyberPreKeyRecord>): Buffer;
|
|
|
|
export function KyberPreKeyRecord_GetTimestamp(obj: Wrapper<KyberPreKeyRecord>): Timestamp;
|
|
|
|
export function KyberPreKeyRecord_New(id: number, timestamp: Timestamp, keyPair: Wrapper<KyberKeyPair>, signature: Buffer): KyberPreKeyRecord;
|
|
|
|
export function KyberPreKeyRecord_Serialize(obj: Wrapper<KyberPreKeyRecord>): Buffer;
|
|
|
|
export function KyberPublicKey_Deserialize(data: Buffer): KyberPublicKey;
|
|
|
|
export function KyberPublicKey_Equals(lhs: Wrapper<KyberPublicKey>, rhs: Wrapper<KyberPublicKey>): boolean;
|
|
|
|
export function KyberPublicKey_Serialize(obj: Wrapper<KyberPublicKey>): Buffer;
|
|
|
|
export function KyberSecretKey_Deserialize(data: Buffer): KyberSecretKey;
|
|
|
|
export function KyberSecretKey_Serialize(obj: Wrapper<KyberSecretKey>): Buffer;
|
2023-03-13 21:53:06 +01:00
|
|
|
export function Mp4Sanitizer_Sanitize(input: InputStream, len: Buffer): Promise<SanitizedMetadata>;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function PlaintextContent_Deserialize(data: Buffer): PlaintextContent;
|
2021-05-26 04:51:55 +02:00
|
|
|
export function PlaintextContent_FromDecryptionErrorMessage(m: Wrapper<DecryptionErrorMessage>): PlaintextContent;
|
|
|
|
export function PlaintextContent_GetBody(obj: Wrapper<PlaintextContent>): Buffer;
|
|
|
|
export function PlaintextContent_Serialize(obj: Wrapper<PlaintextContent>): Buffer;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function PreKeyBundle_GetDeviceId(obj: Wrapper<PreKeyBundle>): number;
|
|
|
|
export function PreKeyBundle_GetIdentityKey(p: Wrapper<PreKeyBundle>): PublicKey;
|
2023-06-02 19:42:39 +02:00
|
|
|
export function PreKeyBundle_GetKyberPreKeyId(obj: Wrapper<PreKeyBundle>): number | null;
|
|
|
|
export function PreKeyBundle_GetKyberPreKeyPublic(bundle: Wrapper<PreKeyBundle>): KyberPublicKey | null;
|
|
|
|
export function PreKeyBundle_GetKyberPreKeySignature(bundle: Wrapper<PreKeyBundle>): Buffer;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2023-06-02 19:42:39 +02:00
|
|
|
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>, kyberPrekeyId: number | null, kyberPrekey: Wrapper<KyberPublicKey> | null, kyberPrekeySignature: Buffer): PreKeyBundle;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function PreKeyRecord_Deserialize(data: Buffer): PreKeyRecord;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function PreKeySignalMessage_Deserialize(data: Buffer): PreKeySignalMessage;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function PrivateKey_Deserialize(data: Buffer): PrivateKey;
|
2021-01-27 00:43:02 +01:00
|
|
|
export function PrivateKey_Generate(): PrivateKey;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ProfileKeyCiphertext_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ProfileKeyCommitment_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ProfileKeyCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
|
|
|
|
export function ProfileKeyCredentialPresentation_GetProfileKeyCiphertext(presentationBytes: Buffer): Serialized<ProfileKeyCiphertext>;
|
|
|
|
export function ProfileKeyCredentialPresentation_GetUuidCiphertext(presentationBytes: Buffer): Serialized<UuidCiphertext>;
|
|
|
|
export function ProfileKeyCredentialRequestContext_CheckValidContents(buffer: Buffer): void;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ProfileKeyCredentialRequestContext_GetRequest(context: Serialized<ProfileKeyCredentialRequestContext>): Serialized<ProfileKeyCredentialRequest>;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ProfileKeyCredentialRequest_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ProfileKey_CheckValidContents(buffer: Buffer): void;
|
2023-04-26 02:41:12 +02:00
|
|
|
export function ProfileKey_DeriveAccessKey(profileKey: Serialized<ProfileKey>): Buffer;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function ProfileKey_GetCommitment(profileKey: Serialized<ProfileKey>, userId: Buffer): Serialized<ProfileKeyCommitment>;
|
|
|
|
export function ProfileKey_GetProfileKeyVersion(profileKey: Serialized<ProfileKey>, userId: Buffer): Buffer;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function ProtocolAddress_DeviceId(obj: Wrapper<ProtocolAddress>): number;
|
|
|
|
export function ProtocolAddress_Name(obj: Wrapper<ProtocolAddress>): string;
|
2021-02-02 23:01:24 +01:00
|
|
|
export function ProtocolAddress_New(name: string, deviceId: number): ProtocolAddress;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function PublicKey_Compare(key1: Wrapper<PublicKey>, key2: Wrapper<PublicKey>): number;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function PublicKey_Deserialize(data: Buffer): PublicKey;
|
2023-05-10 01:41:29 +02:00
|
|
|
export function PublicKey_Equals(lhs: Wrapper<PublicKey>, rhs: Wrapper<PublicKey>): boolean;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ReceiptCredentialPresentation_CheckValidContents(buffer: Buffer): void;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ReceiptCredentialPresentation_GetReceiptExpirationTime(presentation: Serialized<ReceiptCredentialPresentation>): Timestamp;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ReceiptCredentialPresentation_GetReceiptLevel(presentation: Serialized<ReceiptCredentialPresentation>): Buffer;
|
|
|
|
export function ReceiptCredentialPresentation_GetReceiptSerial(presentation: Serialized<ReceiptCredentialPresentation>): Buffer;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ReceiptCredentialRequestContext_CheckValidContents(buffer: Buffer): void;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ReceiptCredentialRequestContext_GetRequest(requestContext: Serialized<ReceiptCredentialRequestContext>): Serialized<ReceiptCredentialRequest>;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ReceiptCredentialRequest_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ReceiptCredentialResponse_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ReceiptCredential_CheckValidContents(buffer: Buffer): void;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ReceiptCredential_GetReceiptExpirationTime(receiptCredential: Serialized<ReceiptCredential>): Timestamp;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ReceiptCredential_GetReceiptLevel(receiptCredential: Serialized<ReceiptCredential>): Buffer;
|
2023-03-13 21:53:06 +01:00
|
|
|
export function SanitizedMetadata_GetDataLen(sanitized: Wrapper<SanitizedMetadata>): Buffer;
|
|
|
|
export function SanitizedMetadata_GetDataOffset(sanitized: Wrapper<SanitizedMetadata>): Buffer;
|
|
|
|
export function SanitizedMetadata_GetMetadata(sanitized: Wrapper<SanitizedMetadata>): Buffer;
|
2021-01-27 00:38:48 +01:00
|
|
|
export function ScannableFingerprint_Compare(fprint1: Buffer, fprint2: Buffer): boolean;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2023-06-02 19:42:39 +02:00
|
|
|
export function SealedSender_DecryptMessage(message: Buffer, trustRoot: Wrapper<PublicKey>, timestamp: Timestamp, localE164: string | null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore): Promise<SealedSenderDecryptionResult>;
|
2023-07-21 02:16:45 +02:00
|
|
|
export function SealedSender_DecryptToUsmc(ctext: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
|
|
|
|
export function SealedSender_Encrypt(destination: Wrapper<ProtocolAddress>, content: Wrapper<UnidentifiedSenderMessageContent>, identityKeyStore: IdentityKeyStore): Promise<Buffer>;
|
|
|
|
export function SealedSender_MultiRecipientEncrypt(recipients: Wrapper<ProtocolAddress>[], recipientSessions: Wrapper<SessionRecord>[], content: Wrapper<UnidentifiedSenderMessageContent>, identityKeyStore: IdentityKeyStore): Promise<Buffer>;
|
2021-03-27 00:33:04 +01:00
|
|
|
export function SealedSender_MultiRecipientMessageForSingleRecipient(encodedMultiRecipientMessage: Buffer): Buffer;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SenderCertificate_Deserialize(data: Buffer): SenderCertificate;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderCertificate_GetCertificate(obj: Wrapper<SenderCertificate>): Buffer;
|
|
|
|
export function SenderCertificate_GetDeviceId(obj: Wrapper<SenderCertificate>): number;
|
2021-10-30 01:27:45 +02:00
|
|
|
export function SenderCertificate_GetExpiration(obj: Wrapper<SenderCertificate>): Timestamp;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2021-10-30 01:27:45 +02:00
|
|
|
export function SenderCertificate_New(senderUuid: string, senderE164: string | null, senderDeviceId: number, senderKey: Wrapper<PublicKey>, expiration: Timestamp, signerCert: Wrapper<ServerCertificate>, signerKey: Wrapper<PrivateKey>): SenderCertificate;
|
|
|
|
export function SenderCertificate_Validate(cert: Wrapper<SenderCertificate>, key: Wrapper<PublicKey>, time: Timestamp): boolean;
|
2023-07-21 02:16:45 +02:00
|
|
|
export function SenderKeyDistributionMessage_Create(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, store: SenderKeyStore): Promise<SenderKeyDistributionMessage>;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SenderKeyDistributionMessage_Deserialize(data: Buffer): SenderKeyDistributionMessage;
|
2021-02-25 20:42:53 +01:00
|
|
|
export function SenderKeyDistributionMessage_GetChainId(obj: Wrapper<SenderKeyDistributionMessage>): number;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyDistributionMessage_GetChainKey(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
|
2021-03-12 20:36:24 +01:00
|
|
|
export function SenderKeyDistributionMessage_GetDistributionId(obj: Wrapper<SenderKeyDistributionMessage>): Uuid;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyDistributionMessage_GetIteration(obj: Wrapper<SenderKeyDistributionMessage>): number;
|
2021-05-08 03:24:44 +02:00
|
|
|
export function SenderKeyDistributionMessage_New(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, chainkey: Buffer, pk: Wrapper<PublicKey>): SenderKeyDistributionMessage;
|
2023-07-21 02:16:45 +02:00
|
|
|
export function SenderKeyDistributionMessage_Process(sender: Wrapper<ProtocolAddress>, senderKeyDistributionMessage: Wrapper<SenderKeyDistributionMessage>, store: SenderKeyStore): Promise<void>;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyDistributionMessage_Serialize(obj: Wrapper<SenderKeyDistributionMessage>): Buffer;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SenderKeyMessage_Deserialize(data: Buffer): SenderKeyMessage;
|
2021-02-25 20:42:53 +01:00
|
|
|
export function SenderKeyMessage_GetChainId(obj: Wrapper<SenderKeyMessage>): number;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyMessage_GetCipherText(obj: Wrapper<SenderKeyMessage>): Buffer;
|
2021-03-12 20:36:24 +01:00
|
|
|
export function SenderKeyMessage_GetDistributionId(obj: Wrapper<SenderKeyMessage>): Uuid;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyMessage_GetIteration(obj: Wrapper<SenderKeyMessage>): number;
|
2021-05-08 03:24:44 +02:00
|
|
|
export function SenderKeyMessage_New(messageVersion: number, distributionId: Uuid, chainId: number, iteration: number, ciphertext: Buffer, pk: Wrapper<PrivateKey>): SenderKeyMessage;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyMessage_Serialize(obj: Wrapper<SenderKeyMessage>): Buffer;
|
|
|
|
export function SenderKeyMessage_VerifySignature(skm: Wrapper<SenderKeyMessage>, pubkey: Wrapper<PublicKey>): boolean;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SenderKeyRecord_Deserialize(data: Buffer): SenderKeyRecord;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SenderKeyRecord_Serialize(obj: Wrapper<SenderKeyRecord>): Buffer;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function ServerCertificate_Deserialize(data: Buffer): ServerCertificate;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ServerPublicParams_CheckValidContents(buffer: Buffer): void;
|
|
|
|
export function ServerPublicParams_CreateAuthCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, authCredential: Serialized<AuthCredential>): Buffer;
|
2022-06-22 00:11:57 +02:00
|
|
|
export function ServerPublicParams_CreateAuthCredentialWithPniPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, authCredential: Serialized<AuthCredentialWithPni>): Buffer;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ServerPublicParams_CreateExpiringProfileKeyCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, profileKeyCredential: Serialized<ExpiringProfileKeyCredential>): Buffer;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function ServerPublicParams_CreateProfileKeyCredentialRequestContextDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, userId: Buffer, profileKey: Serialized<ProfileKey>): Serialized<ProfileKeyCredentialRequestContext>;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ServerPublicParams_CreateReceiptCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, receiptCredential: Serialized<ReceiptCredential>): Serialized<ReceiptCredentialPresentation>;
|
|
|
|
export function ServerPublicParams_CreateReceiptCredentialRequestContextDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, receiptSerial: Buffer): Serialized<ReceiptCredentialRequestContext>;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function ServerPublicParams_ReceiveAuthCredential(params: Serialized<ServerPublicParams>, aci: Buffer, redemptionTime: number, response: Serialized<AuthCredentialResponse>): Serialized<AuthCredential>;
|
2023-07-18 02:16:56 +02:00
|
|
|
export function ServerPublicParams_ReceiveAuthCredentialWithPniAsAci(params: Serialized<ServerPublicParams>, aci: Buffer, pni: Buffer, redemptionTime: Timestamp, response: Serialized<AuthCredentialWithPniResponse>): Serialized<AuthCredentialWithPni>;
|
|
|
|
export function ServerPublicParams_ReceiveAuthCredentialWithPniAsServiceId(params: Serialized<ServerPublicParams>, aci: Buffer, pni: Buffer, redemptionTime: Timestamp, response: Serialized<AuthCredentialWithPniResponse>): Serialized<AuthCredentialWithPni>;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ServerPublicParams_ReceiveExpiringProfileKeyCredential(serverPublicParams: Serialized<ServerPublicParams>, requestContext: Serialized<ProfileKeyCredentialRequestContext>, response: Serialized<ExpiringProfileKeyCredentialResponse>, currentTimeInSeconds: Timestamp): Serialized<ExpiringProfileKeyCredential>;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ServerPublicParams_ReceiveReceiptCredential(serverPublicParams: Serialized<ServerPublicParams>, requestContext: Serialized<ReceiptCredentialRequestContext>, response: Serialized<ReceiptCredentialResponse>): Serialized<ReceiptCredential>;
|
|
|
|
export function ServerPublicParams_VerifySignature(serverPublicParams: Serialized<ServerPublicParams>, message: Buffer, notarySignature: Buffer): void;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function ServerSecretParams_CheckValidContents(buffer: Buffer): void;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ServerSecretParams_GenerateDeterministic(randomness: Buffer): Serialized<ServerSecretParams>;
|
|
|
|
export function ServerSecretParams_GetPublicParams(params: Serialized<ServerSecretParams>): Serialized<ServerPublicParams>;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function ServerSecretParams_IssueAuthCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, aci: Buffer, redemptionTime: number): Serialized<AuthCredentialResponse>;
|
2023-07-18 02:16:56 +02:00
|
|
|
export function ServerSecretParams_IssueAuthCredentialWithPniAsAciDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, aci: Buffer, pni: Buffer, redemptionTime: Timestamp): Serialized<AuthCredentialWithPniResponse>;
|
|
|
|
export function ServerSecretParams_IssueAuthCredentialWithPniAsServiceIdDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, aci: Buffer, pni: Buffer, redemptionTime: Timestamp): Serialized<AuthCredentialWithPniResponse>;
|
2023-07-13 02:36:02 +02:00
|
|
|
export function ServerSecretParams_IssueExpiringProfileKeyCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, request: Serialized<ProfileKeyCredentialRequest>, userId: Buffer, commitment: Serialized<ProfileKeyCommitment>, expirationInSeconds: Timestamp): Serialized<ExpiringProfileKeyCredentialResponse>;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ServerSecretParams_IssueReceiptCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, request: Serialized<ReceiptCredentialRequest>, receiptExpirationTime: Timestamp, receiptLevel: Buffer): Serialized<ReceiptCredentialResponse>;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ServerSecretParams_SignDeterministic(params: Serialized<ServerSecretParams>, randomness: Buffer, message: Buffer): Buffer;
|
2022-07-01 02:31:23 +02:00
|
|
|
export function ServerSecretParams_VerifyAuthCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, groupPublicParams: Serialized<GroupPublicParams>, presentationBytes: Buffer, currentTimeInSeconds: Timestamp): void;
|
2022-06-17 22:10:10 +02:00
|
|
|
export function ServerSecretParams_VerifyProfileKeyCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, groupPublicParams: Serialized<GroupPublicParams>, presentationBytes: Buffer, currentTimeInSeconds: Timestamp): void;
|
2021-10-29 01:48:02 +02:00
|
|
|
export function ServerSecretParams_VerifyReceiptCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, presentation: Serialized<ReceiptCredentialPresentation>): void;
|
2023-07-13 22:54:53 +02:00
|
|
|
export function ServiceId_ParseFromServiceIdBinary(input: Buffer): Buffer;
|
|
|
|
export function ServiceId_ParseFromServiceIdString(input: string): Buffer;
|
|
|
|
export function ServiceId_ServiceIdBinary(value: Buffer): Buffer;
|
|
|
|
export function ServiceId_ServiceIdLog(value: Buffer): string;
|
|
|
|
export function ServiceId_ServiceIdString(value: Buffer): string;
|
2023-08-18 00:31:27 +02:00
|
|
|
export function SessionBuilder_ProcessPreKeyBundle(bundle: Wrapper<PreKeyBundle>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, now: Timestamp): Promise<void>;
|
2023-07-21 02:16:45 +02:00
|
|
|
export function SessionCipher_DecryptPreKeySignalMessage(message: Wrapper<PreKeySignalMessage>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore, kyberPrekeyStore: KyberPreKeyStore): Promise<Buffer>;
|
|
|
|
export function SessionCipher_DecryptSignalMessage(message: Wrapper<SignalMessage>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore): Promise<Buffer>;
|
2023-08-22 02:41:08 +02:00
|
|
|
export function SessionCipher_EncryptMessage(ptext: Buffer, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, now: Timestamp): Promise<CiphertextMessage>;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SessionRecord_ArchiveCurrentState(sessionRecord: Wrapper<SessionRecord>): void;
|
2021-05-26 05:21:12 +02:00
|
|
|
export function SessionRecord_CurrentRatchetKeyMatches(s: Wrapper<SessionRecord>, key: Wrapper<PublicKey>): boolean;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SessionRecord_Deserialize(data: Buffer): SessionRecord;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SessionRecord_GetLocalRegistrationId(obj: Wrapper<SessionRecord>): number;
|
|
|
|
export function SessionRecord_GetRemoteRegistrationId(obj: Wrapper<SessionRecord>): number;
|
2023-08-22 02:39:07 +02:00
|
|
|
export function SessionRecord_HasUsableSenderChain(s: Wrapper<SessionRecord>, now: Timestamp): boolean;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SessionRecord_Serialize(obj: Wrapper<SessionRecord>): Buffer;
|
2023-02-14 16:41:51 +01:00
|
|
|
export function SgxClientState_CompleteHandshake(cli: Wrapper<SgxClientState>, handshakeReceived: Buffer): void;
|
|
|
|
export function SgxClientState_EstablishedRecv(cli: Wrapper<SgxClientState>, receivedCiphertext: Buffer): Buffer;
|
|
|
|
export function SgxClientState_EstablishedSend(cli: Wrapper<SgxClientState>, plaintextToSend: Buffer): Buffer;
|
|
|
|
export function SgxClientState_InitialRequest(obj: Wrapper<SgxClientState>): Buffer;
|
2023-04-28 22:30:05 +02:00
|
|
|
export function SignalMedia_CheckAvailable(): void;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SignalMessage_Deserialize(data: Buffer): SignalMessage;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function SignedPreKeyRecord_Deserialize(data: Buffer): SignedPreKeyRecord;
|
2021-02-10 03:34:42 +01:00
|
|
|
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;
|
2021-10-30 01:27:45 +02:00
|
|
|
export function SignedPreKeyRecord_GetTimestamp(obj: Wrapper<SignedPreKeyRecord>): Timestamp;
|
|
|
|
export function SignedPreKeyRecord_New(id: number, timestamp: Timestamp, pubKey: Wrapper<PublicKey>, privKey: Wrapper<PrivateKey>, signature: Buffer): SignedPreKeyRecord;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function SignedPreKeyRecord_Serialize(obj: Wrapper<SignedPreKeyRecord>): Buffer;
|
2021-10-20 00:40:18 +02:00
|
|
|
export function UnidentifiedSenderMessageContent_Deserialize(data: Buffer): UnidentifiedSenderMessageContent;
|
2021-03-26 18:38:50 +01:00
|
|
|
export function UnidentifiedSenderMessageContent_GetContentHint(m: Wrapper<UnidentifiedSenderMessageContent>): number;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function UnidentifiedSenderMessageContent_GetContents(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
|
2023-02-03 03:10:55 +01:00
|
|
|
export function UnidentifiedSenderMessageContent_GetGroupId(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer | null;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function UnidentifiedSenderMessageContent_GetMsgType(m: Wrapper<UnidentifiedSenderMessageContent>): number;
|
|
|
|
export function UnidentifiedSenderMessageContent_GetSenderCert(m: Wrapper<UnidentifiedSenderMessageContent>): SenderCertificate;
|
2021-03-26 18:38:50 +01:00
|
|
|
export function UnidentifiedSenderMessageContent_New(message: Wrapper<CiphertextMessage>, sender: Wrapper<SenderCertificate>, contentHint: number, groupId: Buffer | null): UnidentifiedSenderMessageContent;
|
2021-02-10 03:34:42 +01:00
|
|
|
export function UnidentifiedSenderMessageContent_Serialize(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
|
2023-07-06 23:39:37 +02:00
|
|
|
export function UsernameLink_Create(username: string): Buffer;
|
|
|
|
export function UsernameLink_DecryptUsername(entropy: Buffer, encryptedUsername: Buffer): string;
|
2023-02-01 18:36:49 +01:00
|
|
|
export function Username_CandidatesFrom(nickname: string, minLen: number, maxLen: number): string;
|
|
|
|
export function Username_Hash(username: string): Buffer;
|
|
|
|
export function Username_Proof(username: string, randomness: Buffer): Buffer;
|
|
|
|
export function Username_Verify(proof: Buffer, hash: Buffer): void;
|
2022-04-06 20:07:08 +02:00
|
|
|
export function UuidCiphertext_CheckValidContents(buffer: Buffer): void;
|
2023-05-09 21:29:25 +02:00
|
|
|
export function ValidatingMac_Finalize(mac: Wrapper<ValidatingMac>): boolean;
|
|
|
|
export function ValidatingMac_Initialize(key: Buffer, chunkSize: number, digests: Buffer): ValidatingMac;
|
|
|
|
export function ValidatingMac_Update(mac: Wrapper<ValidatingMac>, bytes: Buffer, offset: number, length: number): boolean;
|
2021-01-27 00:43:02 +01:00
|
|
|
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; }
|
2021-10-29 01:48:02 +02:00
|
|
|
interface AuthCredential { readonly __type: unique symbol; }
|
|
|
|
interface AuthCredentialResponse { readonly __type: unique symbol; }
|
2022-06-22 00:11:57 +02:00
|
|
|
interface AuthCredentialWithPni { readonly __type: unique symbol; }
|
|
|
|
interface AuthCredentialWithPniResponse { readonly __type: unique symbol; }
|
2021-02-01 21:20:16 +01:00
|
|
|
interface CiphertextMessage { readonly __type: unique symbol; }
|
2021-05-26 04:51:55 +02:00
|
|
|
interface DecryptionErrorMessage { readonly __type: unique symbol; }
|
2022-06-17 22:10:10 +02:00
|
|
|
interface ExpiringProfileKeyCredential { readonly __type: unique symbol; }
|
|
|
|
interface ExpiringProfileKeyCredentialResponse { readonly __type: unique symbol; }
|
2021-01-27 00:43:02 +01:00
|
|
|
interface Fingerprint { readonly __type: unique symbol; }
|
2021-10-29 01:48:02 +02:00
|
|
|
interface GroupMasterKey { readonly __type: unique symbol; }
|
|
|
|
interface GroupPublicParams { readonly __type: unique symbol; }
|
|
|
|
interface GroupSecretParams { readonly __type: unique symbol; }
|
2021-10-27 02:51:25 +02:00
|
|
|
interface HsmEnclaveClient { readonly __type: unique symbol; }
|
2023-05-09 21:29:25 +02:00
|
|
|
interface IncrementalMac { readonly __type: unique symbol; }
|
2023-06-02 19:42:39 +02:00
|
|
|
interface KyberKeyPair { readonly __type: unique symbol; }
|
|
|
|
interface KyberPreKeyRecord { readonly __type: unique symbol; }
|
|
|
|
interface KyberPublicKey { readonly __type: unique symbol; }
|
|
|
|
interface KyberSecretKey { readonly __type: unique symbol; }
|
2021-05-26 04:51:55 +02:00
|
|
|
interface PlaintextContent { readonly __type: unique symbol; }
|
2021-01-27 00:43:02 +01:00
|
|
|
interface PreKeyBundle { readonly __type: unique symbol; }
|
|
|
|
interface PreKeyRecord { readonly __type: unique symbol; }
|
|
|
|
interface PreKeySignalMessage { readonly __type: unique symbol; }
|
|
|
|
interface PrivateKey { readonly __type: unique symbol; }
|
2021-10-29 01:48:02 +02:00
|
|
|
interface ProfileKey { readonly __type: unique symbol; }
|
|
|
|
interface ProfileKeyCiphertext { readonly __type: unique symbol; }
|
|
|
|
interface ProfileKeyCommitment { readonly __type: unique symbol; }
|
|
|
|
interface ProfileKeyCredentialRequest { readonly __type: unique symbol; }
|
|
|
|
interface ProfileKeyCredentialRequestContext { readonly __type: unique symbol; }
|
2021-01-27 00:43:02 +01:00
|
|
|
interface ProtocolAddress { readonly __type: unique symbol; }
|
|
|
|
interface PublicKey { readonly __type: unique symbol; }
|
2021-10-29 01:48:02 +02:00
|
|
|
interface ReceiptCredential { readonly __type: unique symbol; }
|
|
|
|
interface ReceiptCredentialPresentation { readonly __type: unique symbol; }
|
|
|
|
interface ReceiptCredentialRequest { readonly __type: unique symbol; }
|
|
|
|
interface ReceiptCredentialRequestContext { readonly __type: unique symbol; }
|
|
|
|
interface ReceiptCredentialResponse { readonly __type: unique symbol; }
|
2023-03-13 21:53:06 +01:00
|
|
|
interface SanitizedMetadata { readonly __type: unique symbol; }
|
2021-02-16 21:45:16 +01:00
|
|
|
interface SealedSenderDecryptionResult { readonly __type: unique symbol; }
|
2021-01-27 00:43:02 +01:00
|
|
|
interface SenderCertificate { readonly __type: unique symbol; }
|
|
|
|
interface SenderKeyDistributionMessage { readonly __type: unique symbol; }
|
|
|
|
interface SenderKeyMessage { readonly __type: unique symbol; }
|
|
|
|
interface SenderKeyRecord { readonly __type: unique symbol; }
|
|
|
|
interface ServerCertificate { readonly __type: unique symbol; }
|
2021-10-29 01:48:02 +02:00
|
|
|
interface ServerPublicParams { readonly __type: unique symbol; }
|
|
|
|
interface ServerSecretParams { readonly __type: unique symbol; }
|
2021-01-27 00:43:02 +01:00
|
|
|
interface SessionRecord { readonly __type: unique symbol; }
|
2023-02-14 16:41:51 +01:00
|
|
|
interface SgxClientState { readonly __type: unique symbol; }
|
2021-01-27 00:43:02 +01:00
|
|
|
interface SignalMessage { readonly __type: unique symbol; }
|
|
|
|
interface SignedPreKeyRecord { readonly __type: unique symbol; }
|
|
|
|
interface UnidentifiedSenderMessageContent { readonly __type: unique symbol; }
|
2021-10-29 01:48:02 +02:00
|
|
|
interface UuidCiphertext { readonly __type: unique symbol; }
|
2023-05-09 21:29:25 +02:00
|
|
|
interface ValidatingMac { readonly __type: unique symbol; }
|