Validació i Xifratge de Contrasenyes en Java

Aquest programa en Java implementa un sistema complet de verificació de regles per a contrasenyes, xifratge mitjançant l'algorisme Caesar (xifratge de Cèsar) i persistència de dades en un fitxer de text mitjançant FileWriter i PrintWriter.

Regles de Validació de la Contrasenya

• Longitud: La paraula ha de tenir una mida d'entre 3 i 20 caràcters.
• Regla 1 (Presència de vocals): Ha de contenir almenys una vocal (a, e, i, o, u).
• Regla 2 (Vocals o consonants consecutives): No pot contenir tres vocals consecutives ni tres consonants consecutives.
• Regla 3 (Lletres repetides consecutives): No pot contenir dues lletres idèntiques consecutives, amb l'excepció de ee i oo.

Codi Font Corregit de l'Aplicació

package contrasenya;

import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Classe principal per validar i xifrar contrasenyes.
 * @author Jesús
 */
public class Contrasenya {

    static char word[];
    static int len;

    static boolean esVocal(char ch) {
        return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
    }

    static boolean regla1() {
        for (int i = 0; i < len; i++) {
            if (esVocal(word[i])) {
                return true;
            }
        }
        return false;
    }

    static boolean regla2() {
        int v = 0, c = 0;
        for (int i = 0; i < len; i++) {
            if (esVocal(word[i])) {
                v++;
                c = 0;
            } else {
                c++;
                v = 0;
            }
            if (v == 3 || c == 3) {
                return false;
            }
        }
        return true;
    }

    static boolean regla3() {
        for (int i = 1; i < len; i++) {
            if (word[i] == word[i - 1] && word[i] != 'e' && word[i] != 'o') {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        String line;
        Scanner in = new Scanner(System.in);
        Caesar oculta = new Caesar(5); // S'instancia indicant el desplaçament
        Fitxer guarda = new Fitxer();

        while (true) {
            line = in.next();
            if (line.length() < 3 || line.length() > 20) {
                System.out.println("El llarg ha d'estar comprès entre 3 i 19, proveu-ho de nou.");
                continue;
            }
            if (line.equals("end")) {
                break;
            }

            word = line.toCharArray();
            len = line.length();

            if (regla1() && regla2() && regla3()) {
                System.out.println(line + ". is acceptable.");
                line = oculta.Encripta(line);
                System.out.println(line);
                guarda.Graba(line);
            } else {
                System.out.println("<" + line + "> is not acceptable.");
            }
        }
        in.close();
    }
}

Gestió de Fitxers: Classe Fitxer

La classe Fitxer s'encarrega d'escriure la clau generada en un fitxer de text al disc (C:\EJEMPLOCLAVE.txt).

class Fitxer {

    private FileWriter fw;
    private PrintWriter pw = null;

    public void Graba(String password) {
        try {
            fw = new FileWriter("C:\\EJEMPLOCLAVE.txt");
            pw = new PrintWriter(fw);

            // Recorrem la contrasenya i s'escriu lletra per lletra al fitxer
            for (int i = 0; i < password.length(); i++) {
                pw.print(password.subSequence(i, i + 1));
            }
            pw.close();
            fw.close();
        } catch (Exception e) {
            System.out.println("Error al gravar el fitxer: " + e.getMessage());
        }
    }
}

Algorisme de Xifratge: Classe Caesar

La classe Caesar implementa una variació del xifratge per substitució monoalfabètica considerant un alfabet de 38 caràcters (lletres, la 'ñ', el punt i números).

class Caesar {

    char[] palabra = {
        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
        'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
        'x', 'y', 'z', '.', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0'
    };
    int desplaza;

    // Constructor
    Caesar(int desplaza) {
        this.desplaza = desplaza;
    }

    String Encripta(String password) {
        char busca;
        String pssencr = "";

        // Recorrem la paraula lletra per lletra
        for (int i = 0; i < password.length(); i++) {
            busca = password.substring(i, i + 1).charAt(0);

            // Cerca a l'alfabet definit
            for (int j = 0; j < 38; j++) {
                if (busca == palabra[j]) {
                    if (j + desplaza > 37) {
                        pssencr = pssencr + palabra[j + desplaza - 38];
                    } else {
                        pssencr = pssencr + palabra[j + desplaza];
                    }
                }
            }
        }
        return pssencr;
    }
}

Notes de Depuració i Millores Realitzades

• S'han solucionat els errors de codificació UTF-8 (caràcters corromputs com contraseña).
• S'han restaurat les expressions dels bucles for afectades per etiquetes HTML mal tancades.
• S'han consolidat les declaracions duplicades de les classes auxiliars preservant la totalitat de la funcionalitat i mètodes.