backend-plus 2.5.2-betha.27 → 2.5.2-betha.28

package/lib/backend-plus.js

@@ -85,61 +85,115 @@ function md5(text){
 
 const DEFAULT_ITERATIONS = 4096; 
 const HASH_ALGORITHM = 'sha256';
-const KEY_LENGTH = 64; // Longitud de la clave (64 bytes)
+
+// primera version de scram sha 256. El Verifier completo tenía 64 bytes.
+const LEGACY_KEY_LENGTH = 64; 
+
+// Formato nuevo/PG-Compatible: El Client Key tiene 32 bytes (SHA-256).
+const SCRAM_KEY_LENGTH = 32; 
+
 const bufferToBase64 = (buffer) => buffer.toString('base64');
 
 /**
- * Función central para PBKDF2.
- * Devuelve la clave derivada.
+ * Función central para PBKDF2 (Acepta KEY_LEN para compatibilidad).
+ * Devuelve la clave derivada con la longitud especificada.
  */
-function deriveKey(password, salt, iterations) {
+function deriveKey(password, saltBuffer, iterations, keyLength) { 
     return new Promise((resolve, reject) => {
         crypto.pbkdf2(
             password, 
-            salt, 
+            saltBuffer,
             iterations, 
-            KEY_LENGTH, 
+            keyLength,
             HASH_ALGORITHM, 
             (err, derivedKey) => {
                 if (err) return reject(err);
-                resolve(derivedKey);
+                resolve(derivedKey); 
             }
         );
     });
 }
 
+async function generateScramVerifier(password) {
+    const saltBuffer = crypto.randomBytes(16); 
+    const saltBase64 = bufferToBase64(saltBuffer);
+
+    const Hi = await deriveKey(
+        password, 
+        saltBuffer, 
+        DEFAULT_ITERATIONS,
+        SCRAM_KEY_LENGTH 
+    );
+    const clientKey = crypto.createHmac('sha256', Hi).update('Client Key').digest();
+    const serverKey = crypto.createHmac('sha256', Hi).update('Server Key').digest();
+
+    const storedKey = crypto.createHash('sha256').update(clientKey).digest();
+
+    const storedKeyBase64 = bufferToBase64(storedKey);
+    const serverKeyBase64 = bufferToBase64(serverKey);
+
+    return `SCRAM-SHA-256$${DEFAULT_ITERATIONS}:${saltBase64}$${storedKeyBase64}:${serverKeyBase64}`;
+}
+
 /**
- * Genera la cadena de verificación SCRAM-SHA-256 en formato PostgreSQL.
- * Formato: SCRAM-SHA-256$iterations:salt$verifier
+ * Verifica una contraseña contra el hash SCRAM PG-Compatible.
+ * Formato PG: SCRAM-SHA-256$<iteraciones>:<Salt>$<StoredKey>:<ServerKey>
  * @param {string} password - Contraseña en texto plano.
- * @returns {Promise<string>} La cadena SCRAM completa.
+ * @param {string} storedScramString - Cadena SCRAM de PostgreSQL.
+ * @returns {Promise<boolean>} True si la contraseña es válida.
  */
-async function generateScramVerifier(password) {
-    // Genera Salt aleatoria
-    const saltBuffer = crypto.randomBytes(32);
-    const saltBase64 = bufferToBase64(saltBuffer);
+async function verifyScramPG(password, storedScramString) {
+    if (!storedScramString.startsWith('SCRAM-SHA-256$')) {
+        return false;
+    }
+    
+    const parts = storedScramString.split('$');
+    if (parts.length !== 3) {
+        return false;
+    }
+        
+    const [storedIterations, saltBase64] = parts[1].split(':');
+    const [storedKeyBase64, serverKeyBase64] = parts[2].split(':'); // Asume StoredKey y ServerKey
 
-    // Deriva la clave (Verifier)
-    const verifierBuffer = await deriveKey(
+    if (!saltBase64 || !storedKeyBase64 || !serverKeyBase64 || isNaN(parseInt(storedIterations))) {
+        return false;
+    }
+    
+    const iterations = parseInt(storedIterations);
+    const saltBuffer = Buffer.from(saltBase64, 'base64');
+    const storedKeyBuffer = Buffer.from(storedKeyBase64, 'base64');
+    const serverKeyBuffer = Buffer.from(serverKeyBase64, 'base64');
+
+    const Hi = await deriveKey(
         password, 
-        saltBase64, 
-        DEFAULT_ITERATIONS
+        saltBuffer, 
+        iterations,
+        SCRAM_KEY_LENGTH
     );
-    const verifierBase64 = bufferToBase64(verifierBuffer);
 
-    // Ensambla la cadena final (PostgreSQL style)
-    // Usa $ como delimitador principal (aunque PostgreSQL lo pone dentro de la tabla).
-    // El formato canónico es 'SCRAM-SHA-256$i:salt, verifier$encoded_verifier'
-    return `SCRAM-SHA-256$${DEFAULT_ITERATIONS}:${saltBase64}$${verifierBase64}`;
+    const clientKey = crypto.createHmac(HASH_ALGORITHM, Hi)
+        .update('Client Key')
+        .digest();
+
+    const serverKeyActual = crypto.createHmac(HASH_ALGORITHM, Hi)
+        .update('Server Key')
+        .digest();
+
+    const storedKeyActual = crypto.createHash('sha256').update(clientKey).digest();
+
+    const storedKeyMatch = crypto.timingSafeEqual(storedKeyActual, storedKeyBuffer);
+    const serverKeyMatch = crypto.timingSafeEqual(serverKeyActual, serverKeyBuffer);
+    return storedKeyMatch && serverKeyMatch;
 }
 
 /**
- * Verifica una contraseña en texto plano contra la cadena SCRAM almacenada.
- * @param {string} password - Contraseña en texto plano ingresada por el usuario.
- * @param {string} storedScramString - Cadena SCRAM completa (ej: SCRAM-SHA-256$4096:SALT_BASE64$VERIFIER_BASE64).
+ * Verifica una contraseña contra el hash SCRAM Legacy (64 bytes).
+ * Formato Legacy: SCRAM-SHA-256$<iteraciones>:<Salt>$<Verifier(64 bytes)>
+ * @param {string} password - Contraseña en texto plano.
+ * @param {string} storedScramString - Cadena SCRAM Legacy.
  * @returns {Promise<boolean>} True si la contraseña es válida.
  */
-async function verifyScram(password, storedScramString) {
+async function verifyScramLegacy(password, storedScramString) {
     if (!storedScramString.startsWith('SCRAM-SHA-256$')) {
         // No es formato SCRAM. Debe ser MD5 u otro algoritmo.
         return false;
@@ -166,7 +220,8 @@ async function verifyScram(password, storedScramString) {
     const generatedVerifierBuffer = await deriveKey(
         password, 
         storedSalt, 
-        iterations
+        iterations,
+        LEGACY_KEY_LENGTH
     );
     const generatedVerifier = bufferToBase64(generatedVerifierBuffer);
 
@@ -1119,6 +1174,34 @@ AppBackend.prototype.start = function start(opts){
                     mainApp.loginPlusManager.closeManager();
                 }
             });
+            const updatePassword = async ({client, username, password, setUpdateDate, errorIfNoResult}) => {
+                const {table, passFieldName, userFieldName, passUpdatedAtFieldName, passAlgorithmFieldName} = be.config.login;
+                const { schema } = be.config.db;
+                
+                const hashPass = await generateScramVerifier(password);
+                let params = [username, hashPass];
+                let setters = [`${be.db.quoteIdent(passFieldName)} = $2`];
+                if(passAlgorithmFieldName){
+                    setters.push(`${be.db.quoteIdent(passAlgorithmFieldName)} = $3`);
+                    params.push('PG-SHA256')
+                }
+                if(setUpdateDate && passUpdatedAtFieldName){
+                    setters.push(`${be.db.quoteIdent(passUpdatedAtFieldName)} = current_timestamp`)
+                }
+                        
+                const result = await client.query(`
+                    UPDATE ${(schema ? be.db.quoteIdent(schema) + '.' : '') + be.db.quoteIdent(table)} 
+                        SET ${setters.join(', ')}
+                        WHERE ${be.db.quoteIdent(userFieldName)} = $1
+                        returning 1 as ok
+                    `, params
+                ).fetchOneRowIfExists();
+
+                if(result.rowCount === 0 && errorIfNoResult){
+                    throw Error ('no se encontró el usuario')
+                };
+                return result
+            }
             mainApp.loginPlusManager.setValidatorStrategy(
                 async function(req, username, password, done) {
                     try{
@@ -1152,36 +1235,42 @@ AppBackend.prototype.start = function start(opts){
                             done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
                             return
                         }else{
-                            const user  = data.row;
+                            let needsMigration = false;
+                            const user = data.row;
+                            if(!user[passFieldName]){
+                                done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
+                                return
+                            }
                             const usaScramSha256 = user[passFieldName].startsWith('SCRAM-SHA-256$')
                             if (usaScramSha256){
-                                const isScramValid = await verifyScram(
-                                    password, 
-                                    user[passFieldName],
-                                )
+                                let isScramValid = false;
+                                // 1. Intento con formato PG-Compatible (Nuevo)
+                                if(await verifyScramPG(password, user[passFieldName])){
+                                    isScramValid = true;
+                                }
+                                
+                                // 2. Intento con formato Legacy (64 bytes)
+                                else if(await verifyScramLegacy(password, user[passFieldName])){
+                                    isScramValid = true;
+                                    needsMigration = true;
+                                }
                                 if(!isScramValid){
                                     done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
                                     return
                                 }
                             }else{                         
-                                if (md5(password+username.toLowerCase()) === user[passFieldName]) {
-                                    console.log('Autenticación MD5 OK. Ejecutando migración a SCRAM...');
-                                    // Generar nuevos valores SCRAM
-                                    const hashPass = await generateScramVerifier(password);
-                                    //sobrescribo el hash MD5 antiguo
-                                    await client.query(`
-                                        UPDATE usuarios 
-                                            SET ${be.db.quoteIdent(passFieldName)} = $1
-                                            WHERE usuario = $2
-                                            returning *`, 
-                                        [hashPass, username]
-                                    ).fetchUniqueRow();
-                                    console.log('Migración completada.');
+                                if (md5(password+username.toLowerCase()) === user[passFieldName]){
+                                    needsMigration = true;
                                 }else{
                                     done(null,false,{message:be.messages.unlogged.login.userOrPassFail});
                                     return
                                 }
                             }
+                            if(needsMigration){
+                                console.log('Ejecutando migración a SCRAM...');
+                                await updatePassword({client, username, password, setUpdateDate:false, errorIfNoResult:true});
+                                console.log('Migración completada.');
+                            }
                         }
                         //continua validando                    
                         if(data.rowCount==1){
@@ -1251,7 +1340,10 @@ AppBackend.prototype.start = function start(opts){
                 const storedHash = user[passFieldName];
                 if (oldPassword !== false) {
                     if (storedHash.startsWith('SCRAM-SHA-256$')) {//Intento SCRAM-SHA-256
-                        ok = await verifyScram(oldPassword, storedHash);
+                        ok = await verifyScramPG(oldPassword, storedHash);
+                        if (!ok) {
+                            ok = await verifyScramLegacy(oldPassword, storedHash);
+                        }
                     } else { //Intento MD5
                         const md5Hash = md5(oldPassword + username.toLowerCase()); 
                         ok = (md5Hash === storedHash);
@@ -1266,17 +1358,7 @@ AppBackend.prototype.start = function start(opts){
                 }
                 // Si la verificación fue exitosa o se omitió (ok == true), generamos el nuevo hash SCRAM
                 if (ok) {
-                    // hash en ormato completo de PostgreSQL: SCRAM-SHA-256$i:salt$verifier
-                    const newScramVerifier = await generateScramVerifier(newPassword);
-                    const updateSql = 
-                        "UPDATE " + (schema ? be.db.quoteIdent(schema) + '.' : '') +
-                        be.db.quoteIdent(table) +
-                        "\n  SET " + be.db.quoteIdent(passFieldName) + " = $2 " +
-                        "\n  WHERE " + be.db.quoteIdent(userFieldName) + " = $1 " +
-                        "\n  RETURNING 1 as ok";
-
-                    const updateParams = [username, newScramVerifier];
-                    const updateResult = await client.query(updateSql, updateParams).fetchOneRowIfExists();
+                    const updateResult = await updatePassword({client, username, password:newPassword, setUpdateDate:true, errorIfNoResult:false});
                     ok = updateResult.rowCount === 1;
                     if (ok && be.config.login['double-dragon']) {
                         const doubleDragonSql = "ALTER USER " + be.db.quoteIdent(username) + " WITH PASSWORD " + be.db.quoteLiteral(newPassword);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "backend-plus",
   "description": "Backend for the anti Pareto rule",
-  "version": "2.5.2-betha.27",
+  "version": "2.5.2-betha.28",
   "author": "Codenautas <codenautas@googlegroups.com>",
   "license": "MIT",
   "repository": "codenautas/backend-plus",