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/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])