El enlace de activación vuelve a ser alfanumérico; avisar a qué correo se envió

Dos cosas que el port de Django cambió sin querer:

- El hash de activación se generaba con `randomBytes(16).toString('hex')`: 32
  caracteres, sí, pero solo `0-9a-f`. El original era `get_random_string(32)`,
  alfanumérico con mayúsculas y minúsculas (`?act=P4JHQDJey2jJDnEBnqUePI5O2qEFB1`).
- El aviso de cuenta creada era un genérico «Revisa tu correo», mientras que el
  original decía qué cuenta se creó y a qué dirección fue el enlace. Se recupera
  el formato de dos líneas (con id `create-response`, como el original).

El muestreo por rechazo del token de seguridad se sube a `lib/random-token.ts` y
lo comparten los dos generadores, que solo se diferencian en el alfabeto: letras
para el token que se teclea a mano, alfanumérico para el hash de la URL.

Verificado con 100.000 hashes: todos casan /^[A-Za-z0-9]{32}$/, salen los 62
caracteres y la desviación por carácter se queda en 1,3% (ruido).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

web-next/lib/random-token.ts

@@ -0,0 +1,30 @@
+import crypto from 'node:crypto'
+
+/** Letras y dígitos: el alfabeto por defecto del `get_random_string` de Django. */
+export const ALPHANUMERIC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+/** Solo letras, para el token de seguridad (formato `uRlPBR`). */
+export const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+
+/**
+ * Código aleatorio de `length` caracteres tomados de `alphabet`.
+ *
+ * Estos códigos se portaron del Django original como `randomBytes(n).toString('hex')`,
+ * que cambiaba el formato sin querer: hex solo usa `0-9a-f`, mientras que el
+ * `get_random_string` original daba alfanumérico con mayúsculas y minúsculas.
+ *
+ * Muestreo por rechazo: 256 no suele ser múltiplo del tamaño del alfabeto, así que
+ * `byte % alphabet.length` haría más probables sus primeros caracteres. Descartando
+ * los bytes desde el múltiplo más alto que cabe en uno, el reparto queda uniforme.
+ */
+export function randomToken(length: number, alphabet: string = ALPHANUMERIC): string {
+  const limit = 256 - (256 % alphabet.length)
+  let token = ''
+  while (token.length < length) {
+    for (const byte of crypto.randomBytes(length)) {
+      if (byte >= limit) continue
+      token += alphabet[byte % alphabet.length]
+      if (token.length === length) break
+    }
+  }
+  return token
+}

web-next/lib/register.ts

@@ -1,9 +1,9 @@
-import crypto from 'node:crypto'
 import type { ResultSetHeader, RowDataPacket } from 'mysql2'
 import { db, DB } from './db'
 import { normalizeEmail, bnetMakeRegistration, gameMakeRegistration, makeGameAccountUsername } from './bnet'
 import { sendMail } from './mail'
 import { activationEmailHtml } from './emails'
+import { randomToken } from './random-token'
 
 const GMAIL_RE = /^[a-zA-Z0-9._%+-]+@gmail\.com$/
 
@@ -66,7 +66,10 @@ export async function registerAccount(input: RegisterInput): Promise<Result> {
     }
   }
 
-  const hash = crypto.randomBytes(16).toString('hex') // 32 hex chars (col hash = CharField(32))
+  // 32 alfanuméricos, como el `get_random_string(32)` original (col hash = varchar(32)).
+  // Se portó como `randomBytes(16).toString('hex')`, que llenaba los 32 caracteres pero
+  // solo con `0-9a-f`: cambiaba el formato del enlace de activación sin querer.
+  const hash = randomToken(32)
   await db(DB.default).query(
     'INSERT INTO accountactivation (email, password, recruiter_id, hash, created_at, is_used, is_new_email_used) VALUES (?, ?, ?, ?, NOW(), 0, 0)',
     [email, password, recruiterId, hash],

web-next/lib/security-token.ts

@@ -1,8 +1,8 @@
-import crypto from 'node:crypto'
 import type { RowDataPacket } from 'mysql2'
 import { db, DB } from './db'
 import { sendMail } from './mail'
 import { securityTokenEmailHtml } from './emails'
+import { randomToken, LETTERS } from './random-token'
 import type { SessionData } from './session'
 
 export interface Result {
@@ -11,35 +11,16 @@ export interface Result {
   tokenDate?: string
 }
 
-/** Letras A-Z y a-z, sin dígitos: el formato del token es `uRlPBR`. */
-const TOKEN_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
-const TOKEN_LENGTH = 6
-
 /**
- * Genera el token de seguridad: 6 letras al azar.
+ * 6 letras, sin dígitos (formato `uRlPBR`).
  *
  * Antes era `randomBytes(4).toString('base64url').slice(0, 6)`, portado tal cual
  * del Django original (`secrets.token_urlsafe(4)[:6]`). Tenía dos taras: metía
  * `-` y `_` en un código que se lee y se teclea desde un correo, y sobre todo 4
  * bytes son 32 bits mientras que 6 caracteres base64 codifican 36 → al último
  * carácter solo le llegaban 2 bits reales y SIEMPRE salía `A`, `Q`, `g` o `w`.
- *
- * Muestreo por rechazo: 256 no es múltiplo de 52, así que `byte % 52` haría más
- * probables las primeras letras del alfabeto. Descartando los bytes >= 208
- * (52*4, el múltiplo de 52 más alto que cabe en un byte) el reparto es uniforme.
  */
-function generateSecurityToken(): string {
-  const limit = 256 - (256 % TOKEN_ALPHABET.length)
-  let token = ''
-  while (token.length < TOKEN_LENGTH) {
-    for (const byte of crypto.randomBytes(TOKEN_LENGTH)) {
-      if (byte >= limit) continue
-      token += TOKEN_ALPHABET[byte % TOKEN_ALPHABET.length]
-      if (token.length === TOKEN_LENGTH) break
-    }
-  }
-  return token
-}
+const TOKEN_LENGTH = 6
 
 /** Solicita un token de seguridad (6 letras) por email. 1 cada 7 días. */
 export async function requestSecurityToken(session: SessionData, ip: string): Promise<Result> {
@@ -56,7 +37,7 @@ export async function requestSecurityToken(session: SessionData, ip: string): Pr
     if (days < 7) return { success: false, error: 'cooldown' }
   }
 
-  const token = generateSecurityToken()
+  const token = randomToken(TOKEN_LENGTH, LETTERS)
   const expiresAt = new Date(Date.now() + 7 * 86400_000)
 
   await db(DB.default).query('DELETE FROM securitytoken WHERE user_id = ?', [userId])