@ibgib/core-gib 0.0.53 → 0.0.55

package/src/common/encrypt/encrypt-helper.mts

@@ -31,7 +31,6 @@ import { ENCRYPTION_REL8N_NAME, ENCRYPTION_ATOM, ENCRYPTION_NAME_REGEXP, } from
 import { MetaspaceService } from "../../witness/space/metaspace/metaspace-types.mjs";
 import { IbGibSpaceAny } from "../../witness/space/space-base-v1.mjs";
 import { SpecialIbGibType } from '../other/other-types.mjs';
-import { encrypt } from '@ibgib/encrypt-gib/dist/encrypt-decrypt.mjs';
 
 /**
  * for verbose logging
@@ -46,39 +45,39 @@ export function validateCommonEncryptionData({
     const lc = `[${validateCommonEncryptionData.name}]`;
     try {
         if (logalot) { console.log(`${lc} starting...`); }
-        if (!data) { throw new Error(`data required (E: )`); }
+        if (!data) { throw new Error(`data required (E: 9c7e015ad86041da89fa0a8490b19496)`); }
         const errors: string[] = [];
         const { name, uuid, classname, method, } = data;
 
         if (name) {
             if (!name.match(ENCRYPTION_NAME_REGEXP)) {
-                errors.push(`name must match regexp: ${ENCRYPTION_NAME_REGEXP} (E: )`);
+                errors.push(`name must match regexp: ${ENCRYPTION_NAME_REGEXP} (E: 3408de089b194553a1b9d2eb49fdda1c)`);
             }
         } else {
-            errors.push(`name required. (E: )`);
+            errors.push(`name required. (E: 1f4ec2f886a142279a91f852a13c3225)`);
         }
 
         if (method) {
             if (!VALID_ENCRYPTION_METHODS.includes(method)) {
-                errors.push(`method (${method}) is invalid. must be one of ${VALID_ENCRYPTION_METHODS.join(', ')} (E: )`);
+                errors.push(`method (${method}) is invalid. must be one of ${VALID_ENCRYPTION_METHODS.join(', ')} (E: 84a382b525944082badae40aebed497d)`);
             }
         } else {
-            errors.push(`method required. (E: )`);
+            errors.push(`method required. (E: 0bf6177233b24c9fa98499dc1453c0c9)`);
         }
 
         if (uuid) {
             if (!uuid.match(UUID_REGEXP)) {
-                errors.push(`uuid must match regexp: ${UUID_REGEXP} (E: )`);
+                errors.push(`uuid must match regexp: ${UUID_REGEXP} (E: bf54ee4ac10a4ee3a8fd1f5db17f1866)`);
             }
         }
 
         if (classname) {
             if (!classname.match(CLASSNAME_REGEXP)) {
-                errors.push(`classname must match regexp: ${CLASSNAME_REGEXP} (E: )`);
+                errors.push(`classname must match regexp: ${CLASSNAME_REGEXP} (E: 054087390a2d40daa6955e70e31c0cdb)`);
             }
         }
 
-        if (method === EncryptionMethod.encrypt_gib_weak) {
+        if (method === EncryptionMethod.encrypt_gib) {
             const encryptGibErrors = validateCommonEncryptionData_encryptGib({ data });
             encryptGibErrors.forEach(x => errors.push(x));
         }
@@ -132,7 +131,7 @@ function validateCommonEncryptionData_encryptGib({
             }
         }
 
-        if (data.salt) {
+        if (data.salt || data.salt === '') {
             if (typeof data.salt !== 'string') {
                 errors.push(`invalid salt (${data.salt}, typeof: ${typeof data.salt}). must be "string". (E: 0bee1f049dfd4f6e937cd423bb1b0c90)`)
             }
@@ -162,18 +161,18 @@ export async function validateCommonEncryptionIbGib({
 }): Promise<string[] | undefined> {
     const lc = `[${validateCommonEncryptionIbGib.name}]`;
     try {
-        if (logalot) { console.log(`${lc} starting... (I: )`); }
+        if (logalot) { console.log(`${lc} starting... (I: 48b13b0fe20146258ee921ed22a214d9)`); }
         const intrinsicErrors: string[] = await validateIbGibIntrinsically({ ibGib: ibGib }) ?? [];
 
-        if (!ibGib.data) { throw new Error(`EncryptionIbGib.data required (E: )`); }
+        if (!ibGib.data) { throw new Error(`EncryptionIbGib.data required (E: bdc7bbea44e042118352f4fa512fea43)`); }
         const ibErrors: string[] = [];
 
         // ib
         let { atom, method, name, } =
             parseEncryptionIb({ ib: ibGib.ib });
-        if (atom !== ENCRYPTION_ATOM) { ibErrors.push(`invalid encryption atom. must be ${ENCRYPTION_ATOM} (E: )`); }
-        if (!method) { ibErrors.push(`encryption method required (E: )`); }
-        if (!name) { ibErrors.push(`encryption name required (E: )`); }
+        if (atom !== ENCRYPTION_ATOM) { ibErrors.push(`invalid encryption atom. must be ${ENCRYPTION_ATOM} (E: 8437377bc6b548db846b8802e935812d)`); }
+        if (!method) { ibErrors.push(`encryption method required (E: b19999f74eff4d7da15867ba5907876b)`); }
+        if (!name) { ibErrors.push(`encryption name required (E: ae9bdc064f804f4a86f157cfe58274f7)`); }
 
         // data
         const dataErrors = validateCommonEncryptionData({ data: ibGib.data });
@@ -207,7 +206,7 @@ export function getEncryptionIb({
     const lc = `[${getEncryptionIb.name}]`;
     try {
         const validationErrors = validateCommonEncryptionData({ data });
-        if (validationErrors.length > 0) { throw new Error(`invalid Encryption data: ${validationErrors} (E: )`); }
+        if (validationErrors.length > 0) { throw new Error(`invalid Encryption data: ${validationErrors} (E: f2f124c1b55a496c835849cc9e67a96f)`); }
 
         const { name, method } = data;
 
@@ -234,15 +233,15 @@ export function parseEncryptionIb({
 } {
     const lc = `[${parseEncryptionIb.name}]`;
     try {
-        if (!ib) { throw new Error(`Encryption ib required (E: )`); }
+        if (!ib) { throw new Error(`Encryption ib required (E: 067fb72027f34ddc95dfba76fd429ed4)`); }
 
         const [atom, method, name] = ib.split(' ');
 
-        if (atom !== ENCRYPTION_ATOM) { throw new Error(`atom !== ${ENCRYPTION_ATOM} (E: )`); }
+        if (atom !== ENCRYPTION_ATOM) { throw new Error(`atom !== ${ENCRYPTION_ATOM} (E: 8361b9630e3f4f309ce48f1db278cc74)`); }
 
-        if (method !== EncryptionMethod.encrypt_gib_weak) { console.warn(`${lc} method !== EncryptionMethod.encrypt_gib_weak. atow (02/2024) .ncrypt_gib_weak is the only thing we got. (W: )`) }
+        if (method !== EncryptionMethod.encrypt_gib) { console.warn(`${lc} method (${method})!== EncryptionMethod.encrypt_gib. atow (02/2024) EncryptionMethod.encrypt_gib is the only thing we got. (W: 266540fa139544079e313e12d707aafe)`) }
 
-        if (!name.match(ENCRYPTION_NAME_REGEXP)) { throw new Error(`!name.match(ENCRYPTION_NAME_REGEXP) (E: )`); }
+        if (!name.match(ENCRYPTION_NAME_REGEXP)) { throw new Error(`!name.match(ENCRYPTION_NAME_REGEXP) (E: 5a49f74179d44b83a4cb4310e05cb2e3)`); }
 
         return { atom, method, name, };
     } catch (error) {
@@ -265,11 +264,11 @@ export async function createAndRegisterNewEncryption({
 }): Promise<EncryptionIbGib_V1> {
     const lc = `[${createAndRegisterNewEncryption.name}]`;
     try {
-        if (logalot) { console.log(`${lc} starting... (I: )`); }
+        if (logalot) { console.log(`${lc} starting... (I: 7839b94f046a43aebc2ac0ff350c464b)`); }
 
         let resEncryptionIbGib: EncryptionIbGib_V1;
 
-        if (encryptionMethod !== EncryptionMethod.encrypt_gib_weak) { throw new Error(`unknown encryptionMethod (${encryptionMethod}). only "encrypt-gib" encryption method currently implemented. (E: )`); }
+        if (encryptionMethod !== EncryptionMethod.encrypt_gib) { throw new Error(`unknown encryptionMethod (${encryptionMethod}). only "encrypt-gib" encryption method currently implemented. (E: bfc617eb731a4f99821fcdd3feba3835)`); }
 
         resEncryptionIbGib = await createAndRegisterNewEncryption_encryptGib({
             encryptionInfo: encryptionInfo as EncryptionInfo_EncryptGib,
@@ -297,10 +296,10 @@ async function createAndRegisterNewEncryption_encryptGib({
 }): Promise<EncryptionIbGib_V1> {
     const lc = `[${createAndRegisterNewEncryption_encryptGib.name}]`;
     try {
-        if (logalot) { console.log(`${lc} starting... (I: )`); }
+        if (logalot) { console.log(`${lc} starting... (I: 5413d44c92db43b0ab70afa962266828)`); }
 
         const { method: encryptionMethod } = encryptionInfo;
-        if (encryptionMethod !== 'encrypt-gib (weak)') { throw new Error(`(UNEXPECTED) encryptionMethod !== 'encrypt-gib (weak)'? (E: )`); }
+        if (encryptionMethod !== EncryptionMethod.encrypt_gib) { throw new Error(`(UNEXPECTED) encryptionMethod (${encryptionMethod}) !== ${EncryptionMethod.encrypt_gib}? (E: 5b1d1d2cd00e4ae1a759da2c4071b46d)`); }
 
         // create the encryption ibgib
         const data: EncryptionData_V1 = {
@@ -319,7 +318,7 @@ async function createAndRegisterNewEncryption_encryptGib({
         // validate right away before anything else
         const validationErrors =
             await validateCommonEncryptionIbGib({ ibGib: encryptionIbGib }) ?? [];
-        if (validationErrors.length > 0) { throw new Error(`(UNEXPECTED) newly created encryptionIbGib has validationErrors? validationErrors: ${validationErrors} (E: )`); }
+        if (validationErrors.length > 0) { throw new Error(`(UNEXPECTED) newly created encryptionIbGib has validationErrors? validationErrors: ${validationErrors} (E: 38791edd0b684eb58c6a194e055cadf9)`); }
 
         // save first in the space...
         await metaspace.persistTransformResult({ resTransform: resFirstGen, space });

package/src/common/encrypt/encrypt-types.mts

@@ -7,7 +7,7 @@ import { ENCRYPTION_REL8N_NAME } from './encrypt-constants.mjs';
 
 
 
-export type EncryptionMethod = 'encrypt-gib (weak)';
+export type EncryptionMethod = 'encrypt-gib';
 /**
  * Discriminator for the algorithm used in encryption that specifies the
  * algorithm used in encryption.
@@ -20,7 +20,7 @@ export const EncryptionMethod = {
      * custom probably very weak algorithm that uses indexing into a recursive
      * hash-based rounding function instead of keystream generation.
      */
