पासवर्ड की शक्ति को मान्य करने के लिए Rexx

Question

मेरा पासवर्ड शक्ति मानदंड नीचे है:

• 8 अक्षर लंबाई
• ऊपरी मामले में 2 पत्र
• 1 विशेष चरित्र (!@#$&*)
• 2 अंक (0-9)
• लोअर केस में 3 पत्र

किसी कृपया मुझे उसी के लिए regex दे सकते हैं सभी शर्तों को पासवर्ड से पूरा किया जाना चाहिए।

Comments

क्या आप वास्तव में इंटरनेट पर अपने पासवर्ड सुरक्षा उपायों पर भरोसा करने के लिए तैयार हैं?

— बोरेलिड

@ बोरेलिड: अपनी पासवर्ड नीतियों को प्रकाशित करना आमतौर पर आपकी सुरक्षा को महत्वपूर्ण रूप से प्रभावित नहीं करना चाहिए । यदि ऐसा होता है, तो आपकी नीतियां खराब हैं ("केवल passwordऔर hello123वैध पासवर्ड हैं!")।

— जोआचिम सॉयर

@ जोकिम सौर: यह मेरा मतलब नहीं है। मेरा मतलब यह था कि पोस्टर शायद जो कुछ भी regex प्राप्त करता है उस पर भरोसा करने वाला है। ऐसा अच्छा विचार नहीं है।

— बोरिलायड

वास्तव में यह रेगेक्स सर्विस कोड में होने जा रहा है, मैं अलग-अलग मामलों के लिए परीक्षण कर रहा हूं,

— अजय केलकर

जटिल पासवर्ड नियम आमतौर पर अधिक सुरक्षित पासवर्ड के लिए नेतृत्व नहीं करेंगे, महत्वपूर्ण केवल एक न्यूनतम लंबाई है। लोग मजबूत पासवर्ड के टन को याद नहीं रख सकते हैं, और ऐसे नियम अच्छी पासवर्ड योजनाओं में हस्तक्षेप कर सकते हैं। लोग ऐसे पासवर्डों को बायपास करने के लिए बहुत आविष्कारशील हो सकते हैं, जैसे "पासवर्ड -2014" जैसे कमजोर पासवर्ड का उपयोग करके। अक्सर आप मजबूत लोगों के बजाय कमजोर पासवर्ड के साथ समाप्त होते हैं।

— मार्टिंकॉकली

Answer 1

आप आगे की जाँच के सकारात्मक रूप का उपयोग करके इन जाँचों को कर सकते हैं:

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

रूबल लिंक

स्पष्टीकरण:

^                         Start anchor
(?=.*[A-Z].*[A-Z])        Ensure string has two uppercase letters.
(?=.*[!@#$&*])            Ensure string has one special case letter.
(?=.*[0-9].*[0-9])        Ensure string has two digits.
(?=.*[a-z].*[a-z].*[a-z]) Ensure string has three lowercase letters.
.{8}                      Ensure string is of length 8.
$                         End anchor.

Comments

किसी को जो कम से कम की लंबाई चाहता है के लिए n, की जगह .{8}के साथ.{n,}

— NullUserException

एक पूर्ण विवरण के लिए +1। मेरे पासवर्ड नियम भिन्न हैं लेकिन आपके उत्तर के आधार पर मैं रेगेक्स को अनुकूलित कर सकता हूं।

— मोरवेल

रेक्स में क्या हो रहा है इसका वर्णन करने के लिए धन्यवाद। यह हम में से उन लोगों के लिए एक महान सीखने के उदाहरण के रूप में कार्य करता है जो वास्तव में वाक्य रचना के साथ कभी नहीं हुए हैं।

मैं रेगेक्स के स्पष्टीकरण की भी सराहना करता हूं। कई बार मैं जटिल रीजेक्स का उपयोग करता हूं जो मुझे मिला, वास्तव में समझने के बिना कि क्या चल रहा है।

— निकोलस स्मिथ

महान पैटर्न, मुझे आश्चर्य है कि क्वांटिफायर का उपयोग क्यों नहीं किया जाता है? कम से कम 1 विशेष, 1 संख्या, 1 विशेष वर्ण, 8 वर्ण: ^ (?! * ([AZ]) {1}}} (=। *। * [! @ # $ & *] {1,}) (! ? =। * * [0-9] {1,}) (! =। * [

— Az

Answer 2

आप अपने प्रत्येक अवरोध को अलग-अलग निर्दिष्ट करने के लिए शून्य-लंबाई वाले पॉजिटिव लुक-अहीड्स का उपयोग कर सकते हैं:

(?=.{8,})(?=.*\p{Lu}.*\p{Lu})(?=.*[!@#$&*])(?=.*[0-9])(?=.*\p{Ll}.*\p{Ll})

यदि आपका रेगेक्स इंजन \pअंकन का समर्थन नहीं करता है और शुद्ध ASCII पर्याप्त है, तो आप के \p{Lu}साथ [A-Z]और \p{Ll}साथ बदल सकते हैं [a-z]।

Answer 3

ऊपर दिए गए उत्तर सही हैं, लेकिन मेरा सुझाव है कि एक बड़े के बजाय कई छोटे रेगेक्स का उपयोग करें।
लंबे रेगेक्स को विभाजित करने के कुछ फायदे हैं:

• लिखने और पढ़ने में आसानी
• डीबग करने में आसानी
• रेगेक्स के भाग को जोड़ने / हटाने में आसानी

आम तौर पर यह दृष्टिकोण कोड को आसानी से बनाए रखने योग्य होता है ।

ऐसा कहने के बाद, मैं एक कोड कोड साझा करता हूं, जो मैं उदाहरण के रूप में स्विफ्ट में लिखता हूं :

struct RegExp {

    /**
     Check password complexity

     - parameter password:         password to test
     - parameter length:           password min length
     - parameter patternsToEscape: patterns that password must not contains
     - parameter caseSensitivty:   specify if password must conforms case sensitivity or not
     - parameter numericDigits:    specify if password must conforms contains numeric digits or not

     - returns: boolean that describes if password is valid or not
     */
    static func checkPasswordComplexity(password password: String, length: Int, patternsToEscape: [String], caseSensitivty: Bool, numericDigits: Bool) -> Bool {
        if (password.length < length) {
            return false
        }
        if caseSensitivty {
            let hasUpperCase = RegExp.matchesForRegexInText("[A-Z]", text: password).count > 0
            if !hasUpperCase {
                return false
            }
            let hasLowerCase = RegExp.matchesForRegexInText("[a-z]", text: password).count > 0
            if !hasLowerCase {
                return false
            }
        }
        if numericDigits {
            let hasNumbers = RegExp.matchesForRegexInText("\\d", text: password).count > 0
            if !hasNumbers {
                return false
            }
        }
        if patternsToEscape.count > 0 {
            let passwordLowerCase = password.lowercaseString
            for pattern in patternsToEscape {
                let hasMatchesWithPattern = RegExp.matchesForRegexInText(pattern, text: passwordLowerCase).count > 0
                if hasMatchesWithPattern {
                    return false
                }
            }
        }
        return true
    }

    static func matchesForRegexInText(regex: String, text: String) -> [String] {
        do {
            let regex = try NSRegularExpression(pattern: regex, options: [])
            let nsString = text as NSString
            let results = regex.matchesInString(text,
                options: [], range: NSMakeRange(0, nsString.length))
            return results.map { nsString.substringWithRange($0.range)}
        } catch let error as NSError {
            print("invalid regex: \(error.localizedDescription)")
            return []
        }
    }
}

Comments

इसके अलावा, जब ऊपर जटिल कॉम्प्लेक्स का उपयोग किया जाता है, तो अपने आप को भयावह बैकट्रैकिंग ( नियमित-expressions.info/catastrophic.html ) खोलना बहुत आसान होता है । यह तब तक किसी का ध्यान नहीं जा सकता है जब तक कि एक दिन आपका सर्वर 100% सीपीयू के साथ न लटका दे क्योंकि एक उपयोगकर्ता ने "अजीब" पासवर्ड का उपयोग किया था। उदाहरण: ^ ((a-z0-9] +) {8,} $ (क्या आप त्रुटि देख सकते हैं?)

— aKzenT

Answer 4

मैं जोड़ने का सुझाव दूंगा

(?!.*pass|.*word|.*1234|.*qwer|.*asdf) exclude common passwords

Answer 5

कोडेडडिक्ट का समाधान ठीक काम करता है, लेकिन यह थोड़ा अधिक कुशल है: (पायथन सिंटैक्स)

password = re.compile(r"""(?#!py password Rev:20160831_2100)
    # Validate password: 2 upper, 1 special, 2 digit, 1 lower, 8 chars.
    ^                        # Anchor to start of string.
    (?=(?:[^A-Z]*[A-Z]){2})  # At least two uppercase.
    (?=[^!@#$&*]*[!@#$&*])   # At least one "special".
    (?=(?:[^0-9]*[0-9]){2})  # At least two digit.
    .{8,}                    # Password length is 8 or more.
    $                        # Anchor to end of string.
    """, re.VERBOSE)

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

Comments

क्या आप जाँच सकते हैं कि क्या यह सही है? ट्रिपल डबलक्वे और प्रश्न चिह्न के बीच पहली पंक्ति में गोल ब्रैकेट खोलने के कारण मुझे संदेह है। मैं देख सकता हूं कि पायथन टिप्पणी (हैश) बाद में है। मैं अंत एंकर (डॉलर चिह्न) के पास संवाददाता समापन दौर ब्रैकेट नहीं देख सकता। उल्लेख करना चाहिए कि मैं एक रेगीक्स प्रोफाई नहीं हूं।

— १६:१६ को लोपेजोस

@lospejos - # एक नियमित एक लाइन टिप्पणी की शुरुआत नहीं है। यह हैश एक टिप्पणी समूह का हिस्सा है जो ए के साथ शुरू होता है (?#और ए के साथ समाप्त होता है )। इस रेगेक्स में कोई असंतुलित परिंदे नहीं हैं।

— सवार

Answer 6

import re

RegexLength=re.compile(r'^\S{8,}$')
RegexDigit=re.compile(r'\d')
RegexLower=re.compile(r'[a-z]')
RegexUpper=re.compile(r'[A-Z]')


def IsStrongPW(password):
    if RegexLength.search(password) == None or RegexDigit.search(password) == None or RegexUpper.search(password) == None or RegexLower.search(password) == None:
        return False
    else:
        return True

while True:
    userpw=input("please input your passord to check: \n")
    if userpw == "exit":
        break
    else:
        print(IsStrongPW(userpw))

Answer 7

@ कोडेडडिक्ट का समाधान काम करेगा।

आपको अपने कुछ नियमों को बदलने पर भी विचार करना चाहिए:

1. अधिक विशेष वर्ण जोड़ें अर्थात%, ^, (,), -, _, + और अवधि। मैं उन सभी विशेष वर्णों को जोड़ रहा हूं, जिन्हें आपने यूएस कीबोर्ड में संख्या चिह्नों से ऊपर याद किया था। बचो रेगेक्स उपयोग करता है।
2. पासवर्ड 8 या अधिक अक्षर का बनाएं। सिर्फ एक स्थिर संख्या 8 नहीं।

उपरोक्त सुधारों के साथ, और अधिक लचीलेपन और पठनीयता के लिए, मैं रेगेक्स को संशोधित करूंगा।

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

मूल व्याख्या

(?=.*RULE){MIN_OCCURANCES,}     Each rule block is shown by (){}. The rule and number of occurrences can then be easily specified and tested separately, before getting combined

विस्तृत विवरण

^                             start anchor
(?=.*[a-z]){3,}               lowercase letters. {3,} indicates that you want 3 of this group
(?=.*[A-Z]){2,}               uppercase letters. {2,} indicates that you want 2 of this group
(?=.*[0-9]){2,}               numbers. {2,} indicates that you want 2 of this group
(?=.*[!@#$%^&*()--__+.]){1,}   all the special characters in the [] fields. The ones used by regex are escaped by using the \ or the character itself. {1,} is redundant, but good practice, in case you change that to more than 1 in the future. Also keeps all the groups consistent
{8,}                          indicates that you want 8 or more
$                             end anchor

और अंत में, परीक्षण के प्रयोजनों के लिए यहां उपरोक्त रेगेक्स के साथ एक लुटेला है

Comments

धन्यवाद @ सफ़े। मैं इसे अपने कोड में उपयोग कर रहा हूं। मुझे पठनीयता और पुनरावृत्ति की क्षमता पसंद है, क्योंकि आपको भविष्य में वापस जाना होगा और इसे बदलना होगा यानी पासवर्ड पॉलिसी बदलने के मामले में :)

— lsu_guy

Answer 8

PHP के लिए, यह ठीक काम करता है!

 if(preg_match("/^(?=(?:[^A-Z]*[A-Z]){2})(?=(?:[^0-9]*[0-9]){2}).{8,}$/", 
 'CaSu4Li8')){
    return true;
 }else{
    return fasle;
 }

इस मामले में परिणाम सच है

Thridks @ridgerunner के लिए

Comments

क्यों नहीं return preg_match("/^(?=(?:[^A-Z]*[A-Z]){2})(?=(?:[^0-9]*[0-9]){2}).{8,}$/", 'CaSu4Li8')?

— aloisdg

Answer 9

एक और समाधान:

import re

passwordRegex = re.compile(r'''(
    ^(?=.*[A-Z].*[A-Z])                # at least two capital letters
    (?=.*[!@#$&*])                     # at least one of these special c-er
    (?=.*[0-9].*[0-9])                 # at least two numeric digits
    (?=.*[a-z].*[a-z].*[a-z])          # at least three lower case letters
    .{8,}                              # at least 8 total digits
    $
    )''', re.VERBOSE)

def userInputPasswordCheck():
    print('Enter a potential password:')
    while True:
        m = input()
        mo = passwordRegex.search(m) 
        if (not mo):
           print('''
Your password should have at least one special charachter,
two digits, two uppercase and three lowercase charachter. Length: 8+ ch-ers.

Enter another password:''')          
        else:
           print('Password is strong')
           return
userInputPasswordCheck()

Answer 10

पासवर्ड को निम्न 4 जटिलता नियमों में से कम से कम 3 से मिलना चाहिए,

[कम से कम 1 अपरकेस कैरेक्टर (AZ) कम से कम 1 लोअरकेस कैरेक्टर (az) कम से कम 1 अंक (0-9) कम से कम 1 स्पेशल कैरेक्टर - स्पेस को स्पेशल कैरेक्टर भी मानना ​​न भूलें]

कम से कम 10 अक्षर

अधिकतम 128 वर्णों पर

एक पंक्ति में 2 से अधिक समान वर्ण नहीं हैं (उदाहरण के लिए, 111 की अनुमति नहीं है)

'^ ((? (? ।) \ 1 {2}) (? = ? [Az]) (? = ([ । AZ]) (=। [[0-9]) | ((? = [Az] ] ) (=। [AZ]) (? =? [^ A-zA-Z0-9]) - (? = ( [AZ]] = (=। [0-9]) (? =? = ^ A) -zA-Z0-9]) | (=! [az]) (! =। [0-9] ((? =। * [^ a-zA-Z0-9]))। {10,127} $ '।

(?!। * (।) \ 1 {2})

((? = [az]) (?! ( [AZ]) (? =? * [0-9]

((? = [az]) (?! ( [AZ]) (? =। * [^ a-zA-Z0-9])

((? = [AZ]) (?! = [0-9]) (? =? * [^ A-zA-Z0-9])

((? = [az]) (?! = [0-9]) (? =। * [^ a-zA-Z0-9])।

। {} 10.127

Answer 11

ऊपर regex के सभी दुर्भाग्य से मेरे लिए काम नहीं किया। एक मजबूत पासवर्ड के मूल नियम हैं

• कम से कम एक कैपिटल लेटर होना चाहिए
• कम से कम एक छोटा अक्षर होना चाहिए
• कम से कम एक नंबर होना चाहिए
• कम से कम एक विशेष चरित्र होना चाहिए
• और न्यूनतम लंबाई

तो, बेस्ट रेगेक्स होगा

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

उपरोक्त regex की न्यूनतम लंबाई 8. है। आप इसे {8,} से { any_number ,} में बदल सकते हैं

नियमों में संशोधन?

मान लें कि आप न्यूनतम x वर्ण छोटे अक्षर, y अक्षर बड़े अक्षर, z वर्ण संख्या, कुल न्यूनतम लंबाई w चाहते हैं । फिर रेगेक्स के नीचे प्रयास करें

^(?=.*[a-z]{x,})(?=.*[A-Z]{y,})(?=.*[0-9]{z,})(?=.*[!@#\$%\^&\*]).{w,}$

नोट: x , y , z , w को regex में बदलें

संपादित करें: अद्यतित रेगेक्स उत्तर

Edit2: संशोधन जोड़ा गया

Comments

आपका रेगेक्स मिलान 12345678कर रहा है क्या आपको यकीन है कि यह एक मजबूत पासवर्ड है? कृपया, पोस्ट करने से पहले अपने regex को आज़माएं।

— टोटो 3

यह बेहतर है, लेकिन सवाल का जवाब नहीं है, वे 1) 8 वर्ण लंबाई चाहते हैं। 2) ऊपरी मामले में 2 पत्र। 3) 1 विशेष चरित्र (! @ # $ & *)। 4) 2 अंक (0-9)। 5) लोअर केस में 3 अक्षर।

— टोटो

@ क्या अब आप अपने विचार साझा कर सकते हैं?

— जुनैद खत्री

आपका regex ध्यान नहीं देता है कि 2 अनिवार्य अपरकेस अक्षर अन्य वर्णों के साथ अलग किए जा सकते हैं, लोअरकेस और अंकों के लिए समान टिप्पणी। मान्य उत्तर वह है जिसे स्वीकार किया गया है।

— टोटो 3