पासवर्ड सत्यापन के लिए Regexp Java

Question

मैं एक जावा पैरामीटर में एक कॉन्फ़िगरेशन पैरामीटर के रूप में उपयोग किए जाने वाले पासवर्ड सत्यापन के लिए एक regexp बना रहा हूं।

Regexp है:

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

पासवर्ड नीति है:

• कम से कम 8 वर्ण

• कम से कम एक अंक होता है

• कम से कम एक कम अल्फा चार और एक ऊपरी अल्फा चार शामिल हैं

• विशेष आकर्षण ( @#%$^आदि) के एक सेट के भीतर कम से कम एक चार्ट शामिल है

• जिसमें स्पेस, टैब आदि नहीं है।

मुझे बस 5 अंक याद आ रहे हैं। मैं स्पेस, टैब, कैरिज रिटर्न इत्यादि के लिए regexp चेक करने में सक्षम नहीं हूं।

क्या कोई मेरी मदद कर सकता है?

Comments

पासवर्ड नियम खराब हैं। कृपया अधिक जानकारी के लिए संदर्भ - पासवर्ड सत्यापन देखें ।

— ctwheels

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])निर्माण पूरी स्ट्रिंग (खाती .*) और पहली घटना जहां को backtracks [xyz]मिलान कर सकते हैं। यह [xyz]पाया जाता है अगर यह सफल होता है, अन्यथा यह विफल रहता है।

वैकल्पिक एक अनिच्छुक क्वालिफायर का उपयोग होगा (?=.*?[xyz]):। पासवर्ड जांच के लिए, यह शायद ही कोई फर्क पड़ेगा, लंबे समय तक तार के लिए यह अधिक कुशल संस्करण हो सकता है।

सबसे कुशल संस्करण (लेकिन पढ़ने और बनाए रखने के लिए सबसे कठिन, इसलिए सबसे अधिक त्रुटि वाला) (?=[^xyz]*[xyz])निश्चित रूप से होगा। इस लंबाई के लिए और इस उद्देश्य के लिए, मैं इसे इस तरह से करने की सिफारिश करूंगा, क्योंकि इसका कोई वास्तविक लाभ नहीं है।

Comments

@ Kerby82: जावा स्ट्रिंग्स में, बैकस्लैश से बच जाना चाहिए। उपयोग करने का प्रयास करें \\s। यह एक जावा आवश्यकता है, रेगेक्स आवश्यकता नहीं।

— तोमलक

@ अलालो बस इसके बारे में इस तरह से सोचो: जो कुछ भी लागू नहीं किया गया है वह वैकल्पिक है। जिन चीजों को आप लागू नहीं करना चाहते हैं, उनके लिए चेक हटा दें। अपनी आवश्यकताओं के समाधान को अनुकूलित करना आसान होना चाहिए।

— तोमलक

यह जवाब "कॉमन वैलिडेशन टास्क" के तहत स्टैक ओवरफ्लो रेगुलर एक्सप्रेशन एफएक्यू में जोड़ा गया है ।

— aliteralmind

@ shA.t यह एक ही बात है। मैंने केवल (?=...)पैटर्न को बनाए रखने की कोशिश की ताकि यह बाकी अभिव्यक्ति के सेटअप से मेल खाए ..

— टॉमालक

@ shA.t क्या आप कहते हैं कि "केवल गैर-अंतरिक्ष वर्ण होते हैं" ( (?=\S+$)) या "अंतरिक्ष वर्ण नहीं होते हैं" ( (?!.*\s)) प्राथमिकता का विषय है। आपको जो अच्छा लगे, उसका इस्तेमाल करें। :)

— तोमलक

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 अक्षर

Comments

। {5,10} न्यूनतम 5 वर्णों और अधिकतम 10 वर्णों का प्रतिनिधित्व करता है। बस किसी भी मामले में विशिष्ट स्पष्टीकरण की तलाश है।

— अभय

@ भाभी, मैं यही चाह रहा था। धन्यवाद।

— अक्षत श्रीनिवास

मैं सुरक्षा के कारण स्ट्रिंग के बजाय एक वर्ण सरणी में संग्रहीत पासवर्ड पर रेगेक्स को लागू करने का प्रयास कर रहा हूं। लेकिन एक चार सरणी में रेगेक्स कैसे लागू होता है?

— AgentM

Answer 3

पहले दिए गए सभी उत्तर प्रत्येक आवश्यकता के लिए एक अलग लुकहेड का उपयोग करने के लिए एक ही (सही) तकनीक का उपयोग करते हैं। लेकिन उनमें कुछ अक्षमताओं और संभावित रूप से बड़े पैमाने पर बग होते हैं, जो कि पीछे के छोर पर निर्भर करते हैं जो वास्तव में पासवर्ड का उपयोग करेंगे।

मैं स्वीकार किए जाते हैं जवाब से regex के साथ शुरू करेंगे:

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

