mybase 1.1.42 → 1.1.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.42",
+  "version": "1.1.44",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/models/OTPGenerator.d.ts

@@ -1,8 +1,12 @@
+import { Timespan } from './Timespan';
 export declare class OTPGenerator {
     private passkey;
     private length;
     constructor(passkey: string, length?: number);
     generateOTP(): string;
     validateOTP(otp: string): boolean;
-    private generateOTPWithNonce;
+    age(otp: string): Timespan;
+    generateOTPWithNonce(nonce: number): string;
+    private isValid;
+    private extractNonce;
 }

package/ts/models/OTPGenerator.js

@@ -25,8 +25,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OTPGenerator = void 0;
 const crypto = __importStar(require("crypto"));
+const Timespan_1 = require("./Timespan");
 class OTPGenerator {
-    constructor(passkey, length = 5) {
+    constructor(passkey, length = 4) {
         this.passkey = passkey;
         this.length = length;
     }
@@ -36,18 +37,32 @@ class OTPGenerator {
     }
     // Validate if the OTP matches by extracting the nonce and regenerating OTP
     validateOTP(otp) {
-        if (otp.length !== this.length + 13)
-            return false;
-        const nonceHex = otp.slice(-13);
-        const nonce = parseInt(nonceHex, 16);
+        if (!this.isValid(otp))
+            return false; // Validate plausibility of OTP
+        const nonce = this.extractNonce(otp);
         return otp === this.generateOTPWithNonce(nonce);
     }
-    // Helper to generate OTP based on a specific nonce
+    // Get the age of the OTP compared to now
+    age(otp) {
+        if (!this.isValid(otp))
+            throw new Error('Invalid OTP');
+        const nonce = this.extractNonce(otp);
+        return new Timespan_1.Timespan(Date.now() - nonce);
+    }
     generateOTPWithNonce(nonce) {
         const hash = crypto.createHmac('sha256', this.passkey).update(nonce.toString()).digest('hex');
         const otp = [...hash.slice(0, this.length)].map(char => String.fromCharCode((parseInt(char, 16) % 26) + 97)).join('');
         return `${otp}${nonce.toString(16).padStart(13, '0')}`;
     }
+    // Private helper to validate plausibility of OTP
+    isValid(otp) {
+        return otp.length === this.length + 13;
+    }
+    // Private helper to extract the nonce from the OTP
+    extractNonce(otp) {
+        const nonceHex = otp.slice(-13);
+        return parseInt(nonceHex, 16);
+    }
 }
 exports.OTPGenerator = OTPGenerator;
 //# sourceMappingURL=OTPGenerator.js.map

package/ts/models/OTPGenerator.test.ts

@@ -1,9 +1,11 @@
 import { OTPGenerator } from './OTPGenerator';
 import { wait } from './../funcs/wait';
+import { Timespan } from './Timespan';
 
+const passkey = 'hiowi3rmpewr34';
 describe('OTPGenerator', () => {
     it('should generate OTP', () => {
-        const otpGenerator = new OTPGenerator('h0424m43io4', 5);
+        const otpGenerator = new OTPGenerator(passkey, 5);
         const otp = otpGenerator.generateOTP();
         // length should be 5  + 13
         expect(otp.length).toBe(18);
@@ -11,7 +13,7 @@ describe('OTPGenerator', () => {
     })
 
     it('should generate different OTPs in milliseconds', async () => {
-        const otpGenerator = new OTPGenerator('h0424m43io4', 5);
+        const otpGenerator = new OTPGenerator(passkey, 5);
         const otp1 = otpGenerator.generateOTP()
         await wait(1/1000);
         const otp2 = otpGenerator.generateOTP();
@@ -19,12 +21,22 @@ describe('OTPGenerator', () => {
     })
 
     it('should generate different OTPs in milliseconds per password', async () => {
-        const otpGenerator1 = new OTPGenerator('h0424m43io4', 5);
-        const otpGenerator2 = new OTPGenerator('h0424m43io5', 5);
+        const otpGenerator1 = new OTPGenerator(passkey+'1', 5);
+        const otpGenerator2 = new OTPGenerator(passkey+'2', 5);
         for(let i=0; i<10000; i++) {
             const otp1 = otpGenerator1.generateOTP()
             const otp2 = otpGenerator2.generateOTP();
             expect(otp1).not.toBe(otp2);
         }
     })
+
+    it('age should be milliseconds since generation', async () => {
+        const otpGenerator = new OTPGenerator(passkey, 5);
+        const otp = otpGenerator.generateOTP();
+        await wait(1/1000);
+        const age = otpGenerator.age(otp);
+        expect(age).toBeInstanceOf(Timespan);
+        expect(age.miliseconds).toBeGreaterThan(0);
+        expect(age.miliseconds).toBeLessThan(100);
+    })
 });

package/ts/models/OTPGenerator.ts

@@ -1,7 +1,9 @@
 import * as crypto from 'crypto';
+import { Timespan } from './Timespan';
+
 
 export class OTPGenerator {
-    constructor(private passkey: string, private length: number = 5) {}
+    constructor(private passkey: string, private length: number = 4) {}
 
     // Generate OTP with the current timestamp as nonce
     public generateOTP(): string {
@@ -10,16 +12,32 @@ export class OTPGenerator {
 
     // Validate if the OTP matches by extracting the nonce and regenerating OTP
     public validateOTP(otp: string): boolean {
-        if (otp.length !== this.length + 13) return false;
-        const nonceHex = otp.slice(-13);
-        const nonce = parseInt(nonceHex, 16);
+        if (!this.isValid(otp)) return false; // Validate plausibility of OTP
+        const nonce = this.extractNonce(otp);
         return otp === this.generateOTPWithNonce(nonce);
     }
 
-    // Helper to generate OTP based on a specific nonce
-    private generateOTPWithNonce(nonce: number): string {
+    // Get the age of the OTP compared to now
+    public age(otp: string): Timespan {
+        if (!this.isValid(otp)) throw new Error('Invalid OTP');
+        const nonce = this.extractNonce(otp);
+        return new Timespan(Date.now() - nonce)
+    }
+
+    public generateOTPWithNonce(nonce: number): string { // lets keep it public for testing
         const hash = crypto.createHmac('sha256', this.passkey).update(nonce.toString()).digest('hex');
         const otp = [...hash.slice(0, this.length)].map(char => String.fromCharCode((parseInt(char, 16) % 26) + 97)).join('');
         return `${otp}${nonce.toString(16).padStart(13, '0')}`;
     }
+
+    // Private helper to validate plausibility of OTP
+    private isValid(otp: string): boolean {
+        return otp.length === this.length + 13;
+    }
+
+    // Private helper to extract the nonce from the OTP
+    private extractNonce(otp: string): number {
+        const nonceHex = otp.slice(-13);
+        return parseInt(nonceHex, 16);
+    }
 }