@prototypevip/baileys 0.1.1 → 0.1.3

package/lib/Signal/libsignal-wasm/README.md

@@ -0,0 +1,64 @@
+libsignal-node
+========
+Signal protocol implementation for Node.js based on
+[libsignal-protocol-javascript](https://github.com/WhisperSystems/libsignal-protocol-javascript).
+
+[![npm](https://img.shields.io/npm/v/libsignal.svg)](https://www.npmjs.com/package/libsignal)
+[![npm](https://img.shields.io/npm/l/libsignal.svg)](https://github.com/ForstaLabs/libsignal-node)
+
+
+Overview
+--------
+A ratcheting forward secrecy protocol that works in synchronous and
+asynchronous messaging environments.
+
+
+PreKeys
+--------
+This protocol uses a concept called 'PreKeys'. A PreKey is an ECPublicKey and
+an associated unique ID which are stored together by a server. PreKeys can also
+be signed.
+
+At install time, clients generate a single signed PreKey, as well as a large
+list of unsigned PreKeys, and transmit all of them to the server.
+
+
+Sessions
+--------
+Signal Protocol is session-oriented. Clients establish a "session," which is
+then used for all subsequent encrypt/decrypt operations. There is no need to
+ever tear down a session once one has been established.
+
+Sessions are established in one of two ways:
+
+1. PreKeyBundles. A client that wishes to send a message to a recipient can
+   establish a session by retrieving a PreKeyBundle for that recipient from the
+   server.
+2. PreKeySignalMessages. A client can receive a PreKeySignalMessage from a
+   recipient and use it to establish a session.
+
+
+State
+--------
+An established session encapsulates a lot of state between two clients. That
+state is maintained in durable records which need to be kept for the life of
+the session.
+
+State is kept in the following places:
+
+* Identity State. Clients will need to maintain the state of their own identity
+  key pair, as well as identity keys received from other clients.
+* PreKey State. Clients will need to maintain the state of their generated
+  PreKeys.
+* Signed PreKey States. Clients will need to maintain the state of their signed
+  PreKeys.
+* Session State. Clients will need to maintain the state of the sessions they
+  have established.
+
+
+License
+--------
+Licensed under the GPLv3: http://www.gnu.org/licenses/gpl-3.0.html
+
+* Copyright 2015-2016 Open Whisper Systems
+* Copyright 2017-2018 Forsta Inc

package/lib/Signal/libsignal-wasm/index.d.ts

@@ -0,0 +1,55 @@
+interface E2ESession {
+  registrationId: number;
+  identityKey: Uint8Array;
+  signedPreKey: {
+    keyId: number;
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+  };
+  preKey: {
+    keyId: number;
+    publicKey: Uint8Array;
+  };
+}
+
+export interface SignalStorage {
+  loadSession(id: string): Promise<SessionRecord | null | undefined>;
+  storeSession(id: string, session: SessionRecord): Promise<void>;
+  isTrustedIdentity(
+    identifier: string,
+    identityKey: Uint8Array,
+    direction: number
+  ): boolean;
+  loadPreKey(
+    id: number | string
+  ): Promise<{ privKey: Buffer; pubKey: Buffer } | undefined>;
+  removePreKey(id: number): void;
+  loadSignedPreKey(): { privKey: Buffer; pubKey: Buffer };
+  getOurRegistrationId(): Promise<number> | number;
+  getOurIdentity(): { privKey: Buffer; pubKey: Buffer };
+}
+
+export class ProtocolAddress {
+  constructor(name: string, deviceId: number);
+  public id: string;
+  public deviceId: number;
+  public toString(): string;
+}
+
+export class SessionRecord {
+  static deserialize(serialized: Uint8Array): SessionRecord;
+  public serialize(): Uint8Array;
+  public haveOpenSession(): boolean;
+}
+
+export class SessionCipher {
+  constructor(storage: SignalStorage, remoteAddress: ProtocolAddress);
+  public decryptPreKeyWhisperMessage(ciphertext: Uint8Array): Promise<Buffer>;
+  public decryptWhisperMessage(ciphertext: Uint8Array): Promise<Buffer>;
+  public encrypt(data: Uint8Array): Promise<{ type: number; body: string }>;
+}
+
+export class SessionBuilder {
+  constructor(storage: SignalStorage, remoteAddress: ProtocolAddress);
+  public initOutgoing(session: E2ESession): Promise<void>;
+}

package/lib/Signal/libsignal-wasm/index.js

@@ -0,0 +1,14 @@
+export * as crypto from './src/crypto.js';
+export * as curve from './src/curve.js';
+export * as keyhelper from './src/keyhelper.js';
+export { default as ProtocolAddress } from './src/protocol_address.js';
+export { default as SessionBuilder } from './src/session_builder.js';
+export { default as SessionCipher } from './src/session_cipher.js';
+export { default as SessionRecord } from './src/session_record.js';
+export {
+    SignalError,
+    UntrustedIdentityKeyError,
+    SessionError,
+    MessageCounterError,
+    PreKeyError
+} from './src/errors.js';

package/lib/Signal/libsignal-wasm/protos/WhisperTextProtocol.proto

@@ -0,0 +1,28 @@
+package textsecure;
+
+option java_package = "org.whispersystems.libsignal.protocol";
+option java_outer_classname = "WhisperProtos";
+
+message WhisperMessage {
+  optional bytes  ephemeralKey    = 1;
+  optional uint32 counter         = 2;
+  optional uint32 previousCounter = 3;
+  optional bytes  ciphertext      = 4; // PushMessageContent
+}
+
+message PreKeyWhisperMessage {
+  optional uint32 registrationId = 5;
+  optional uint32 preKeyId       = 1;
+  optional uint32 signedPreKeyId = 6;
+  optional bytes  baseKey        = 2;
+  optional bytes  identityKey    = 3;
+  optional bytes  message        = 4; // WhisperMessage
+}
+
+message KeyExchangeMessage {
+  optional uint32 id               = 1;
+  optional bytes  baseKey          = 2;
+  optional bytes  ephemeralKey     = 3;
+  optional bytes  identityKey      = 4;
+  optional bytes  baseKeySignature = 5;
+}