web-dev-qa-db-fra.com

Java générateur de mot de passe

J'essaie de créer un programme Java qui crée un mot de passe, soit en minuscules, en minuscules et en majuscules, en minuscules et en majuscules et en nombres, en minuscules et en majuscules et en chiffres et en ponctuation et le programme doit également créer l'un de ces mots de passe que l'utilisateur choisit et doit générer une longueur de mot de passe en fonction de ce qu'il choisit. J'ai déjà généré les options de mot de passe pour l'utilisateur et je l'ai invité à en choisir un. Je suis maintenant bloqué sur la façon dont pour créer les types de mot de passe mentionnés ci-dessus. Une personne m'a suggéré d'utiliser les valeurs ASCII puis de les convertir en texte. Je sais comment les convertir en texte, mais cela affichera des chiffres, des lettres et les signes de ponctuation. Existe-t-il un moyen de générer des valeurs ASCII uniquement pour les lettres minuscules? Comment puis-je générer un mot de passe en fonction de la longueur de l'utilisateur qu'il donne?

javapasswordsgenerator
15
word word

J'utilise cette classe immuable.
Il utilise le modèle de générateur.
Il ne prend pas en charge l'extension .

public final class PasswordGenerator {

    private static final String LOWER = "abcdefghijklmnopqrstuvwxyz";
    private static final String UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String DIGITS = "0123456789";
    private static final String PUNCTUATION = "!@#$%&*()_+-=[]|,./?><";
    private boolean useLower;
    private boolean useUpper;
    private boolean useDigits;
    private boolean usePunctuation;

    private PasswordGenerator() {
        throw new UnsupportedOperationException("Empty constructor is not supported.");
    }

    private PasswordGenerator(PasswordGeneratorBuilder builder) {
        this.useLower = builder.useLower;
        this.useUpper = builder.useUpper;
        this.useDigits = builder.useDigits;
        this.usePunctuation = builder.usePunctuation;
    }

    public static class PasswordGeneratorBuilder {

        private boolean useLower;
        private boolean useUpper;
        private boolean useDigits;
        private boolean usePunctuation;

        public PasswordGeneratorBuilder() {
            this.useLower = false;
            this.useUpper = false;
            this.useDigits = false;
            this.usePunctuation = false;
        }

        /**
         * Set true in case you would like to include lower characters
         * (abc...xyz). Default false.
         *
         * @param useLower true in case you would like to include lower
         * characters (abc...xyz). Default false.
         * @return the builder for chaining.
         */
        public PasswordGeneratorBuilder useLower(boolean useLower) {
            this.useLower = useLower;
            return this;
        }

        /**
         * Set true in case you would like to include upper characters
         * (ABC...XYZ). Default false.
         *
         * @param useUpper true in case you would like to include upper
         * characters (ABC...XYZ). Default false.
         * @return the builder for chaining.
         */
        public PasswordGeneratorBuilder useUpper(boolean useUpper) {
            this.useUpper = useUpper;
            return this;
        }

        /**
         * Set true in case you would like to include digit characters (123..).
         * Default false.
         *
         * @param useDigits true in case you would like to include digit
         * characters (123..). Default false.
         * @return the builder for chaining.
         */
        public PasswordGeneratorBuilder useDigits(boolean useDigits) {
            this.useDigits = useDigits;
            return this;
        }

        /**
         * Set true in case you would like to include punctuation characters
         * (!@#..). Default false.
         *
         * @param usePunctuation true in case you would like to include
         * punctuation characters (!@#..). Default false.
         * @return the builder for chaining.
         */
        public PasswordGeneratorBuilder usePunctuation(boolean usePunctuation) {
            this.usePunctuation = usePunctuation;
            return this;
        }

        /**
         * Get an object to use.
         *
         * @return the {@link gr.idrymavmela.business.lib.PasswordGenerator}
         * object.
         */
        public PasswordGenerator build() {
            return new PasswordGenerator(this);
        }
    }

