@sswroom/sswr 1.6.12 → 1.6.14

package/crypto.d.ts

@@ -0,0 +1,27 @@
+export abstract class ICrypto
+{
+	abstract encrypt(inBuff: ArrayBuffer): Promise<ArrayBuffer | null>;
+	abstract decrypt(inBuff: ArrayBuffer): Promise<ArrayBuffer | null>;
+	
+	abstract getEncBlockSize(): number;
+	abstract getDecBlockSize(): number;
+
+	static keyToBuffer(key: string, nBytes: number): ArrayBuffer;
+}
+
+export class AES256GCM extends ICrypto
+{
+	constructor(key: ArrayBuffer, iv: ArrayBuffer);
+
+	encrypt(inBuff: ArrayBuffer): Promise<ArrayBuffer | null>;
+	decrypt(inBuff: ArrayBuffer): Promise<ArrayBuffer | null>;
+
+	getEncBlockSize(): number;
+	getDecBlockSize(): number;
+
+	/**
+	 * 12 byte length
+	 * @param iv Initial Vector
+	 */
+	setIV(iv: ArrayBuffer): void;
+}

package/crypto.js

@@ -0,0 +1,149 @@
+export class ICrypto
+{
+	/**
+	 * @param {ArrayBuffer} inBuff
+	 * @returns {Promise<ArrayBuffer|null>}
+	 */
+	async encrypt(inBuff)
+	{
+		throw new Error("ICrypto.encrypt must be inherited");
+	}
+
+	/**
+	 * @param {ArrayBuffer} inBuff
+	 * @returns {Promise<ArrayBuffer|null>}
+	 */
+	async decrypt(inBuff)
+	{
+		throw new Error("ICrypto.decrypt must be inherited");
+	}
+	
+	/**
+	 * @returns {number}
+	 */
+	getEncBlockSize()	/**
+	* @returns {number}
+	*/
+
+	{
+		throw new Error("ICrypto.getEncBlockSize must be inherited");
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	getDecBlockSize()
+	{
+		throw new Error("ICrypto.getDecBlockSize must be inherited");
+	}
+
+	
+	/**
+	 * @param {string} key
+	 * @param {number} nBytes
+	 * @returns {Uint8Array}
+	 */
+	static keyToBuffer(key, nBytes)
+	{
+		let enc = new TextEncoder();
+		let arr = enc.encode(key);
+		if (arr.length >= nBytes)
+		{
+			return arr.subarray(0, nBytes);
+		}
+		else
+		{
+			let ret = new Uint8Array(nBytes);
+			let i = 0;
+			let j = arr.length;
+			let k = 0;
+			while (i < nBytes)
+			{
+				if (k >= j)
+				{
+					ret[i] = 0x7f;
+					k = 0;
+				}
+				else
+				{
+					ret[i] = arr[k];
+					k++;
+				}
+				i++;
+			}
+			return ret;
+		}
+	}
+}
+
+export class AES256GCM extends ICrypto
+{
+	/**
+	 * @param {ArrayBuffer} key
+	 * @param {ArrayBuffer} iv
+	 */
+	constructor(key, iv)
+	{
+		super();
+		if (key.byteLength != 32)
+		{
+			throw new Error("key must be 32 bytes long");
+		}
+		this.key = key;
+		this.setIV(iv);
+	}
+
+	/**
+	 * @param {ArrayBuffer} inBuff
+	 */
+	async encrypt(inBuff)
+	{
+		if (window.crypto.subtle == null)
+		{
+			return null;
+		}
+		let key = await window.crypto.subtle.importKey("raw", this.key, {name: "AES-GCM"}, false, ["encrypt", "decrypt"]);
+		return await window.crypto.subtle.encrypt( {
+			name: "AES-GCM",
+			iv: this.iv
+		  }, key, inBuff);
+	}
+
+	/**
+	 * @param {ArrayBuffer} inBuff
+	 */
+	async decrypt(inBuff)
+	{
+		if (window.crypto.subtle == null)
+		{
+			return null;
+		}
+		let key = await window.crypto.subtle.importKey("raw", this.key, {name: "AES-GCM"}, false, ["encrypt", "decrypt"]);
+		return await window.crypto.subtle.decrypt( {
+			name: "AES-GCM",
+			iv: this.iv
+		  }, key, inBuff);
+	}
+
+	getEncBlockSize()
+	{
+		return 16;
+	}
+
+	getDecBlockSize()
+	{
+		return 16;
+	}
+
+	/**
+	 * @param {ArrayBuffer} iv
+	 */
+	setIV(iv)
+	{
+		if (iv.byteLength != 12)
+		{
+			throw new Error("iv must be 12 bytes long");
+		}
+		this.iv = iv;
+	}
+}

package/data.d.ts

@@ -83,6 +83,7 @@ export class DateTimeUtil
 	static parseMonthStr(month: string): number;
 	static dayInMonth(year: number, month: number): number;
 	static getLocalTzQhr(): number;
+	static secs2FILETIME(secs: bigint, nanosec: number): bigint;
 }
 
 export class Duration
@@ -156,6 +157,7 @@ export class TimeInstant
 	toEpochSec(): bigint;
 	toEpochMS(): bigint;
 	toEpochNS(): bigint;
+	toFILETIME(): bigint;
 	static fromDotNetTicks(ticks: bigint | number): TimeInstant;
 }
 
@@ -164,7 +166,7 @@ export class Timestamp {
 	tzQhr: number;
 
 	constructor(inst: TimeInstant, tzQhr?: number);
-	static fromTicks(ticks: number | number, tzQhr?: number): Timestamp;
+	static fromTicks(ticks: number | bigint, tzQhr?: number): Timestamp;
 	static fromStr(str: string, defTzQhr?: number): Timestamp | null;
 	static now(): Timestamp;
 	static utcNow(): Timestamp;
@@ -203,6 +205,9 @@ export class Timestamp {
 	toEpochSec(): bigint;
 	toEpochMS(): bigint;
 	toEpochNS(): bigint;
+	toMSDOSDate(): number;
+	toMSDOSTime(): number;
+	toFILETIME(): bigint;
 	toString(pattern?: string): string;
 	toStringISO8601(): string;
 	toStringNoZone(): string;
@@ -251,6 +256,29 @@ export class ByteReader
 	isASCIIText(ofst: number, len: number): boolean;
 }
 
+export class ByteBuilder
+{
+	tmpBuff: Uint8Array;
+	view: DataView;
+	buff: number[];
+
+	constructor();
+	writeInt8(ofst: number, value: number): void;
+	writeInt16(ofst: number, value: number, lsb: boolean): void;
+	writeInt24(ofst: number, value: number, lsb: boolean): void;
+	writeInt32(ofst: number, value: number, lsb: boolean): void;
+	writeInt64(ofst: number, value: bigint, lsb: boolean): void;
+	writeFloat64(ofst: number, value: number, lsb: boolean): void;
+	/** @returns number of bytes written */
+	writeUTF8(ofst: number, value: string): number;
+	/** @returns number of bytes written */
+	writeUTF16(ofst: number, value: string, lsb: boolean): number;
+	writeUInt8Array(ofst: number, buff: Uint8Array): void;
+	build(): Uint8Array;
+
+	allocBuff(ofst: number, len: number): void;
+}
+
 export abstract class ParsedObject
 {
 	sourceName: string;