fix: normalized the password check

Author: martinheidegger

src/utils/codecs/crockford-base32.ts

@@ -68,6 +68,21 @@ function encode(input: Uint8Array) {
   return output.map((byte) => c32[byte]).join("");
 }
 
+export function splitBase32(input: string): string {
+  const middle = Math.floor(input.length / 2);
+  const quart = Math.floor(middle / 2);
+  const secondQuart = middle + Math.floor((input.length - middle) / 2);
+  return (
+    input.substring(0, quart) +
+    "-" +
+    input.substring(quart, middle) +
+    "-" +
+    input.substring(middle, secondQuart) +
+    "-" +
+    input.substring(secondQuart)
+  );
+}
+
 export function sanitizeCrockfordBase32(
   input: string,
   ignoreUnknown: true,
@@ -85,16 +100,13 @@ export function sanitizeCrockfordBase32(input: string, ignoreUnknown: boolean) {
       continue;
     }
     if (validChar !== undefined) {
-      if (count % 5 === 0 && count !== 0) {
-        sane += "-";
-      }
       count += 1;
       sane += c32[validChar];
     } else if (!ignoreUnknown) {
       return null;
     }
   }
-  return sane;
+  return splitBase32(sane);
 }
 
 function decode(input: string) {

src/utils/crypto.ts

@@ -122,6 +122,17 @@ export interface PasswordGenerator {
   entropyNeeded: number;
   entropyProvided: number;
   getRandom(random: RandomSource): string;
+  getPossiblePassword(input: string): string | undefined;
+}
+
+export function getPossibleWordsPassword(input: string, size: number) {
+  if (input.length !== size) {
+    return undefined;
+  }
+  if (!/^[a-z-]+$/.test(input)) {
+    return undefined;
+  }
+  return input;
 }
 
 export class RandomWords implements PasswordGenerator {
@@ -154,6 +165,10 @@ export class RandomWords implements PasswordGenerator {
     this.entropyProvided = this.weighted.entropyProvided;
   }
 
+  getPossiblePassword(input: string): string | undefined {
+    return getPossibleWordsPassword(input, this.targetLength);
+  }
+
   getRandom(random: RandomSource): string {
     return this.weighted
       .getRandom(random)

src/utils/password-base32.ts

@@ -1,20 +1,27 @@
-import { crockfordBase32 } from "@/utils/codecs/crockford-base32";
+import {
+  crockfordBase32,
+  sanitizeCrockfordBase32,
+  splitBase32,
+} from "@/utils/codecs/crockford-base32";
 import type { PasswordGenerator, RandomSource } from "@/utils/crypto";
 
 function toReadableHash(input: Uint8Array) {
   const c = crockfordBase32.encode(input);
-  const middle = Math.floor(c.length / 2);
-  const quart = Math.floor(middle / 2);
-  const secondQuart = middle + Math.floor((c.length - middle) / 2);
-  return (
-    c.substring(0, quart) +
-    "-" +
-    c.substring(quart, middle) +
-    "-" +
-    c.substring(middle, secondQuart) +
-    "-" +
-    c.substring(secondQuart)
-  );
+  return splitBase32(c);
+}
+
+export function getPossibleBase32Password(
+  input: string,
+  size: number,
+): string | undefined {
+  const key = sanitizeCrockfordBase32(input, false);
+  if (!key) {
+    return undefined;
+  }
+  if (key.length !== size) {
+    return undefined;
+  }
+  return key;
 }
 
 class RandomBase32 implements PasswordGenerator {
@@ -35,6 +42,10 @@ class RandomBase32 implements PasswordGenerator {
     this.entropyProvided = bits;
   }
 
+  getPossiblePassword(input: string): string | undefined {
+    return getPossibleBase32Password(input, this.targetLength);
+  }
+
   getRandom(random: RandomSource) {
     return toReadableHash(random.getBytes(this.buffer));
   }

src/utils/password-generators.ts

@@ -1,4 +1,8 @@
 import { passwordBase32 } from "@/utils/password-base32";
 import { passwordWords } from "@/utils/password-dict-words";
+import type { PasswordGenerator } from "./crypto";
 
-export const passwordGenerators = [passwordBase32, passwordWords];
+export const passwordGenerators: PasswordGenerator[] = [
+  passwordBase32,
+  passwordWords,
+];

src/utils/safeDoc.ts

@@ -11,6 +11,7 @@ import type {
 } from "@/utils/codecs";
 import { codecs } from "@/utils/codecs";
 import { uniqueRequests } from "@/utils/requests";
+import { passwordGenerators } from "./password-generators";
 
 export {
   createDocCodec,
@@ -91,25 +92,13 @@ export async function toPublicKey(privateKey: string) {
   );
 }
 
-export function getPossibleDocKey(input: string) {
-  return getPossibleBase32Key(input) ?? getPossibleWordsKey(input);
-}
-
-function getPossibleWordsKey(input: string) {
-  if (/^[a-z-]{38}/.test(input)) {
-    return input;
-  }
-}
-
-function getPossibleBase32Key(input: string) {
-  const key = sanitizeCrockfordBase32(input, false);
-  if (!key) {
-    return undefined;
-  }
-  if (key.length !== 23) {
-    return undefined;
+export function getPossibleDocKey(input: string): string | undefined {
+  for (const generator of passwordGenerators) {
+    const key = generator.getPossiblePassword(input);
+    if (key !== undefined) {
+      return key;
+    }
   }
-  return key;
 }
 
 export interface ParsedDocument<