Notwendigkeit, Logik des Passwortsystems zu verbessern

Question

So habe ich dieses grundlegende Passwortsystem gehen, und bis jetzt, habe ich meine Länge Checker Code aussortiert (in meinem System kann Passwort nur zwischen 6 und 12 Zeichen lang sein.)

Allerdings ist der Stärkeüberprüfer komplizierter, weil ich Kennwörter in drei Kategorien, SCHWACH, STARK und MITTEL, sortieren möchte. Die Kategorien werden durch die Arten von Zeichen im Passwort bestimmt, also wäre "Alpha" SCHWACH, "Alpha" wäre MEDIUM und "Alpha1234" wäre STRONG.

Wenn die Passwortstärke schwach ist, möchte ich, dass das Programm den Benutzer auffordert, zurückzugehen und ein anderes Passwort einzugeben. Wenn die Stärke MEDIUM ist, gebe ich dem Benutzer die Option, entweder ein anderes Passwort einzugeben oder das Passwort zu behalten eingegeben, und wenn die Stärke stark ist, wird das das Passwort automatisch

Bisher habe ich geschrieben drei Arrays, die die Zeichensätze definieren gehalten:

public static String[] uppercase = {"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"}; 

public static String[] lowercase = {"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"}; 

public static int[] numbers; { 
    numbers = new int[10]; 
    numbers[0] = 0; 
    numbers[1] = 1; 
    numbers[2] = 2; 
    numbers[3] = 3; 
    numbers[4] = 4; 
    numbers[5] = 5; 
    numbers[6] = 6; 
    numbers[7] = 7; 
    numbers[8] = 8; 
    numbers[9] = 9; 
} 

Hier sind die Zeichen checker Methoden:

public static boolean containsUppercase(String p) { 
    for (int i=0; i < p.length(); i++) { 
     for (int j = 0; j < uppercase.length; j++) { 
      if (Character.toString(p.charAt(i)).equals(uppercase[j])) { 
       return true; 
      } 
     } 
    } 
return false; 
} 
public static boolean containsLowercase(String p) { 
    for (int i=0; i < p.length(); i++) { 
     for (int j = 0; j < lowercase.length; j++) { 
      if (Character.toString(p.charAt(i)).equals(lowercase[j])) { 
       return true; 
      } 
     } 
    } 
return false; 
} 
public static boolean containsNumbers(String p) { 
    for (int i=0; i < p.length(); i++) { 
     for (int j = 0; j < numbers.length; j++) { 
      if (Character.toString(p.charAt(i)).equals(numbers[j])) { 
       return true; 
      } 
     } 
    } 
return false; 
} 

Und hier sind die Passwortstärke Kontrolleure:

if ((containsUppercase(password)) || (containsLowercase(password)) || (containsNumbers(password))) { 
      JOptionPane.showMessageDialog(null, "Your password strength is WEAK. You must enter another password"); 
      passwordreenter = 0; 
     } 
     if ((containsUppercase(password) && (containsLowercase(password)) || (containsUppercase(password)) && (containsNumbers(password)) || (containsLowercase(password)) && (containsNumbers(password)))) { 
      passwordreenter = JOptionPane.showConfirmDialog(null, "Your password strength is MEDIUM. Would you like to enter another password anyway?"); 
      System.out.println(passwordreenter); 
     } 
     if ((containsUppercase(password)) && (containsLowercase(password) && (containsNumbers(password)))) { 
      JOptionPane.showMessageDialog(null, "Your password strength is STRONG. The program will now close"); 
      System.exit(0); 
     } 

Wenn ich das Programm laufen, wie ich es gleich auf die richtige Passwort Stärke zu gehen, da jetzt es durch jedes einzelne geht if-Anweisung, wenn ich Geben Sie ein STRONG-Passwort ein

Answer 1

Wenn Ihr Passwort "stark" ist, dann wird jeder Check wahr, also wird natürlich jede if Anweisung übergeben. Sie möchten ein Kennwort als "schwach" klassifizieren, wenn es nur einen der Überprüfungen durchlässt, "mittel", wenn es zwei Überprüfungen besteht, und "stark", wenn es alle drei Überprüfungen besteht. Eine Möglichkeit, dies zu tun, besteht darin, mit int auf 0 zu setzen und für jede Prüfung, die übergeben wird, die Zahl zu erhöhen. Verwenden Sie dann diese endgültige Nummer in Ihrer if s.

int level = 0; 
if (containsUppercase(password)) { 
    level++; 
} 
if (containsLowercase(password)) { 
    level++; 
} 
if (containsNumbers(password)) { 
    level++; 
} 

if (level <= 1) { 
    JOptionPane.showMessageDialog(null, "Your password strength is WEAK. You must enter another password"); 
    passwordreenter = 0; 
} else if (level == 2) { 
    passwordreenter = JOptionPane.showConfirmDialog(null, "Your password strength is MEDIUM. Would you like to enter another password anyway?"); 
    System.out.println(passwordreenter); 
} else if (level == 3) { 
    JOptionPane.showMessageDialog(null, "Your password strength is STRONG. The program will now close"); 
    System.exit(0); 
} 

Answer 2

Ersetzen Sie einfach die letzten 2 if-Anweisungen durch else. Ordnen Sie auch Ihre Anweisungen neu, so dass das starke Passwort zuerst verarbeitet wird.

Answer 3

Ihre Stärkeüberprüfungslogik ist falsch. Wenn das angegebene Kennwort Großbuchstaben, Kleinbuchstaben und Zahlen enthält, sind alle 3 if Aussagen wahr. Sie verwenden keine if-else Anweisungen, so dass sie alle ausgeführt werden.

Ich würde auch empfehlen, https://codereview.stackexchange.com/; Sie können helfen, Ihren Code aufzuräumen.

Answer 4

public static void main(String[] args) { 
    String password = "A"; 
    String passwordStrength = ""; 
    if(password.length() >= 6 && password.length() <= 12) 
     passwordStrength= passStrength(password); 

} 

public static String passStrength(String password) { 
    String[] desc = new String[3]; 
    desc[0] = "Weak"; 
    desc[1] = "Medium"; 
    desc[2] = "Strong"; 



    int score = -1; 


      String pattern = "(.*)(\\d+)(.*)"; 
      Pattern r = Pattern.compile(pattern); 
      Matcher m = r.matcher(password); 
      if(m.find()) score++; 

      pattern = "(.*)([a-z]+)(.*)"; 
      r = Pattern.compile(pattern); 
      m = r.matcher(password); 
      if(m.find()) score++; 

      pattern = "(.*)([A-Z]+)(.*)"; 
      r = Pattern.compile(pattern); 
      m = r.matcher(password); 
      if(m.find()) score++; 

      return desc[score]; 

}