पोस्ट-इट द्वारा सुरक्षा

Question

जैसा कि आप जानते हैं कि हैकर्स हर जगह हैं और वे सब कुछ हैक करना चाहते हैं। आपको पासवर्ड आवश्यकताएं बनाने के लिए कहा गया था जो किसी भी हैकर को रोक देगा । समस्या यह है, कि आपके बॉस ने सुना है कि एलओसी के लिए भुगतान करना बुराई है और वह आपको प्रति माह $ 1800 - $ 0.03 * वर्णों का भुगतान करता है ताकि आप सरलतम बात लिख सकें, जो संभवतः काम कर सकती है। इसलिए, आपको कम संख्या में वर्णों का उपयोग करना होगा (उम्मीद से बहुत छोटा), या अन्यथा नकदी के बारे में भूल जाएं। इसके अलावा, आपके बॉस को परवाह नहीं है कि आप किस भाषा का उपयोग करेंगे।

अच्छे पासवर्ड की आवश्यकताएं उल्लिखित लेख के समान हैं, समाधान आधारित आवश्यकताओं को छोड़कर बाहरी फ़ाइलों पर निर्भर रहने के लिए डिक्शनरी को हटा दिया गया था, आपको अक्षरों को फिर से व्यवस्थित करने के लिए जांचने की आवश्यकता नहीं है (यह समझने के लिए कि वास्तव में इसका क्या मतलब है यह समझने के लिए मुश्किल है) अंतिम नियम को हटा दिया गया है (3/4 क्या है?) और यह पुराने पासवर्ड की जांच नहीं करता है।

लिंक्ड लेख से कुछ आवश्यकताओं को हटाने के बाद सटीक आवश्यकताएं हैं:

• कम से कम 8 वर्ण हैं!
• 12 वर्णों से अधिक लंबा नहीं होना चाहिए!
• ऊपरी और निचले मामले के पात्र हैं!
• 8 से अधिक अपर-केस पत्र नहीं हैं!
• 8 से कम लोअर-केस लेटर नहीं है!
• कम से कम 2 अक्षर हैं!
• एक प्रमुख पत्र है!
• कम से कम 1 अंक है!
• आपका उपयोगकर्ता नाम नहीं है!
• आपका उपयोगकर्ता नाम पीछे की ओर न हो!
• अपना उपयोगकर्ता नाम शामिल न करें!
• अपना उपयोगकर्ता नाम पीछे की ओर न रखें!
• अक्षरों को दोहराने की 1 से अधिक जोड़ी नहीं है!
• एक ही वर्ण की 3 आवृत्तियाँ नहीं होती हैं !
• कैरेट (^) शामिल नहीं है
• जगह नहीं है
• शामिल नहीं =
• नहीं conatain &
• शामिल नहीं #
• शामिल नहीं ,
• शंकुधारी नहीं ;
• शामिल नहीं "
• शामिल नहीं>
• शामिल नहीं है <
• शामिल नहीं [
• नहीं होते |
• शामिल नहीं )

इस सूची में सभी गलत वर्तनी को छोड़ दिया गया है।

$ ./checkpass
Username: John
Password: L!]E2m69
OK.

$ ./checkpass
Username: John
Password: JohnnhoJ12
Nope.

$ ./checkpass
Username: JOE.smith
Password: JOE!smith123
OK.

सबसे छोटा कोड पैसा जीतता है (जेपीजी फ़ाइल के रूप में भेजा जाता है)। इसे "उपयोगकर्ता नाम:" और "पासवर्ड:" दिखाना होगा और सटीक संदेश के साथ संकेत देना होगा।

Comments

डेली डब्ल्यूटीएफ लेख में एक कोड गोल्फ चुनौती देखकर अच्छा लगा, +1 ;-)

— क्रिश्चोफेड

पहला उदाहरण विफल होना चाहिए ("ऊपरी और निचले मामले के पात्र हैं!"), क्या यह नहीं होना चाहिए?

— हावर्ड

@ हॉवर्ड: इसका मतलब है कि पासवर्ड में अपरकेस और लोअरकेस अक्षर दोनों की जरूरत है। "नहीं" शब्द का अभाव।

— कोनराड बोरोस्की