सबसे पहले, चूंकि जावा समर्थन करता है \Aऔर \zमैं उन का उपयोग करना पसंद करता हूं ताकि यह सुनिश्चित हो सके कि संपूर्ण स्ट्रिंग स्वतंत्र रूप से मान्य है Pattern.MULTILINE। यह प्रदर्शन को प्रभावित नहीं करता है, लेकिन जब regexes को पुनर्नवीनीकरण किया जाता है तो गलतियों से बचा जाता है।

\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

डॉट का उपयोग केवल तभी किया जाना चाहिए जब आप वास्तव में किसी भी चरित्र को अनुमति देना चाहते हैं। अन्यथा, अपने regex को केवल उन वर्णों तक सीमित करने के लिए (उपेक्षित) वर्ण वर्ग का उपयोग करें जिन्हें वास्तव में अनुमति है। हालाँकि इस मामले में बहुत कम फर्क पड़ता है, लेकिन जब कुछ और उपयुक्त हो तो डॉट का उपयोग न करना एक बहुत अच्छी आदत है। मैं अब तक भयावह बैकट्रैकिंग के कई मामलों को देखता हूं क्योंकि डेवलपर बहुत अधिक आलसी था।

चूंकि एक अच्छा मौका है प्रारंभिक परीक्षणों में पासवर्ड के पहले भाग में एक उपयुक्त चरित्र मिलेगा, एक आलसी क्वांटिफायर अधिक कुशल हो सकता है:

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

लेकिन अब वास्तव में महत्वपूर्ण मुद्दे के लिए: कोई भी उत्तर इस तथ्य का उल्लेख नहीं करता है कि मूल प्रश्न किसी ऐसे व्यक्ति द्वारा लिखा गया लगता है जो ASCII में सोचता है। लेकिन जावा स्ट्रिंग्स में यूनिकोड हैं। क्या पासवर्ड में गैर-एएससीआईआई पात्रों की अनुमति है? यदि वे हैं, तो केवल ASCII रिक्त स्थान हैं, या सभी यूनिकोड व्हाट्सएप को बाहर रखा जाना चाहिए।

डिफ़ॉल्ट रूप से \sकेवल ASCII व्हाट्सएप से मेल खाता है, इसलिए इसका व्युत्क्रम \Sसभी यूनिकोड वर्णों (व्हाट्सएप या नहीं) और सभी गैर-व्हाट्सएप ASCII वर्णों से मेल खाता है। यदि यूनिकोड वर्णों की अनुमति है लेकिन यूनिकोड रिक्त स्थान नहीं हैं, तो UNICODE_CHARACTER_CLASSध्वज \Sको यूनिकोड व्हाट्सएप को बाहर करने के लिए निर्दिष्ट किया जा सकता है । यदि यूनिकोड वर्णों की अनुमति नहीं है, तो [\x21-\x7E]इसका उपयोग \Sसभी ASCII वर्णों से मेल खाने के बजाय किया जा सकता है जो एक स्थान या नियंत्रण वर्ण नहीं हैं।

जो हमें अगले संभावित मुद्दे पर लाता है: क्या हम नियंत्रण पात्रों को अनुमति देना चाहते हैं? एक उचित रेगेक्स लिखने में पहला कदम यह निर्दिष्ट करना है कि आप क्या मेल खाना चाहते हैं और क्या नहीं। केवल 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;
}

Comments

और सुरक्षा के नजरिए से लंबे पासवर्ड को बल देना कहीं बेहतर है, पासवर्ड को सुपर कॉम्प्लिकेटेड और याद रखने में कठिन बनाने के बजाय अच्छी तरह से ज्ञात पासवर्ड (जैसे 12345 और पास = यूजर) को रोकें।

— मार्टिन रौशर

मुझे आपका दृष्टिकोण ऊपर पसंद है। उसके लिये आपका धन्यवाद!

— थॉमस लैंग

Answer 5

पासवर्ड की आवश्यकता:

• पासवर्ड लंबाई में कम से कम आठ (8) अक्षर होना चाहिए जहां सिस्टम इसका समर्थन कर सकता है।

• पासवर्ड में इन समूहों के कम से कम दो (2) वर्ण शामिल होने चाहिए: अल्फा, न्यूमेरिक और विशेष वर्ण।

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

मैंने इसका परीक्षण किया और यह काम करता है

Answer 6

प्रत्येक प्रकार के चरित्र के लिए न्यूनतम आवश्यकताओं में रुचि रखने वाले किसी व्यक्ति के लिए, मैं टॉमालक के स्वीकृत उत्तर पर निम्नलिखित विस्तार करने का सुझाव दूंगा:

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

