@digitaldefiance/node-ecies-lib 1.1.20 → 1.1.22

package/src/interfaces/keyring-consts.ts

@@ -0,0 +1,5 @@
+export interface IKeyringConsts {
+  ALGORITHM: string;
+  KEY_BITS: number;
+  MODE: string;
+}

package/src/interfaces/member-operational.ts

@@ -0,0 +1,52 @@
+import {
+  EmailString,
+  MemberType,
+  SecureBuffer,
+  SecureString,
+} from '@digitaldefiance/ecies-lib';
+import { Wallet } from '@ethereumjs/wallet';
+import { Types } from 'mongoose';
+import { SignatureBuffer } from '../types';
+
+/**
+ * Operational interface for member - defines getters and methods
+ */
+export interface IMemberOperational<I extends string | Types.ObjectId> {
+  // Required getters
+  get id(): I;
+  get type(): MemberType;
+  get name(): string;
+  get email(): EmailString;
+  get publicKey(): Uint8Array;
+  get creatorId(): I;
+  get dateCreated(): Date;
+  get dateUpdated(): Date;
+
+  // Optional private data getters
+  get privateKey(): SecureBuffer | undefined;
+  get wallet(): Wallet | undefined;
+
+  // State getters
+  get hasPrivateKey(): boolean;
+
+  // Methods
+  sign(data: Buffer): SignatureBuffer;
+  verify(signature: SignatureBuffer, data: Buffer): boolean;
+  encryptData(data: string | Buffer): Uint8Array;
+  decryptData(encryptedData: Buffer): Uint8Array;
+  toJson(): string;
+
+  // Private key management
+  loadWallet(mnemonic: SecureString): void;
+  unloadPrivateKey(): void;
+  unloadWallet(): void;
+  unloadWalletAndPrivateKey(): void;
+}
+
+/**
+ * Extended operational interface for test members
+ */
+export interface ITestBrightChainMemberOperational
+  extends IMemberOperational<Types.ObjectId> {
+  get mnemonic(): SecureString | undefined;
+}

package/{dist/interfaces/member-with-mnemonic.d.ts → src/interfaces/member-with-mnemonic.ts}

@@ -1,7 +1,7 @@
 import { SecureString } from '@digitaldefiance/ecies-lib';
 import { Member } from '../member';
+
 export interface IBackendMemberWithMnemonic {
-    member: Member;
-    mnemonic: SecureString;
+  member: Member;
+  mnemonic: SecureString;
 }
-//# sourceMappingURL=member-with-mnemonic.d.ts.map

package/{dist/interfaces/multi-encrypted-message.d.ts → src/interfaces/multi-encrypted-message.ts}

@@ -1,8 +1,8 @@
 import { IMultiEncryptedParsedHeader } from './multi-encrypted-parsed-header';
+
 export interface IMultiEncryptedMessage extends IMultiEncryptedParsedHeader {
-    /**
-     * The encrypted message.
-     */
-    readonly encryptedMessage: Buffer;
+  /**
+   * The encrypted message.
+   */
+  readonly encryptedMessage: Buffer;
 }
-//# sourceMappingURL=multi-encrypted-message.d.ts.map

package/src/interfaces/multi-encrypted-parsed-header.ts

@@ -0,0 +1,24 @@
+import { Types } from 'mongoose';
+
+export interface IMultiEncryptedParsedHeader {
+  /**
+   * The length of the data before encryption
+   */
+  readonly dataLength: number;
+  /**
+   * The number of recipients
+   */
+  readonly recipientCount: number;
+  /**
+   * The IDs of the recipients
+   */
+  readonly recipientIds: Types.ObjectId[];
+  /**
+   * An encrypted version of the symmetric key for each recipient
+   */
+  readonly recipientKeys: Buffer[];
+  /**
+   * The size of the header, up to the encrypted message start (excludes encrypted message IV+auth tag)
+   */
+  readonly headerSize: number;
+}

package/{dist/interfaces/pbkdf-profiles.d.ts → src/interfaces/pbkdf-profiles.ts}

@@ -1,6 +1,6 @@
 import { IPbkdf2Config } from '@digitaldefiance/ecies-lib';
 import { Pbkdf2ProfileEnum } from '../enumerations/pbkdf2-profile';
+
 export type PbkdfProfiles = {
-    [key in Pbkdf2ProfileEnum]: IPbkdf2Config;
+  [key in Pbkdf2ProfileEnum]: IPbkdf2Config;
 };