-    encrypt_gib_weak: 'encrypt-gib (weak)' as EncryptionMethod,
+    encrypt_gib: 'encrypt-gib' as EncryptionMethod,
 }
 export const VALID_ENCRYPTION_METHODS = Object.values(EncryptionMethod);
 
@@ -41,7 +41,7 @@ export interface EncryptionInfo {
  * Parameter information that is specific to the encrypt-gib algorithm.
  */
 export interface EncryptionInfo_EncryptGib extends EncryptionInfo {
-    method: 'encrypt-gib (weak)'
+    method: 'encrypt-gib'
     /**
      * This is the algorithm that encrypt-gib will use in its
      * internal hashing round function to encrypt the data.

package/src/common/encrypt/encrypt.respec.mts

@@ -0,0 +1,90 @@
+/**
+ * @module encryption respec
+ *
+ * we gotta test our encryption ibgibs
+ */
+
+// import { cwd, chdir, } from 'node:process';
+// import { statSync } from 'node:fs';
+// import { mkdir, } from 'node:fs/promises';
+// import { ChildProcess, exec, ExecException } from 'node:child_process';
+import * as pathUtils from 'path';
+
+import {
+    firstOfAll, firstOfEach, ifWe, ifWeMight, iReckon,
+    lastOfAll, lastOfEach, respecfully, respecfullyDear
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+
+import {
+    extractErrorMsg, delay, getSaferSubstring,
+    getTimestampInTicks, getUUID, pretty, HashAlgorithm, clone, getTimestamp,
+} from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+
+import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
+import { EncryptionData_V1, EncryptionMethod } from './encrypt-types.mjs';
+import { SaltStrategy } from '@ibgib/encrypt-gib/dist/types.mjs';
+import { getEncryptionIb, parseEncryptionIb } from './encrypt-helper.mjs';
+import { ENCRYPTION_ATOM } from './encrypt-constants.mjs';
+
+/**
+ * for verbose logging
+ */
+const logalot = GLOBAL_LOG_A_LOT; // change this when you want to turn off verbose logging
+
+const lcFile: string = `[${pathUtils.basename(import.meta.url)}]`;
+
+const atom = ENCRYPTION_ATOM;
+const recursionCount = 168;
+const hashAlgorithm: HashAlgorithm = 'SHA-256';
+const saltPrependedPerHash = '';
+const saltStrategy = SaltStrategy.prependPerHash;
+const initialRecursions = 1000;
+const recursionsPerHash = 2;
+const method: EncryptionMethod = EncryptionMethod.encrypt_gib;
+
+const salt_empty = ''; //
+const description = 'description yo';
+
+const blockName = `encryption ib`;
+await respecfully(maam, blockName, async () => {
+    const lc = `${lcFile}[${blockName}]`;
+    debugger;
+
+    const name = await getUUID();
+    const timestampDate = new Date();
+    const timestamp = getTimestamp(timestampDate);
+    const timestampMs = timestampDate.getMilliseconds().toString();
+
+
+    const data_valid: EncryptionData_V1 = {
+        name,
+        hashAlgorithm,
+        initialRecursions: 1000,
+        method,
+        salt: salt_empty,
+        description,
+        encryptedDataDelimiter: undefined,
+        recursionsPerHash,
+        saltStrategy,
+        n: 0, timestamp, timestampMs,
+    };
+
+
+    await ifWe(maam, `getEncryptionIb`, async () => {
+        const data = data_valid;
+        let ib = getEncryptionIb({ data });
+        iReckon(sir, ib.includes(name)).asTo('name').isGonnaBeTrue();
+        iReckon(sir, ib.includes(method)).asTo('method').isGonnaBeTrue();
+    });
+    await ifWe(maam, `parseEncryptionIb`, async () => {
+        const data = data_valid;
+        let ib = getEncryptionIb({ data });
+        let parsed = parseEncryptionIb({ ib });
+
+        iReckon(sir, parsed.atom).asTo('atom').isGonnaBe(atom);
+        iReckon(sir, parsed.name).asTo('name').isGonnaBe(name);
+        iReckon(sir, parsed.method).asTo('method').isGonnaBe(method);
+    });
+
+});

package/src/common/secret/secret-helper.mts

@@ -15,8 +15,7 @@ import {
     extractErrorMsg, delay, getSaferSubstring,
     getTimestampInTicks, getUUID, pretty, HashAlgorithm, getTimestamp,
 } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
-import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
-import { UUID_REGEXP, CLASSNAME_REGEXP, } from '@ibgib/helper-gib/dist/constants.mjs';
+import { CLASSNAME_REGEXP, } from '@ibgib/helper-gib/dist/constants.mjs';
 import { Ib, } from '@ibgib/ts-gib/dist/types.mjs';
 import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 import { Factory_V1 } from "@ibgib/ts-gib/dist/V1/factory.mjs";
@@ -26,7 +25,6 @@ import { CheckIfPasswordProbablyCorrectInfo, SecretData_V1, SecretIbGib_V1, Secr
 import { SECRET_ATOM, SECRET_NAME_REGEXP, SECRET_REL8N_NAME, } from './secret-constants.mjs';
 import { MetaspaceService } from "../../witness/space/metaspace/metaspace-types.mjs";
 import { IbGibSpaceAny } from "../../witness/space/space-base-v1.mjs";
-import { SpecialIbGibType } from "../other/other-types.mjs";
 import { INVALID_DATE_STRING } from '../other/other-constants.mjs';
 import { hash16816 } from '../other/ibgib-helper.mjs';
 

package/src/witness/space/metaspace/metaspace-base.mts

@@ -25,6 +25,7 @@ import { RootData } from '../../../common/root/root-types.mjs';
 import {
     CiphertextData, CiphertextIbGib_V1, CiphertextRel8ns,
     EncryptionData_V1, EncryptionIbGib_V1, EncryptionInfo_EncryptGib,
+    EncryptionMethod,
 } from '../../../common/encrypt/encrypt-types.mjs';
 import { RobbotIbGib_V1 } from '../../../witness/robbot/robbot-types.mjs';
 import { AppIbGib_V1 } from '../../../witness/app/app-types.mjs';
@@ -1796,7 +1797,7 @@ export abstract class MetaspaceBase implements MetaspaceService {
         const lc = `${this.lc}[${this.getCiphertextIbGib.name}]`;
         try {
             const encryptionInfo = encryptionIbGib.data;
-            if (encryptionInfo?.method !== 'encrypt-gib (weak)') {
+            if (encryptionInfo?.method !== EncryptionMethod.encrypt_gib) {
                 throw new Error('only encrypt-gib is implemented.');
             }
             const info: EncryptionInfo_EncryptGib = encryptionInfo;