यह कुछ फोंट में बहुत स्पष्ट नहीं है कि उस पहले पासवर्ड में l एक लोअर-केस ell है और नंबर वन नहीं है, इसलिए मैं इसे एक अनलिमिटेड लोअर-केस लेटर से बदलने के लिए एडिट कर रहा हूं।

— पीटर टेलर

@PeterTaylor आह, धन्यवाद। वास्तव में मैंने इसे 1ell के बजाय (अंक एक) के रूप में पढ़ा ।

— हावर्ड

Answer 1

पर्ल, 203 194 189 193 चार्ट

यहाँ मेरी पर्ल समस्या पर है:

print"Username: ";chop($u=<>);$n=reverse$u;print"Password: ";$_=<>;
say/^\pL.{7,11}$/*/\d/*/[A-Z]/*9>y/A-Z//&y/a-z//<9*/[a-z]/*
!/[" #,;->^&[|)]|(.)(.*\1.*\1|\1.*(.)\3)|\Q$u\E|\Q$n/?"OK.":"Nope."

पासवर्ड के क्रम में regexes की जाँच करें:

• एक अक्षर से शुरू होता है, जिसमें आठ से बारह अक्षर होते हैं

• एक अंक होता है

• एक बड़ा अक्षर है

• आठ या उससे कम बड़े अक्षर हैं

• आठ या उससे कम अक्षर हैं

• एक लोअरकेस अक्षर है

• किसी भी निषिद्ध विराम चिह्नों, किसी भी वर्ण की तीन घटनाएं, एक दोहरे चरित्र की एक से अधिक घटना, उपयोगकर्ता नाम या उपयोगकर्ता नाम उलट शामिल नहीं है।

(189-चार्ट संस्करण में बग को इंगित करने के लिए पीटर टेलर का धन्यवाद।)

Comments

यह पता लगाने के लिए कि इसके साथ विचारधारा पर कैसे चलना है use v5.10;और यह विफल रहता है मेरे "regexes ठीक से बच गए हैं" टेस्ट केस। देखें ideone.com/QKFnZ

— पीटर टेलर

@PeterTaylor: मैं रूबी के बारे में नहीं जानता, लेकिन पर्ल में फिक्स होगा \Q$u\E|\Q$n(अंतिम \Eभाग को छोड़ दिया जा सकता है, अगर इस हिस्से को समाप्त करने के लिए स्थानांतरित किया जाएगा)।

— कोनराड बोरोस्की

OTOH मुझे लगता है कि एक चरित्र को दोहराकर विलय को बचाया जा सकता है (.)(.*\1.*\1|\1.*(.)\3) (परीक्षण नहीं किया गया - मैं आइडोन के साथ एक पूर्ण परीक्षण बैटरी को स्क्रिप्ट करने की कोशिश नहीं करने जा रहा हूं)।

— पीटर टेलर

Answer 2

रूबी, 270 अक्षर

$><<"Username: ";u=gets.chop
$><<"Password: ";gets
puts ('^.{8,12}$+\p{Lower}+\p{Upper}+^(\p{Alpha}.*){2}+\d+(\p{Lower}.*){9}+(\p{Upper}.*){9}+(.)\1.*(.)\2+(.).*\1.*\1+[ ^=&#,;"<>\[|)]+'+u+?++u.reverse).split(?+).map{|r|/#{r}/=~$_??A:?B}*""=="AAAAABBBBBBB"?"OK.":"Nope."

एक रूबी कार्यान्वयन बारह नियमित अभिव्यक्तियों पर निर्माण करता है। प्रत्येक अभिव्यक्ति या तो एक सकारात्मक मिलान (पहले पांच) या एक नकारात्मक एक (बाद के सात) है। प्रतिबंध के रूप में उपयोगकर्ता नाम में केवल अक्षर या अंक हो सकते हैं।

सकारात्मक नियमित अभिव्यक्ति मैच:

• /^.{8,12}$/: कम से कम 8 वर्ण हैं!, 12 वर्णों से अधिक लंबा नहीं है!
• /\p{Lower}/और /\p{Upper}/: ऊपरी और निचले मामले के पात्र हैं!
• /^(\p{Alpha}.*){2}/: कम से कम 2 अक्षर हैं!, एक प्रमुख पत्र है!
• /\d/: कम से कम 1 अंक है!

नकारात्मक नियमित अभिव्यक्ति मेल खाती है:

• /(\p{Lower}.*){9}/: कोई 8 से कम लोअर-केस लेटर नहीं है!
• /(\p{Upper}.*){9}/: 8 से अधिक अपर-केस पत्र नहीं है!
• /(.)\1.*(.)\2/: दोहराए जाने वाले पात्रों में से 1 से अधिक जोड़ी नहीं है!
• /(.).*\1.*\1/: एक ही वर्ण की 3 घटनाएं नहीं होती हैं!
• /[ ^=&#,;"<>\[|)]/: कैरेट, स्पेस, =, &, #, ,,, ",>, <, [, |,] शामिल नहीं है।
• /#{u}/: आपका उपयोगकर्ता नाम नहीं है!, आपका उपयोगकर्ता नाम नहीं है!
• /#{u.reverse}/: आपका उपयोगकर्ता नाम पीछे की ओर न हो!, अपना उपयोगकर्ता नाम पीछे की ओर न रखें!

Comments

यह उपयोगकर्ता नाम नहीं बचता है, इसलिए पूरी तरह से मान्य पासवर्ड अस्वीकार किया जा सकता है। Ideone.com/bPpeo

— पीटर टेलर

@PeterTaylor यही कारण है कि मैंने अपने उत्तर में उपयोगकर्ता नामों के लिए प्रतिबंध का उल्लेख किया।

— हावर्ड

Answer 3

पायथन 3, 291 बाइट्स / अक्षर

from re import*
n,p=map(input,["Username: ","Password: "])
c,U,L=lambda x:len(split("[%s]"%x,p)),"A-Z","a-z"
print(["OK.","Nope."][any([8>len(p)>12,2>c(U)>9,2>c(L)>9,3>c(U+L),match(U+L,p),2>c("0-9"),n in p,n[::-1]in p,any(c(x)>3 for x in p),len(findall("(.)\\1",p))>1,c(' ^=&#,;"><[|)')>1])])

अधिक अच्छी तरह से स्वरूपित और टिप्पणी:

# import all elements from the regular expression module
from re import *

# Get the two lines of user input (username `n`, password `p`):
n, p = map(input, ["Username: ","Password: "])

# Assign some internally useful shortcuts (uppercase letters `U`, lowercase letters `L`):
# `c(x)` counts the occurrences of pattern `x` in the password `p` plus 1
c, U, L = lambda x: len(split("[%s]" % x, p)), "A-Z", "a-z"

# Print the test result: `"OK."` if the `any(...)` function returned `False`, else `"Nope."`.
# The `any(...)` combines the result of all enclosed checks and returns `True` if at least
# one of the checks failed (returned `True`).
print(["OK.", "Nope."][any([                                # vvv--- CHECKS: ---vvv
                             8>len(p)>12,                   # password length 8-12
                             2>c(U)>9,                      # 1-8 uppercase letters
                             2>c(L)>9,                      # 1-8 lowercase letters
                             3>c(U+L),                      # at least 2 letters
                             match(U+L,p),                  # starts with a letter
                             2>c("0-9"),                    # at least 1 digit
                             n in p,                        # username is not (in) the pw.
                             n[::-1]in p,                   # reversed name not (in) the pw.
                             any(c(x)>3 for x in p),        # at most 3 same characters
                             len(findall("(.)\\1",p))>1,    # at most 1 pair (e.g. "AA")
                             c(' ^=&#,;"><[|)')>1])         # does not contain special char.
                           ])

आप इस समाधान को ideone.com पर पा सकते हैं , लेकिन आउटपुट थोड़ा बदसूरत लग रहा है क्योंकि यह पूर्वनिर्धारित इनपुट या यहां तक ​​कि लाइन ब्रेक नहीं दिखाता है। इसके अलावा, उपयोगकर्ता नाम-पासवर्ड संयोजन "JOE.smith"- "JOE!smith123"वर्तमान में निश्चित इनपुट डेटा के रूप में दर्ज किया गया है।
मैंने हालांकि डिबग आउटपुट के रूप में सभी चेक का ब्रेकडाउन जोड़ा।