-//# sourceMappingURL=pbkdf-profiles.d.ts.map

package/src/interfaces/pbkdf2-result.ts

@@ -0,0 +1,5 @@
+export interface IPbkdf2Result {
+  salt: Buffer;
+  hash: Buffer;
+  iterations: number;
+}

package/src/interfaces/signing-key-private-key-info.ts

@@ -0,0 +1,12 @@
+import { ec } from 'elliptic';
+import { IKeyPairBufferWithUnEncryptedPrivateKey } from './keypair-buffer-with-un-encrypted-private-key';
+
+export interface ISigningKeyPrivateKeyInfo
+  extends IKeyPairBufferWithUnEncryptedPrivateKey {
+  keyPair: ec.KeyPair;
+  publicKey: Buffer;
+  privateKey: Buffer;
+  seedHex: string;
+  entropy: string;
+  mnemonic: string;
+}

package/{dist/interfaces/simple-keypair-buffer.d.ts → src/interfaces/simple-keypair-buffer.ts}

@@ -1,6 +1,6 @@
 import { ISimplePublicKeyOnlyBuffer } from './simple-public-key-only-buffer';
+
 export interface ISimpleKeyPairBuffer extends ISimplePublicKeyOnlyBuffer {
-    publicKey: Buffer;
-    privateKey: Buffer;
+  publicKey: Buffer;
+  privateKey: Buffer;
 }
-//# sourceMappingURL=simple-keypair-buffer.d.ts.map

package/{dist/interfaces/simple-keypair.d.ts → src/interfaces/simple-keypair.ts}

@@ -1,6 +1,6 @@
 import { ISimplePublicKeyOnly } from './simple-public-key-only';
+
 export interface ISimpleKeyPair extends ISimplePublicKeyOnly {
-    publicKey: string;
-    privateKey: Buffer;
+  publicKey: string;
+  privateKey: Buffer;
 }
-//# sourceMappingURL=simple-keypair.d.ts.map

package/src/interfaces/simple-public-key-only-buffer.ts

@@ -0,0 +1,3 @@
+export interface ISimplePublicKeyOnlyBuffer {
+  publicKey: Buffer;
+}

package/src/interfaces/simple-public-key-only.ts

@@ -0,0 +1,3 @@
+export interface ISimplePublicKeyOnly {
+  publicKey: string;
+}

package/src/interfaces/single-encrypted-parsed-header.ts

@@ -0,0 +1,35 @@
+import { EciesEncryptionTypeEnum } from '@digitaldefiance/ecies-lib';
+
+/**
+ * Interface for encrypted messages
+ */
+export interface ISingleEncryptedParsedHeader {
+  /**
+   * The optional preamble, if specified/relevant
+   */
+  readonly preamble?: Buffer;
+  /**
+   * The encryption type used to encrypt the data
+   */
+  readonly encryptionType: EciesEncryptionTypeEnum;
+  /**
+   * The ephemeral public key used to encrypt the data
+   */
+  readonly ephemeralPublicKey: Buffer;
+  /**
+   * The initialization vector used to encrypt the data
+   */
+  readonly iv: Buffer;
+  /**
+   * The authentication tag used to encrypt the data
+   */
+  readonly authTag: Buffer;
+  /**
+   * The length of the encrypted data
+   */
+  readonly dataLength: number;
+  /**
+   * The size of the encrypted data header
+   */
+  readonly headerSize: number;
+}

package/{dist/interfaces/wallet-seed.d.ts → src/interfaces/wallet-seed.ts}

@@ -1,7 +1,7 @@
 import { SecureBuffer } from '@digitaldefiance/ecies-lib';
 import { Wallet } from '@ethereumjs/wallet';
+
 export interface IWalletSeed {
-    wallet: Wallet;
-    seed: SecureBuffer;
+  wallet: Wallet;
+  seed: SecureBuffer;
 }
-//# sourceMappingURL=wallet-seed.d.ts.map

package/src/interfaces/wrapped-key-consts.ts

@@ -0,0 +1,6 @@
+export interface IWrappedKeyConsts {
+  SALT_SIZE: number;
+  IV_SIZE: number;
+  MASTER_KEY_SIZE: number;
+  MIN_ITERATIONS: number;
+}

package/src/member.ts