ध्यान दें कि यह एक प्रारूपण स्ट्रिंग है न कि अंतिम रेगेक्स पैटर्न। बस इसके लिए न्यूनतम आवश्यक घटनाओं के साथ% d को प्रतिस्थापित करें: अंक, लोअरकेस, अपरकेस, गैर-अंक / चरित्र, और संपूर्ण पासवर्ड (क्रमशः)। अधिकतम घटनाएं होने की संभावना नहीं है (जब तक कि आप अधिकतम 0 नहीं चाहते हैं, प्रभावी रूप से ऐसे किसी भी अक्षर को अस्वीकार कर सकते हैं) लेकिन उन्हें आसानी से जोड़ा जा सकता है। प्रत्येक प्रकार के आस-पास के अतिरिक्त समूह पर ध्यान दें, ताकि गैर-निरंतर मैचों के लिए न्यूनतम / अधिकतम बाधाएं अनुमति दें। यह एक ऐसी प्रणाली के लिए अद्भुत काम करता है जहां हम केंद्रीय रूप से कॉन्फ़िगर कर सकते हैं कि हमें कितने प्रकार के चरित्र की आवश्यकता है और फिर वेबसाइट के साथ-साथ दो अलग-अलग मोबाइल प्लेटफॉर्म हैं जो उपरोक्त स्वरूपण स्ट्रिंग के आधार पर रेगेक्स पैटर्न का निर्माण करने के लिए उस जानकारी को प्राप्त करते हैं।

Answer 7

यह हर विशेष चरित्र के लिए जाँच करता है:

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

Answer 8

मापदंडों के साथ, जावा विधि आपके लिए तैयार है

बस अपने वांछित मापदंडों को कॉपी और पेस्ट करें और सेट करें।

यदि आप एक मॉड्यूल नहीं चाहते हैं, तो बस टिप्पणी करें या विशेष चार के लिए मेरे द्वारा किए गए अनुसार "यदि" जोड़ें

//______________________________________________________________________________
/**
 * 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 9

Passay पुस्तकालय का उपयोग करें जो शक्तिशाली एपीआई है।

Answer 10

मुझे लगता है कि यह भी कर सकते हैं (एक सरल मोड के रूप में):

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

[रेगीक्स डेमो]

Answer 11

आसान वाला

("^ (! =। * [0-9])) (=? * [Az]) (? =? *। [AZ]) (=। *। * [\\ w _]] [\\ s] {8 , 10} $ ")

1. (; = = कुछ भी) -> का अर्थ है कि सभी इनपुट स्ट्रिंग में सकारात्मक दिखता है और सुनिश्चित करें कि इस स्थिति के लिए लिखा है। नमूना (? =। * [[0-9]) -> इसका मतलब है कि सभी स्ट्रिंग में एक अंकों की संख्या लिखी गई है। यदि नहीं लिखा वापसी झूठी ।

2. (?! कुछ भी) -> (शिकंजा विपरीत) नकारात्मक दिखता है आगे अगर हालत है इसका मतलब लिखा वापसी झूठी ।

   करीब अर्थ ^ (स्थिति) (स्थिति) (स्थिति) (स्थिति) [\ _] {},१०} $

Comments

जबकि कोड केवल उत्तर समस्या का समाधान प्रदान कर सकता है, कुछ स्पष्टीकरण से उत्तर की गुणवत्ता में काफी सुधार होगा।

— निगेल रेन

Answer 12

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. पहले पासवर्ड को एक स्ट्रिंग के रूप में सेट करें और पूर्णांक सेट ओ बनाएँ।
2. फिर लूप द्वारा प्रत्येक और हर चार की जांच करें।
3. यदि यह स्ट्रिंग में संख्या पाता है तो n 5 जोड़ें। फिर लूप के लिए अगले पर जाएं। Character.isDigit (s.charAt (i))
4. यह लूप स्ट्रिंग में रखे किसी भी अक्षर की जाँच करता है। यदि इसकी खोज हो तो n में एक और 5 जोड़ो। Character.isLetter (s.charAt (i))
5. अब पूर्णांक n की जाँच करें यदि स्थिति के अनुसार। यदि n = 10 सही है तो स्ट्रिंग अल्फ़ान्यूमेरिक है और नहीं।

Answer 13

इसके अलावा आप ऐसा कर सकते हैं।

 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 14

मजबूत पासवर्ड के लिए नमूना कोड ब्लॉक:

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

1. कम से कम 6 अंक
2. 18 अंकों तक
3. एक संख्या
4. एक लोअरकेस
5. एक बड़ा अक्षर
6. सभी विशेष वर्ण हो सकते हैं

Answer 15

RegEx है -

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

1. कम से कम 8 अंक {8,}
2. कम से कम एक संख्या (=! *। * d)
3. कम से कम एक लोअरकेस (! =। * [az])
4. कम से कम एक अपरकेस (? =। * [AZ])
5. कम से कम एक विशेष चरित्र (=! *। * [@ # $% ^ & + =])
6. कोई स्थान नहीं है