Regexp Java для проверки пароля

Question

Я создаю регулярное выражение для проверки пароля, которое будет использоваться в приложении Java в качестве параметра конфигурации.

Регулярное выражение:

^.*(?=.{8,})(?=..*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=]).*$

Политика паролей:

• Не менее 8 символов

• Содержит хотя бы одну цифру

• Содержит как минимум один нижний альфа-символ и один верхний альфа-символ

• Содержит как минимум один символ в наборе специальных символов (@#%$^ и т. Д.)

• Не содержит пробела, табуляции и т. Д.

Мне не хватает только пункта 5. Я не могу выполнить проверку регулярного выражения для пробела, табуляции, возврата каретки и т. Д.

Может ли кто-нибудь мне помочь?

Answer 1

Попробуйте это:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Пояснение:

^                 # start-of-string
(?=.*[0-9])       # a digit must occur at least once
(?=.*[a-z])       # a lower case letter must occur at least once
(?=.*[A-Z])       # an upper case letter must occur at least once
(?=.*[@#$%^&+=])  # a special character must occur at least once
(?=\S+$)          # no whitespace allowed in the entire string
.{8,}             # anything, at least eight places though
$                 # end-of-string

Легко добавлять, изменять или удалять отдельные правила, поскольку каждое правило является независимым "модулем".

Конструкция (?=.*[xyz]) пожирает всю строку (.*) и возвращает обратно к первому вхождению, где [xyz] может соответствовать. Успешно, если найден [xyz], иначе нет.

Альтернативой может быть использование квалификатора с неохотой: (?=.*?[xyz]). Для проверки пароля это вряд ли будет иметь значение, для более длинных строк это может быть более эффективный вариант.

Самым эффективным вариантом (но самым трудным для чтения и обслуживания, поэтому наиболее подверженным ошибкам) ​​будет, конечно, (?=[^xyz]*[xyz]). Для регулярного выражения этой длины и для этой цели я бы не рекомендовал делать это таким образом, поскольку он не имеет реальных преимуществ.

Answer 2

простой пример с использованием регулярных выражений

public class passwordvalidation {
    public static void main(String[] args) {
      String passwd = "aaZZa44@"; 
      String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
      System.out.println(passwd.matches(pattern));
   }
}

Пояснения:

• (?=.*[0-9]) цифра должна встречаться как минимум один раз
• (?=.*[a-z]) строчная буквадолжно встречаться не менее одного раза
• (?=.*[A-Z]) заглавная буква должна встречаться не менее одного раза
• (?=.*[@#$%^&+=]) специальный символ должен встречаться не менее одного раза
• (?=\\S+$) нетПробел допускается во всей строке
• .{8,} не менее 8 символов

Answer 3

Все ранее предоставленные ответы используют одну и ту же (правильную) технику, чтобы использовать отдельное предпросмотр для каждого требования.Но они содержат несколько недостатков и потенциально серьезную ошибку, в зависимости от серверной части, которая будет фактически использовать пароль.

Я начну с регулярного выражения из принятого ответа:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Прежде всего, поскольку Java поддерживает \A и \z, я предпочитаю использовать их, чтобы убедиться, что вся строка проверена, независимо от Pattern.MULTILINE.Это не влияет на производительность, но позволяет избежать ошибок при повторном использовании регулярных выражений.

\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}\z

Проверка того, что пароль не содержит пробелов, и проверка его минимальной длины можно выполнить за один проход, используя все сразупоместив переменный квантификатор {8,} на сокращение \S, ограничивающее допустимые символы:

\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])\S{8,}\z

Если указанный пароль содержит пробел, все проверки будут выполнены только для окончательной проверкипровалиться на месте.Этого можно избежать, заменив все точки на \S:

\A(?=\S*[0-9])(?=\S*[a-z])(?=\S*[A-Z])(?=\S*[@#$%^&+=])\S{8,}\z

Точку следует использовать, только если вы действительно хотите разрешить какой-либо символ.В противном случае используйте (отрицательный) класс символов, чтобы ограничить свое регулярное выражение только теми символами, которые действительно разрешены.Хотя в этом случае это не имеет большого значения, не использовать точку, когда что-то более подходящее - очень хорошая привычка.Я вижу слишком много случаев катастрофического возврата назад , потому что разработчик был слишком ленив, чтобы использовать что-то более подходящее, чем точка.

Так как есть хорошие шансы, начальные тесты найдут подходящий символ впервая половина пароля, ленивый квантификатор может быть более эффективным:

\A(?=\S*?[0-9])(?=\S*?[a-z])(?=\S*?[A-Z])(?=\S*?[@#$%^&+=])\S{8,}\z

Но теперь для действительно важного вопроса: ни один из ответов не упоминает тот факт, что первоначальный вопрос, кажется, написан кем-то, ктодумает в ASCII.Но в Java строки являются Unicode.Разрешены ли символы не ASCII в паролях?Если они есть, запрещены только пробелы ASCII или должны быть исключены все пробелы Unicode.

По умолчанию \s соответствует только пробелам ASCII, поэтому его обратный \S соответствует всем символам Unicode (пробелам или нет) ивсе непробельные символы ASCII.Если символы Юникода разрешены, а пробелы Юникода - нет, можно указать флаг UNICODE_CHARACTER_CLASS, чтобы \S исключал пробелы Юникода.Если символы Unicode недопустимы, вместо \S можно использовать [\x21-\x7E], чтобы сопоставить все символы ASCII, которые не являются пробелами или управляющими символами.

Что приводит нас к следующей потенциальной проблеме: doмы хотим разрешить управляющие символы?Первый шаг в написании правильного регулярного выражения - точно указать, что вы хотите сопоставить, а что нет.Единственно на 100% технически правильный ответ заключается в том, что спецификация пароля в вопросе неоднозначна, поскольку в ней не указывается, разрешены ли определенные диапазоны символов, такие как управляющие символы или символы, не входящие в ASCII.

Answer 4

Вы не должны использовать слишком сложные регулярные выражения (если вы можете их избежать), потому что они

• трудны для чтения (по крайней мере, для всех, кроме вас)
• трудно расширять
• трудно отлаживать

Несмотря на то, что при использовании множества небольших регулярных выражений может быть небольшая нагрузка на производительность, приведенные выше баллы легко превышают ее.:

bool matchesPolicy(pwd) {
    if (pwd.length < 8) return false;
    if (not pwd =~ /[0-9]/) return false;
    if (not pwd =~ /[a-z]/) return false;
    if (not pwd =~ /[A-Z]/) return false;
    if (not pwd =~ /[%@$^]/) return false;
    if (pwd =~ /\s/) return false;
    return true;
}

Answer 5

Java-метод готов для вас, с параметрами

Просто скопируйте и вставьте и установите нужные параметры.

Если вам не нужен модуль, просто прокомментируйте его или добавьте «если»"как я сделал для специального символа

//______________________________________________________________________________
/**
 * Validation Password     */
//______________________________________________________________________________
private static boolean validation_Password(final String PASSWORD_Arg)    {
    boolean result = false;
    try {
        if (PASSWORD_Arg!=null) {
            //_________________________
            //Parameteres
            final String MIN_LENGHT="8";
            final String MAX_LENGHT="20";
            final boolean SPECIAL_CHAR_NEEDED=true;

            //_________________________
            //Modules
            final String ONE_DIGIT = "(?=.*[0-9])";  //(?=.*[0-9]) a digit must occur at least once
            final String LOWER_CASE = "(?=.*[a-z])";  //(?=.*[a-z]) a lower case letter must occur at least once
            final String UPPER_CASE = "(?=.*[A-Z])";  //(?=.*[A-Z]) an upper case letter must occur at least once
            final String NO_SPACE = "(?=\\S+$)";  //(?=\\S+$) no whitespace allowed in the entire string
            //final String MIN_CHAR = ".{" + MIN_LENGHT + ",}";  //.{8,} at least 8 characters
            final String MIN_MAX_CHAR = ".{" + MIN_LENGHT + "," + MAX_LENGHT + "}";  //.{5,10} represents minimum of 5 characters and maximum of 10 characters

            final String SPECIAL_CHAR;
            if (SPECIAL_CHAR_NEEDED==true) SPECIAL_CHAR= "(?=.*[@#$%^&+=])"; //(?=.*[@#$%^&+=]) a special character must occur at least once
            else SPECIAL_CHAR="";
            //_________________________
            //Pattern
            //String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
            final String PATTERN = ONE_DIGIT + LOWER_CASE + UPPER_CASE + SPECIAL_CHAR + NO_SPACE + MIN_MAX_CHAR;
            //_________________________
            result = PASSWORD_Arg.matches(PATTERN);
            //_________________________
        }    

    } catch (Exception ex) {
        result=false;
    }

    return result;
}        

Answer 6

Для тех, кто интересуется минимальными требованиями для каждого типа символов, я бы предложил сделать следующее расширение для принятого ответа Томалака:

^(?=(.*[0-9]){%d,})(?=(.*[a-z]){%d,})(?=(.*[A-Z]){%d,})(?=(.*[^0-9a-zA-Z]){%d,})(?=\S+$).{%d,}$

Обратите внимание, что это строка форматирования, а не окончательный шаблон регулярного выражения.Просто замените% d минимально необходимыми вхождениями для: цифр, строчных букв, прописных букв, не цифр / символов и всего пароля (соответственно).Максимальное количество вхождений маловероятно (если только вы не хотите максимум 0, фактически отклоняя любые такие символы), но их также можно легко добавить.Обратите внимание на дополнительную группировку вокруг каждого типа, чтобы ограничения min / max учитывали непоследовательные совпадения.Это чудесно для системы, где мы можем централизованно настраивать, сколько символов каждого типа нам требуется, а затем иметь веб-сайт, а также две разные мобильные платформы, которые получают эту информацию для построения шаблона регулярного выражения на основе приведенной выше строки форматирования.

Answer 7

Требование пароля:

• Пароль должен содержать не менее восьми (8) символов, если система может его поддерживать.

• Пароли должны содержать символы как минимум из двух (2) из ​​этих групп: буквенные, цифровые и специальные символы.

  ^.*(?=.{8,})(?=.*\d)(?=.*[a-zA-Z])|(?=.{8,})(?=.*\d)(?=.*[!@#$%^&])|(?=.{8,})(?=.*[a-zA-Z])(?=.*[!@#$%^&]).*$
  

Я проверил это, и оно работает

Answer 8

Также вы можете сделать это.

 public boolean isPasswordValid(String password) {


    String regExpn =
            "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}$";

    CharSequence inputStr = password;

    Pattern pattern = Pattern.compile(regExpn,Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);

    if(matcher.matches())
        return true;
    else
        return false;
}

Answer 9

Этот проверяет каждый специальный символ:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=\S+$).*[A-Za-z0-9].{8,}$

Answer 10

String s=pwd;
int n=0;
for(int i=0;i<s.length();i++)
{
    if((Character.isDigit(s.charAt(i))))
    {
        n=5;
        break;
    }
    else
    {

    }
}
for(int i=0;i<s.length();i++)
{
    if((Character.isLetter(s.charAt(i))))
    {
        n+=5;
        break;
    }
    else
    {

    }

}

if(n==10)
{
    out.print("Password format correct <b>Accepted</b><br>");

}
else
{
    out.print("Password must be alphanumeric <b>Declined</b><br>");
}

Объяснение:

1. Сначала установите пароль в виде строки и создайте набор целых чисел o.
2. Затем проверьте каждый символ с помощьюцикл for.
3. Если он находит число в строке, то n добавляет 5. Затем переходят к следующему циклу for. Character.isDigit (s.charAt (i))
4. Этот цикл проверяет любые алфавиты, помещенные в строку.Если его найти, то добавьте еще 5 в n. Character.isLetter (s.charAt (i))
5. Теперь проверьте целое число n с помощью условия if.Если n = 10 истинно, данная строка является буквенно-цифровой, иначе это не так.