Parola doğrulama için Regexp Java

Bir Java uygulamasında bir yapılandırma parametresi olarak kullanılacak parola doğrulaması için bir normal ifade oluşturuyorum.

Normal ifade:

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

Parola politikası:

• En az 8 karakter

• En az bir rakam içerir

• En az bir alt alfa karakteri ve bir üst alfa karakteri içerir

• Bir dizi özel karakter ( @#%$^vb.) İçinde en az bir karakter içerir.

• Boşluk, sekme vb. İçermez.

Sadece 5. noktayı kaçırıyorum. Boşluk, sekme, satır başı vb. İçin regexp kontrolüne sahip olamıyorum.

Biri bana yardım edebilir mi?

Bunu dene:

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

Açıklama:

^                 # 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

Her kural bağımsız bir "modül" olduğundan, ayrı kuralları eklemek, değiştirmek veya kaldırmak kolaydır.

(?=.*[xyz])Yapı dizenin tamamıyla (yiyor .*ilk geçtiği için) ve geri adım attığı [xyz]eşleşebilir. Bulunursa başarılı olur [xyz], aksi takdirde başarısız olur.

Alternatif gönülsüz tanımlamasını kullanarak olacaktır: (?=.*?[xyz]). Bir parola kontrolü için, bu pek fark yaratmaz, çok daha uzun dizeler için daha verimli bir varyant olabilir.

En verimli varyant (ancak okunması ve bakımı en zor olan, bu nedenle en fazla hataya açık olan) (?=[^xyz]*[xyz])elbette olacaktır. Bu uzunlukta bir normal ifade için ve bu amaçla, gerçek bir faydası olmadığı için bunu bu şekilde yapmanızı tavsiye etmiyorum.

normal ifade kullanarak basit örnek

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));
   }
}

açıklamalar:

• (?=.*[0-9]) bir rakam en az bir kez geçmelidir
• (?=.*[a-z]) en az bir kez küçük harf bulunmalıdır
• (?=.*[A-Z]) en az bir kez büyük harf bulunmalıdır
• (?=.*[@#$%^&+=]) en az bir kez özel bir karakter oluşmalıdır
• (?=\\S+$) dizenin tamamında boşluğa izin verilmez
• .{8,} en az 8 karakter

Daha önce verilen yanıtların tümü, her gereksinim için ayrı bir ilerleme kullanmak üzere aynı (doğru) tekniği kullanır. Ancak, parolayı gerçekten kullanacak arka uca bağlı olarak, birkaç verimsizlik ve potansiyel olarak büyük bir hata içerirler.

Kabul edilen yanıttan normal ifadeyle başlayacağım:

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

Öncelikle, Java desteklediğinden \Ave \zben bunları tüm dizenin doğrulandığından emin olmak için kullanmayı tercih ediyorum Pattern.MULTILINE. Bu, performansı etkilemez, ancak normal ifadeler geri dönüştürüldüğünde hataları önler.

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

Parolanın boşluk içermediğinin kontrol edilmesi ve minimum uzunluğunun kontrol edilmesi , izin verilen karakterleri sınırlayan {8,}stenoya değişken nicelik belirteci koyarak tek seferde tümü kullanılarak yapılabilir \S:

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

Sağlanan parola bir boşluk içeriyorsa, tüm kontroller, yalnızca alanda son kontrolün başarısız olması için yapılacaktır. Bu, tüm noktaları aşağıdakilerle değiştirerek önlenebilir \S:

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

Nokta yalnızca herhangi bir karaktere gerçekten izin vermek istiyorsanız kullanılmalıdır. Aksi takdirde, normal ifadenizi yalnızca gerçekten izin verilen karakterlerle sınırlamak için (olumsuzlanmış) bir karakter sınıfı kullanın. Bu durumda çok az fark yaratsa da, başka bir şey daha uygun olduğunda noktayı kullanmamak çok iyi bir alışkanlıktır. Geliştirici noktadan daha uygun bir şey kullanamayacak kadar tembel olduğu için çok fazla geri dönüş vakası görüyorum .

İlk testlerin parolanın ilk yarısında uygun bir karakter bulma ihtimali yüksek olduğundan, tembel bir nicelik belirteci daha verimli olabilir:

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

Ama şimdi gerçekten önemli konuya gelelim: cevapların hiçbiri, orijinal sorunun ASCII'de düşünen biri tarafından yazılmış gibi göründüğünden bahsetmiyor. Ancak Java'da dizeler Unicode'dur. Şifrelerde ASCII olmayan karakterlere izin verilir mi? Eğer öyleyse, yalnızca ASCII boşluklarına izin verilmiyordur veya tüm Unicode boşlukları hariç tutulmalıdır.

Varsayılan olarak \syalnızca ASCII beyaz boşlukla eşleşir, bu nedenle tersi \Stüm Unicode karakterleriyle (beyaz boşluk veya değil) ve tüm boşluk olmayan ASCII karakterlerle eşleşir. Unicode karakterlere izin veriliyorsa ancak Unicode boşlukları yoksa, Unicode boşluklarını dışlamak için UNICODE_CHARACTER_CLASSbayrak belirtilebilir \S. Unicode karakterlere izin verilmiyorsa, boşluk veya kontrol karakteri olmayan tüm ASCII karakterlerini eşleştirmek [\x21-\x7E]yerine kullanılabilir \S.

Bu da bizi bir sonraki potansiyel soruna getiriyor: kontrol karakterlerine izin vermek istiyor muyuz? Düzgün bir normal ifade yazmanın ilk adımı, neyi eşleştirmek istediğinizi ve neyi eşleşmediğinizi tam olarak belirlemektir. Teknik olarak% 100 doğru tek cevap, sorudaki parola spesifikasyonunun belirsiz olmasıdır, çünkü kontrol karakterleri veya ASCII olmayan karakterler gibi belirli karakter aralıklarına izin verilip verilmediğini belirtmez.

Aşırı karmaşık Normal İfadeler (bunlardan kaçınabiliyorsanız) kullanmamalısınız çünkü bunlar

• okuması zor (en azından kendiniz hariç herkes için)
• uzatması zor
• hata ayıklaması zor

Birçok küçük normal ifadeyi kullanırken küçük bir performans yükü olsa da, yukarıdaki noktalar onu kolayca aşar.

Ben şu şekilde uygularım:

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;
}

Şifre Gereksinimi:

• Parola, sistemin destekleyebileceği yerde en az sekiz (8) karakter uzunluğunda olmalıdır.

• Parolalar şu gruplamalardan en az ikisinden (2) karakter içermelidir: alfa, sayısal ve özel karakterler.

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

Test ettim ve işe yarıyor

Her karakter türü için minimum gereksinimlerle ilgilenen herkes için, Tomalak'ın kabul ettiği yanıtın üzerine aşağıdaki uzantıyı eklemenizi öneririm:

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

Bunun bir biçimlendirme dizesi olduğuna ve son düzenli ifade kalıbı olmadığına dikkat edin. Sadece% d yerine en az gerekli tekrarları yazın: rakamlar, küçük harf, büyük harf, rakam olmayan / karakter ve tam şifre (sırasıyla). Maksimum tekrarlanma olasılığı düşüktür (maksimum 0 olmasını istemediğiniz sürece, bu tür karakterleri etkili bir şekilde reddederseniz), ancak bunlar da kolayca eklenebilir. Min / maks sınırlamalarının ardışık olmayan eşleşmelere izin vermesi için her türün etrafındaki ekstra gruplamaya dikkat edin. Bu, her bir karakter türünden kaç tane istediğimizi merkezi olarak yapılandırabildiğimiz ve ardından yukarıdaki biçimlendirme dizesini temel alan normal ifade kalıbını oluşturmak için iki farklı mobil platformun bu bilgileri almasını sağlayan bir sistem için harikalar yarattı.

Bu, her özel karakteri kontrol eder:

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

Java Metodu sizin için hazır, parametrelerle

Sadece kopyalayıp yapıştırın ve istediğiniz parametreleri ayarlayın.

Bir modül istemiyorsanız, onu yorumlayın veya özel karakter için yaptığım gibi bir "eğer" ekleyin

//______________________________________________________________________________
/**
 * 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;
}        

Güçlü api olan Passay kitaplığını kullanın .

Bunun da yapabileceğini düşünüyorum (daha basit bir mod olarak):

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

[Regex Demo]

kolay bir tanesi

("^ (? =. * [0-9]) (? =. * [Az]) (? =. * [AZ]) (? =. * [\\ W _]) [\\ S] {8 10} $ ")

1. (? = herhangi bir şey) -> tüm girdi dizelerinde pozitif ileriye bakma anlamına gelir ve bu koşul için yazıldığından emin olun. örnek (? =. * [0-9]) -> tüm dizede bir basamaklı sayının yazıldığından emin olmak anlamına gelir. yazılı değilse yanlış dönüş .

2. (?! Şey) -> (tam tersi) koşul olduğunu ileri eğer negatif görünüyor demektir yazılı dönüş false .

   yakın anlamı ^ (koşul) (koşul) (koşul) (koşul) [\ S] {8,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>");
}

Açıklama:

1. Önce şifreyi bir dizge olarak ayarlayın ve tamsayı kümesi o oluşturun.
2. Ardından döngü için her bir karakteri kontrol edin.
3. Dizede sayı bulursa n, 5 ekler. Sonra sonraki for döngüsüne atlayın. Character.isDigit (s.charAt (I))
4. Bu döngü, dizeye yerleştirilen tüm alfabeleri kontrol eder. Eğer bulursa, n'ye bir tane daha 5 ekleyin. Character.isLetter (s.charAt (I))
5. Şimdi, if koşulu yoluyla n tamsayısını kontrol edin. Eğer n = 10 doğruysa, verilen dizge alfasayısaldır, aksi takdirde değildir.

Ayrıca Bunu Beğenebilirsiniz.

 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;
}

Güçlü parola için örnek kod bloğu:

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

1. en az 6 hane
2. 18 haneye kadar
3. bir numara
4. bir küçük harf
5. bir büyük harf
6. tüm özel karakterleri içerebilir

Normal İfade -

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

1. en az 8 hane {8,}
2. en az bir sayı (? =. * \ d)
3. en az bir küçük harf (? =. * [az])
4. en az bir büyük harf (? =. * [AZ])
5. en az bir özel karakter (? =. * [@ # $% ^ & + =])
6. Boşluk [^ \ s]