@@ -0,0 +1,463 @@
+import {
+  ECIES,
+  EmailString,
+  IMemberStorageData,
+  MemberErrorType,
+  MemberType,
+  SecureBuffer,
+  SecureString,
+} from '@digitaldefiance/ecies-lib';
+import { Wallet } from '@ethereumjs/wallet';
+import {
+  getNodeEciesTranslation,
+  NodeEciesStringKey,
+} from './i18n/ecies-i18n-factory';
+
+/**
+ * Custom error classes that work with the plugin i18n system
+ */
+export class NodeMemberError extends Error {
+  constructor(message: string, public readonly type: MemberErrorType) {
+    super(message);
+    this.name = 'NodeMemberError';
+  }
+}
+
+import { ECIESService } from './services/ecies/service';
+// Removed: import { ServiceProvider } from './services/service.provider';
+import { ObjectId } from 'mongodb';
+import { Types } from 'mongoose';
+import { IMemberOperational } from './interfaces/member-operational';
+import { SignatureBuffer } from './types';
+
+/**
+ * A member of Brightchain.
+ * In the Owner Free Filesystem (OFF), members are used to:
+ * 1. Sign and verify data
+ * 2. Encrypt and decrypt data
+ * 3. Participate in voting
+ * 4. Establish ownership of data
+ */
+export class Member implements IMemberOperational<Types.ObjectId> {
+  private readonly _eciesService: ECIESService;
+  private readonly _id: Types.ObjectId;
+  private readonly _type: MemberType;
+  private readonly _name: string;
+  private readonly _email: EmailString;
+  private readonly _publicKey: Buffer;
+  private readonly _creatorId: Types.ObjectId;
+  private readonly _dateCreated: Date;
+  private readonly _dateUpdated: Date;
+  private _privateKey?: SecureBuffer;
+  private _wallet?: Wallet;
+
+  constructor(
+    // Add injected services as parameters
+    eciesService: ECIESService,
+    // Original parameters
+    type: MemberType,
+    name: string,
+    email: EmailString,
+    publicKey: Buffer,
+    privateKey?: SecureBuffer,
+    wallet?: Wallet,
+    id?: Types.ObjectId,
+    dateCreated?: Date,
+    dateUpdated?: Date,
+    creatorId?: Types.ObjectId,
+  ) {
+    // Assign injected services
+    this._eciesService = eciesService;
+    // Assign original parameters
+    this._type = type;
+    this._id = id ?? new ObjectId();
+    this._name = name;
+    if (!this._name || this._name.length == 0) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_MissingMemberName,
+        ),
+        MemberErrorType.MissingMemberName,
+      );
+    }
+    if (this._name.trim() != this._name) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace,
+        ),
+        MemberErrorType.InvalidMemberNameWhitespace,
+      );
+    }
+    this._email = email;
+    this._publicKey = publicKey;
+    this._privateKey = privateKey;
+    this._wallet = wallet;
+
+    // don't create a new date object with nearly identical values to the existing one
+    let _now: null | Date = null;
+    const now = function () {
+      if (!_now) {
+        _now = new Date();
+      }
+      return _now;
+    };
+    this._dateCreated = dateCreated ?? now();
+    this._dateUpdated = dateUpdated ?? now();
+    this._creatorId = creatorId ?? this._id;
+  }
+
+  // Required getters
+  public get id(): Types.ObjectId {
+    return this._id;
+  }
+  public get type(): MemberType {
+    return this._type;
+  }
+  public get name(): string {
+    return this._name;
+  }
+  public get email(): EmailString {
+    return this._email;
+  }
+  public get publicKey(): Buffer {
+    return this._publicKey;
+  }
+  public get creatorId(): Types.ObjectId {
+    return this._creatorId;
+  }
+  public get dateCreated(): Date {
+    return this._dateCreated;
+  }
+  public get dateUpdated(): Date {
+    return this._dateUpdated;
+  }
+
+  // Optional private data getters
+  public get privateKey(): SecureBuffer | undefined {
+    return this._privateKey;
+  }
+  public get wallet(): Wallet {
+    if (!this._wallet) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Member_NoWallet),
+        MemberErrorType.NoWallet,
+      );
+    }
+    return this._wallet;
+  }
+
+  // State getters
+  public get hasPrivateKey(): boolean {
+    return this._privateKey !== undefined;
+  }
+
+  public unloadPrivateKey(): void {
+    // Do not dispose here; tests expect the same SecureBuffer instance to remain usable
+    // when reloaded into another member in the same process.
+    this._privateKey = undefined;
+  }
+
+  public unloadWallet(): void {
+    this._wallet = undefined;
+  }
+
+  public unloadWalletAndPrivateKey(): void {
+    this.unloadWallet();
+    this.unloadPrivateKey();
+  }
+
+  public loadWallet(mnemonic: SecureString): void {
+    if (this._wallet) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_WalletAlreadyLoaded,
+        ),
+        MemberErrorType.WalletAlreadyLoaded,
+      );
+    }
+    const { wallet } = this._eciesService.walletAndSeedFromMnemonic(mnemonic);
+    const privateKey = wallet.getPrivateKey();
+    const publicKey = wallet.getPublicKey();
+    const publicKeyWithPrefix = Buffer.concat([
+      Buffer.from([ECIES.PUBLIC_KEY_MAGIC]),
+      publicKey,
+    ]);
+
+    if (
+      publicKeyWithPrefix.toString('hex') !== this._publicKey.toString('hex')
+    ) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_InvalidMnemonic,
+        ),
+        MemberErrorType.InvalidMnemonic,
+      );
+    }
+    this._wallet = wallet;
+    this._privateKey = new SecureBuffer(privateKey);
+  }
+
+  /**
+   * Loads the private key and optionally the voting private key.
+   *
+   * @param privateKey The private key to load.
+   * @param votingPrivateKey The voting private key to load.
+   */
+  public loadPrivateKey(privateKey: SecureBuffer): void {
+    this._privateKey = privateKey;
+  }
+
+  public sign(data: Buffer): SignatureBuffer {
+    if (!this._privateKey) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_MissingPrivateKey,
+        ),
+        MemberErrorType.MissingPrivateKey,
+      );
+    }
+    return this._eciesService.signMessage(
+      Buffer.from(this._privateKey.value),
+      data,
+    );
+  }
+
+  public signData(data: Buffer): SignatureBuffer {
+    if (!this._privateKey) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_MissingPrivateKey,
+        ),
+        MemberErrorType.MissingPrivateKey,
+      );
+    }
+    return this._eciesService.signMessage(
+      Buffer.from(this._privateKey.value),
+      data,
+    );
+  }
+
+  public verify(signature: SignatureBuffer, data: Buffer): boolean {
+    return this._eciesService.verifyMessage(this._publicKey, data, signature);
+  }
+
+  public verifySignature(
+    data: Buffer,
+    signature: Buffer,
+    publicKey: Buffer,
+  ): boolean {
+    return this._eciesService.verifyMessage(
+      publicKey,
+      data,
+      signature as SignatureBuffer,
+    );
+  }
+
+  private static readonly MAX_ENCRYPTION_SIZE = 1024 * 1024 * 10; // 10MB limit
+  private static readonly VALID_STRING_REGEX = /^[\x20-\x7E\n\r\t]*$/; // Printable ASCII + common whitespace
+
+  public encryptData(
+    data: string | Buffer,
+    recipientPublicKey?: Buffer,
+  ): Buffer {
+    // Validate input
+    if (!data) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_MissingEncryptionData,
+        ),
+        MemberErrorType.MissingEncryptionData,
+      );
+    }
+
+    // Check size limit
+    const dataSize = Buffer.isBuffer(data)
+      ? data.length
+      : Buffer.byteLength(data);
+    if (dataSize > Member.MAX_ENCRYPTION_SIZE) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_EncryptionDataTooLarge,
+        ),
+        MemberErrorType.EncryptionDataTooLarge,
+      );
+    }
+
+    // Create buffer from data
+    const bufferData = Buffer.isBuffer(data) ? data : Buffer.from(data);
+
+    // Use recipient public key or self public key
+    const targetPublicKey = recipientPublicKey || this._publicKey;
+
+    return this._eciesService.encryptSimpleOrSingle(
+      false,
+      targetPublicKey,
+      bufferData,
+    );
+  }
+
+  public decryptData(encryptedData: Buffer): Buffer {
+    if (!this._privateKey) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_MissingPrivateKey,
+        ),
+        MemberErrorType.MissingPrivateKey,
+      );
+    }
+    // decryptSingleWithHeader now returns the Buffer directly
+    return this._eciesService.decryptSimpleOrSingleWithHeader(
+      false,
+      Buffer.from(this._privateKey.value),
+      encryptedData,
+    );
+  }
+
+  public toJson(): string {
+    const storage: IMemberStorageData = {
+      id: this._id.toString(),
+      type: this._type,
+      name: this._name,
+      email: this._email.toString(),
+      publicKey: this._publicKey.toString('base64'),
+      creatorId: this._creatorId.toString(),
+      dateCreated: this._dateCreated.toISOString(),
+      dateUpdated: this._dateUpdated.toISOString(),
+    };
+    return JSON.stringify(storage);
+  }
+
+  public dispose(): void {
+    // Ensure secret material is zeroized when disposing
+    try {
+      this._privateKey?.dispose();
+    } finally {
+      this.unloadWalletAndPrivateKey();
+    }
+  }
+
+  public static fromJson(
+    json: string,
+    // Add injected services as parameters
+    eciesService: ECIESService,
+  ): Member {
+    const storage: IMemberStorageData = JSON.parse(json);
+    const email = new EmailString(storage.email);
+
+    // Pass injected services to constructor
+    const dateCreated = new Date(storage.dateCreated);
+    return new Member(
+      eciesService,
+      storage.type,
+      storage.name,
+      email,
+      Buffer.from(storage.publicKey, 'base64'),
+      undefined,
+      undefined,
+      new ObjectId(storage.id),
+      dateCreated,
+      new Date(storage.dateUpdated),
+      new ObjectId(storage.creatorId),
+    );
+  }
+
+  public static fromMnemonic(
+    mnemonic: SecureString,
+    eciesService: ECIESService,
+    memberType = MemberType.User,
+    name = 'Test User',
+    email = new EmailString('test@example.com'),
+  ): Member {
+    const { wallet } = eciesService.walletAndSeedFromMnemonic(mnemonic);
+    const privateKey = wallet.getPrivateKey();
+    const publicKeyWithPrefix = Buffer.concat([
+      Buffer.from([ECIES.PUBLIC_KEY_MAGIC]),
+      wallet.getPublicKey(),
+    ]);
+
+    return new Member(
+      eciesService,
+      memberType,
+      name,
+      email,
+      publicKeyWithPrefix,
+      new SecureBuffer(privateKey),
+      wallet,
+    );
+  }
+
+  public static newMember(
+    // Add injected services as parameters
+    eciesService: ECIESService,
+    // Original parameters
+    type: MemberType,
+    name: string,
+    email: EmailString,
+    forceMnemonic?: SecureString,
+    createdBy?: Types.ObjectId,
+  ): { member: Member; mnemonic: SecureString } {
+    // Validate inputs first
+    if (!name || name.length == 0) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_MissingMemberName,
+        ),
+        MemberErrorType.MissingMemberName,
+      );
+    }
+    if (name.trim() != name) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_InvalidMemberNameWhitespace,
+        ),
+        MemberErrorType.InvalidMemberNameWhitespace,
+      );
+    }
+    if (!email || email.toString().length == 0) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(NodeEciesStringKey.Error_Member_MissingEmail),
+        MemberErrorType.MissingEmail,
+      );
+    }
+    if (email.toString().trim() != email.toString()) {
+      throw new NodeMemberError(
+        getNodeEciesTranslation(
+          NodeEciesStringKey.Error_Member_InvalidEmailWhitespace,
+        ),
+        MemberErrorType.InvalidEmailWhitespace,
+      );
+    }
+
+    // Use injected services
+    const mnemonic = forceMnemonic ?? eciesService.generateNewMnemonic();
+    const { wallet } = eciesService.walletAndSeedFromMnemonic(mnemonic);
+
+    // Get private key from wallet
+    const privateKey = wallet.getPrivateKey();
+    // Get public key with 0x04 prefix
+    const publicKeyWithPrefix = Buffer.concat([
+      Buffer.from([ECIES.PUBLIC_KEY_MAGIC]),
+      wallet.getPublicKey(),
+    ]);
+
+    const newId = new ObjectId();
+    const dateCreated = new Date();
+    return {
+      // Pass injected services to constructor
+      member: new Member(
+        eciesService,
+        type,
+        name,
+        email,
+        publicKeyWithPrefix,
+        new SecureBuffer(privateKey),
+        wallet,
+        newId,
+        dateCreated,
+        dateCreated,
+        createdBy ?? newId,
+      ),
+      mnemonic,
+    };
+  }
+}