    /**
     * This method will generate a password depending the use* properties you
     * define. It will use the categories with a probability. It is not sure
     * that all of the defined categories will be used.
     *
     * @param length the length of the password you would like to generate.
     * @return a password that uses the categories you define when constructing
     * the object with a probability.
     */
    public String generate(int length) {
        // Argument Validation.
        if (length <= 0) {
            return "";
        }

        // Variables.
        StringBuilder password = new StringBuilder(length);
        Random random = new Random(System.nanoTime());

        // Collect the categories to use.
        List<String> charCategories = new ArrayList<>(4);
        if (useLower) {
            charCategories.add(LOWER);
        }
        if (useUpper) {
            charCategories.add(UPPER);
        }
        if (useDigits) {
            charCategories.add(DIGITS);
        }
        if (usePunctuation) {
            charCategories.add(PUNCTUATION);
        }

        // Build the password.
        for (int i = 0; i < length; i++) {
            String charCategory = charCategories.get(random.nextInt(charCategories.size()));
            int position = random.nextInt(charCategory.length());
            password.append(charCategory.charAt(position));
        }
        return new String(password);
    }
}

Ceci est un exemple d'utilisation,

PasswordGenerator passwordGenerator = new PasswordGenerator.PasswordGeneratorBuilder()
        .useDigits(true)
        .useLower(true)
        .useUpper(true)
        .build();
String password = passwordGenerator.generate(8); // output ex.: lrU12fmM 75iwI90o
39
George Siggouroglou

Vous pouvez utiliser org.Apache.commons.lang.RandomStringUtils pour générer du texte/des mots de passe aléatoires. Veuillez vous référer au lien this par exemple.

17
Dark Knight

Au cas où cela serait utile pour quelqu'un. Le générateur de mot de passe aléatoire d'une ligne par standard Java 8 classes basées sur la plage ASCII:

String password = new Random().ints(10, 33, 122).collect(StringBuilder::new,
        StringBuilder::appendCodePoint, StringBuilder::append)
        .toString();

ou

String password = new Random().ints(10, 33, 122).mapToObj(i -> String.valueOf((char)i)).collect(Collectors.joining());

Ici, la longueur du mot de passe est de 10. Bien sûr, vous pouvez également le définir de manière aléatoire dans une certaine plage. Et les caractères sont de la plage ASCII 33-122 qui sont tous des symboles spéciaux, des chiffres en majuscules et en minuscules.

Si vous avez seulement besoin de lettres minuscules, vous pouvez simplement définir la plage: 97-122

5
engilyin

Vous pouvez le faire de cette façon:

String lower = "abc...xyz";
String digits = "0123456789";
String punct = "!#$&...";
String  ...                      // further characer classes

(Noter la ... pièces que vous devez remplir vous-même.)

À partir des options choisies par l'utilisateur, vous créez une chaîne de caractères parmi laquelle choisir en concaténant les classes de caractères correspondantes.

Enfin, vous exécutez une boucle n fois, où n est le nombre de caractères souhaité. À chaque tour, vous choisissez un caractère aléatoire dans la chaîne que vous avez créée et l'ajoutez au résultat:

StringBuilder sb = new StringBuilder();
int n = ....; // how many characters in password
String set = ....; // characters to choose from

for (i= 0; i < n; i++) {
    int k = ....;   // random number between 0 and set.length()-1 inklusive
    sb.append(set.charAt(k));
}
String result = sb.toString();
3
Ingo

Le texte Apache commons a une assez bonne alternative pour la génération de chaînes aléatoires. Builder est utilisé pour construire un générateur, après que ce générateur soit facile à utiliser pour la génération des mots de passe nécessaires.

 // Generates a 20 code point string, using only the letters a-z
 RandomStringGenerator generator = new RandomStringGenerator.Builder()
     .withinRange('a', 'z').build();
 String randomLetters = generator.generate(20);

S'il te plait regarde

https://commons.Apache.org/proper/commons-text/javadocs/api-release/org/Apache/commons/text/RandomStringGenerator.html

2
Jukka Nikki

Vous pouvez choisir au hasard des chiffres, des lettres et des signes de ponctuation, ayant une dimension. Les nombres Ansi sont de 30 à 39, les lettres minuscules de 61-7A, etc. Utilisez tableaux ascii

1
Andrew Evt
import Java.security.SecureRandom;
import Java.util.Random;

public class PasswordHelper {        

    public static String generatePassword (int length) {

    //minimum length of 6
    if (length < 4) {
        length = 6;
    }

    final char[] lowercase = "abcdefghijklmnopqrstuvwxyz".toCharArray();
    final char[] uppercase = "ABCDEFGJKLMNPRSTUVWXYZ".toCharArray();
    final char[] numbers = "0123456789".toCharArray();
    final char[] symbols = "^$?!@#%&".toCharArray();
    final char[] allAllowed = "abcdefghijklmnopqrstuvwxyzABCDEFGJKLMNPRSTUVWXYZ0123456789^$?!@#%&".toCharArray();

    //Use cryptographically secure random number generator
    Random random = new SecureRandom();

    StringBuilder password = new StringBuilder(); 

    for (int i = 0; i < length-4; i++) {
        password.append(allAllowed[random.nextInt(allAllowed.length)]);
    }

    //Ensure password policy is met by inserting required random chars in random positions
    password.insert(random.nextInt(password.length()), lowercase[random.nextInt(lowercase.length)]);
    password.insert(random.nextInt(password.length()), uppercase[random.nextInt(uppercase.length)]);
    password.insert(random.nextInt(password.length()), numbers[random.nextInt(numbers.length)]);
    password.insert(random.nextInt(password.length()), symbols[random.nextInt(symbols.length)]);
    }

    return password.toString();

    }

}
1
F_SO_K

Vous pouvez essayer Java implémentation d'un "pwgen" Unix. https://github.com/antiso/pwgen-gae Il contient le lien vers l'implémentation de la bibliothèque jpwgen avec CLI chez Bitbucket et le lien vers l'exemple déployé GAE.

0
Vladimir Sosnin

Si c'était moi, je créerais des tableaux de caractères (char[] ...) qui représentent les différents jeux de caractères que vous autorisez, puis dans votre méthode de générateur, vous choisissez le tableau de caractères approprié et générez le mot de passe à partir de cela. La partie compliquée devient alors la création des tableaux de personnages ...

public String generate(char[] validchars, int len) {
    char[] password = new char[len];
    Random Rand = new Random(System.nanoTime());
    for (int i = 0; i < len; i++) {
        password[i] = validchars[Rand.nextInt(validchars.length)];
    }
    return new String(password);
}

Ensuite, votre problème devient simplement la génération de tableaux char [] qui représentent les différentes règles que vous avez, et comment transmettre cet ensemble à la méthode generate.

une façon de le faire est de mettre en place une liste de règles d'expression régulière qui correspondent aux règles que vous autorisez, puis d'envoyer chaque caractère à travers les règles .... et si elles correspondent aux règles, alors ajoutez-les .....

Considérons une fonction qui ressemble à:

public static final char[] getValid(final String regex, final int lastchar) {
    char[] potential = new char[lastchar]; // 32768 is not huge....
    int size = 0;
    final Pattern pattern = Pattern.compile(regex);
    for (int c = 0; c <= lastchar; c++) {
        if (pattern.matcher(String.valueOf((char)c)).matches()) {
            potential[size++] = (char)c;
        }
    }
    return Arrays.copyOf(potential, size);
}

Ensuite, vous pouvez obtenir un tableau de caractères aphabétiques (en minuscules uniquement) avec:

getValid("[a-z]", Character.MAX_VALUE);

Ou, une liste de tous les caractères "Word" avec:

getValid("\\w", Character.MAX_VALUE);

Ensuite, il s'agit de choisir l'expression régulière correspondant à vos besoins et de "stocker" le tableau de caractères valides à réutiliser à chaque fois. (Ne générez pas les caractères à chaque fois que vous générez un mot de passe ....)

0
rolfl

J'ai créé un programme simple qui remplit un ArrayList avec des nombres ASCII, puis utilise un générateur de nombres SecureRandom pour les randomiser dans un for boucle, dans laquelle vous pouvez définir le nombre de caractères souhaité.

import Java.security.SecureRandom;
import Java.util.ArrayList;
import Java.util.List;

public class PassGen {

    private String str;
    private int randInt;
    private StringBuilder sb;
    private List<Integer> l;

    public PassGen() {
        this.l = new ArrayList<>();
        this.sb = new StringBuilder();

        buildPassword();
    }

    private void buildPassword() {

        //Add ASCII numbers of characters commonly acceptable in passwords
        for (int i = 33; i < 127; i++) {
            l.add(i);
        }

        //Remove characters /, \, and " as they're not commonly accepted
        l.remove(new Integer(34));
        l.remove(new Integer(47));
        l.remove(new Integer(92));

        /*Randomise over the ASCII numbers and append respective character
          values into a StringBuilder*/
        for (int i = 0; i < 10; i++) {
            randInt = l.get(new SecureRandom().nextInt(91));
            sb.append((char) randInt);
        }

        str = sb.toString();
    }

    public String generatePassword() {
        return str;
    }
}

J'espère que cela t'aides! :)

0
Pastasaurus Rex