מדריך לפסאי

1. הקדמה

כיום, לרוב יישומי האינטרנט יש את מדיניות הסיסמאות שלהם - שהיא, במילים פשוטות, נוצרה כדי לאלץ משתמשים ליצור סיסמאות שקשורות להפסקה.

כדי ליצור סיסמאות כאלה או לאמתן נוכל להשתמש בספריית Passay.

2. תלות של Maven

אם אנו רוצים להשתמש בספריית Passay בפרויקט שלנו, יש צורך להוסיף את התלות הבאה שלנו pom.xml:

 org.passay מעבר 1.3.1 

אנחנו יכולים למצוא את זה כאן.

3. אימות סיסמא

אימות סיסמא הוא אחת משתי הפונקציות העיקריות המסופקות על ידי ספריית Passay. זה לא מתאמץ ואינטואיטיבי. בואו נגלה את זה.

3.1. סיסמת נתונים

כדי לאמת את הסיסמה שלנו, עלינו להשתמש סיסמת נתונים. זהו מיכל למידע הדרוש לאימות. הוא יכול לאחסן נתונים כמו:

  • סיסמה
  • שם משתמש
  • רשימת הפניות לסיסמאות
  • מָקוֹר

מאפייני סיסמא ושם משתמש מסבירים את עצמם. ספריית פסאי נותנת לנו התייחסות היסטורית ו SourceReference שנוכל להוסיף לרשימת הפניות לסיסמאות.

אנו יכולים להשתמש בשדה המקור בכדי להחזיק מידע האם הסיסמה נוצרה או הוגדרה על ידי משתמש.

3.2. אימות סיסמאות

עלינו לדעת שאנחנו צריכים סיסמת נתונים ו אימות סיסמאות אובייקטים להתחיל לאמת סיסמאות. כבר דנו סיסמת נתונים. בואו ניצור אימות סיסמאות עַכשָׁיו.

ראשית, עלינו להגדיר סט כללים לאימות סיסמא. עלינו להעביר אותם לבנאי תוך כדי יצירת a אימות סיסמאות לְהִתְנַגֵד:

PasswordValidator passwordValidator = PasswordValidator חדש (LengthRule חדש (5));

ישנן שתי דרכים להעביר את הסיסמה שלנו ל- סיסמת נתונים לְהִתְנַגֵד. אנו מעבירים את זה לבנאי או לשיטת הקובעים:

PasswordData passwordData = PasswordData חדש ("1234"); PasswordData passwordData2 = PasswordData חדש (); passwordData.setPassword ("1234");

אנו יכולים לאמת את הסיסמה שלנו על ידי התקשרות לְאַמֵת() שיטה ב אימות סיסמאות:

RuleResult validate = passwordValidator.validate (passwordData);

כתוצאה מכך נקבל RuleResult לְהִתְנַגֵד.

3.3. RuleResult

RuleResult מחזיק מידע מעניין אודות תהליך אימות. זה בא כתוצאה מה- לְאַמֵת() שיטה.

קודם כל, זה יכול לומר לנו אם הסיסמה תקפה:

Assert.assertEquals (false, validate.isValid ());

יתר על כן, אנו יכולים ללמוד אילו שגיאות מוחזרות כאשר הסיסמה אינה חוקית. קודי שגיאה ותיאורי אימות נשמרים RuleResultDetail:

RuleResultDetail ruleResultDetail = validate.getDetails (). Get (0); Assert.assertEquals ("TOO_SHORT", ruleResultDetail.getErrorCode ()); Assert.assertEquals (5, ruleResultDetail.getParameters (). Get ("minimumLength")); Assert.assertEquals (5, ruleResultDetail.getParameters (). Get ("maximumLength"));

לבסוף, אנו יכולים לחקור את המטא נתונים של אימות הסיסמה באמצעות RuleResultMetadata:

מספר שלם lengthCount = אמת .getMetadata () .getCounts () .get (RuleResultMetadata.CountCategory.Length); Assert.assertEquals (Integer.valueOf (4), lengthCount);

4. יצירת סיסמאות

בנוסף לאימות, ה- פסאי הספרייה מאפשרת לנו ליצור סיסמאות. אנו יכולים לספק כללים שבהם הגנרטור צריך להשתמש.

כדי ליצור סיסמה, עלינו להיות עם מחולל סיסמאות לְהִתְנַגֵד. ברגע שיש לנו את זה, אנו קוראים createPassword () שיטה ורשימת מעבר של CharacterRules. הנה קוד לדוגמא:

ספרות CharacterRule = CharacterRule חדש (EnglishCharacterData.Digit); PasswordGenerator passwordGenerator = PasswordGenerator חדש (); סיסמת מחרוזת = passwordGenerator.generatePassword (10, ספרות); Assert.assertTrue (password.length () == 10); Assert.assertTrue (containOnlyCharactersFromSet (סיסמה, "0123456789"));

עלינו לדעת שאנחנו צריכים אובייקט של CharacterData ליצור CharacterRule. עובדה מעניינת נוספת היא שהספרייה מספקת לנו אנגלית CharacterData. זהו אנום של חמש סטים של דמויות:

  • ספרות
  • אלפבית אנגלי באותיות קטנות
  • אלפבית אנגלי גדול
  • שילוב של קבוצות קטנות וקטנות
  • תווים מיוחדים

עם זאת, שום דבר לא יכול למנוע מאיתנו להגדיר את קבוצת הדמויות שלנו. זה פשוט כמו יישום ה- CharacterData מִמְשָׁק. בואו נראה איך אנחנו יכולים לעשות את זה:

CharacterRule specialCharacterRule = CharacterRule חדש (CharacterData חדש) {@Override public String getErrorCode () {return "SAMPLE_ERROR_CODE";} @Override public String getCharacters () {return "[email protected] #";}}); PasswordGenerator passwordGenerator = PasswordGenerator חדש (); סיסמת מחרוזת = passwordGenerator.generatePassword (10, specialCharacterRule); Assert.assertTrue (containOnlyCharactersFromSet (סיסמה, "[דוא"ל מוגן] #"));

5. כללי התאמה חיוביים

כבר למדנו כיצד אנו יכולים ליצור ולאמת סיסמאות. לשם כך עלינו להגדיר מערכת כללים. מסיבה זו, עלינו לדעת שיש שני סוגים של כללים פסאי: כללי התאמה חיובית וכללי התאמה שליליים.

ראשית, בואו לגלות מהם הכללים החיוביים וכיצד נוכל להשתמש בהם.

כללי התאמה חיוביים מקבלים סיסמאות המכילות תווים מסופקים, ביטויים רגולריים או משתנים במגבלות מסוימות.

ישנם שישה כללי התאמה חיוביים:

  • מותר CharacterRule - מגדיר את כל התווים שעל הסיסמה לכלול
  • מותר RegegexRule - מגדיר ביטוי קבוע שהסיסמה חייבת להתאים לו
  • CharacterRule - מגדיר ערכת תווים ומספר מינימלי של תווים שיש לכלול בסיסמה
  • LengthRule - מגדיר אורך מינימלי של הסיסמה
  • אופי מאפיינים כלל - בודק אם הסיסמה ממלאת נ של כללים מוגדרים.
  • אורך מורכבות כלל - מאפשר לנו להגדיר כללים שונים לאורכי סיסמא שונים

5.1. כללי התאמה חיוביים פשוטים

כעת נסקור את כל הכללים עם תצורה פשוטה. הם מגדירים סט של תווים או דפוסים משפטיים או אורך סיסמא מקובל.

הנה דוגמה קצרה לכללים הנדונים:

PasswordValidator passwordValidator = סיסמה חדשה Validator (מותר חדשCharacterRule (תו חדש [] {'a', 'b', 'c'}), CharacterRule חדש (אנגלית CharacterData.LowerCase, 5), חדש LengthRule (8, 10)); RuleResult validate = passwordValidator.validate (PasswordData חדש ("12abc")); assertFalse (validate.isValid ()); assertEquals ("ALLOWED_CHAR: {illegalCharacter = 1, matchBehavior = contains}", getDetail (validate, 0)); assertEquals ("ALLOWED_CHAR: {illegalCharacter = 2, matchBehavior = contains}", getDetail (validate, 1)); assertEquals ("TOO_SHORT: {minimumLength = 8, maximumLength = 10}", getDetail (validate, 4));

אנו יכולים לראות כי כל כלל נותן לנו הסבר ברור אם הסיסמה אינה חוקית. ישנן התראות שהסיסמה קצרה מדי ויש לה שני תווים לא חוקיים. אנו יכולים גם לשים לב שהסיסמה אינה תואמת את הביטוי הרגולרי שסופק.

יתרה מכך, התבשרנו שהוא מכיל לא מספיק אותיות קטנות.

5.2. אופי Characterisitcs כלל

Charcter Characterisitcs כלל מורכב יותר מכללים שהוצגו לפני כן. ליצור Charcter Characterisitcs כלל אנחנו צריכים לספק רשימה של CharacterRuleס. יתרה מכך, עלינו להגדיר לכמה מהם הסיסמה חייבת להתאים. אנחנו יכולים לעשות זאת בדרך זו:

CharacterCharacteristicsRule characterCharacteristicsRule = CharacterCharacteristicsRule חדש (3, CharacterRule חדש (EnglishCharacterData.LowerCase, 5), CharacterRule חדש (EnglishCharacterData. UpperCase, 5), CharacterRule חדש (EnglishCharacterData.Digit), CharacterRule חדש (EnglishCharacterData).

הוצג אופי מאפיינים כלל דורש סיסמה שתכיל שלושה מתוך ארבעה כללים שסופקו.

5.3. אורך מורכבות כלל

מצד שני, פסאי הספרייה מספקת לנו אורך מורכבות כלל. זה מאפשר לנו להגדיר אילו כללים יש להחיל על הסיסמה באורך. בניגוד ל אופי מאפיינים כללהם מאפשרים לנו להשתמש בכל מיני כללים - לא רק CharacterRule.

בואו ננתח את הדוגמה:

LengthComplexityRule lengthComplexityRule = LengthComplexityRule חדש (); lengthComplexityRule.addRules ("[1,5]", CharacterRule חדש (EnglishCharacterData.LowerCase, 5)); lengthComplexityRule.addRules ("[6,10]", חדש מותר CharacterRule (תו חדש [] {'a', 'b', 'c', 'd'}));

כפי שאנו רואים עבור סיסמה הכוללת אחד עד חמש תווים, אנו מיישמים CharacterRule. אך עבור סיסמה המכילה בין שש לעשרה תווים, אנו רוצים שהסיסמה תתאים מותר CharacterRule.

6. כללי התאמה שליליים

שלא כמו כללי התאמה חיוביים, כללי התאמה שליליים דוחים סיסמאות המכילות תווים שסופקו, ביטויים רגילים, ערכים וכו '.

בואו נגלה מהם כללי ההתאמה השליליים:

  • חוק לא חוקי - מגדיר את כל התווים שאסור להכיל סיסמה
  • IllegalRegexRule - מגדיר ביטוי רגולרי שאסור לו להתאים
  • IllegalSequenceRule - בודק אם לסיסמה יש רצף לא חוקי של תווים
  • NumberRangeRule - מגדיר טווח מספרים שאסור להכיל בסיסמה
  • WhitespaceRule - בודק אם סיסמה מכילה רווחים לבנים
  • DictionaryRule - בודק אם סיסמה שווה לכל רשומת מילון
  • DictionarySubstringRule - בודק אם סיסמה מכילה רשומת מילון כלשהי
  • היסטוריה שלטון - בודק אם סיסמה מכילה התייחסות סיסמא היסטורית כלשהי
  • DigestHistoryRule - בודק אם סיסמה מכילה התייחסות סיסמא היסטורית מעוכלת כלשהי
  • SourceRule - בודק אם סיסמה מכילה הפניה כלשהי לסיסמת המקור
  • DigestSourceRule - בודק אם סיסמה מכילה התייחסות לסיסמת מקור לעיכול
  • UsernameRule - בודק אם סיסמה מכילה שם משתמש
  • חזור על CharacterRegexRule - בודק אם סיסמה מכילה חוזרת ASCII תווים

6.1. כללי התאמה שליליים פשוטים

ראשית, אנו הולכים לראות כיצד נוכל להשתמש בכללים פשוטים כגון חוק לא חוקי, IllegalRegexRuleוכו 'הנה דוגמה קצרה:

PasswordValidator passwordValidator = PasswordValidator חדש (IllegalCharacterRule חדש (תו חדש [] {'a'}), NumberRangeRule חדש (1, 10), WhitespaceRule חדש ()); RuleResult validate = passwordValidator.validate (סיסמת נתונים חדשה ("abcd22")); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_CHAR: {illegalCharacter = a, matchBehavior = contains}", getDetail (validate, 0)); assertEquals ("ILLEGAL_NUMBER_RANGE: {number = 2, matchBehavior = contains}", getDetail (validate, 4)); assertEquals ("ILLEGAL_WHITESPACE: {whitespaceCharacter =, matchBehavior = מכיל}", getDetail (תקף, 5));

הדוגמה מראה לנו כיצד פועלים הכללים המתוארים. בדומה לכללי התאמה חיוביים, הם נותנים לנו משוב מלא לגבי אימות.

6.2. כללי מילון

מה אם נרצה לבדוק אם סיסמה אינה שווה למילים שסופקו.

מסיבה זו, פסאי הספרייה נותנת לנו כלים מצוינים לכך. בואו נגלה DictionaryRule ו DictionarySubstringRule:

WordListDictionary wordListDictionary = חדש WordListDictionary (ArrayWordList חדש (מחרוזת חדשה [] {"סרגל", "foobar"})); DictionaryRule dictionaryRule = new DictionaryRule (wordListDictionary); DictionarySubstringRule dictionarySubstringRule = new DictionarySubstringRule (wordListDictionary);

אנו יכולים לראות כללי מילון מאפשרים לנו לספק רשימה של מילים אסורות. זה מועיל כשיש לנו רשימה של הסיסמאות הנפוצות ביותר או הקלות ביותר לשבירה. לכן, סביר לאסור על משתמשים להשתמש בהם.

בחיים האמיתיים, בוודאי נטען רשימת מילים מקובץ טקסט או ממסד נתונים. במקרה כזה, אנו יכולים להשתמש רשימות מילים. יש לו שלוש שיטות עמוסות הכוללות מגוון של קוֹרֵאs וליצור ArrayWordList.

6.3. היסטוריה שלטון ו SourceRule

יתר על כן, ה פסאי הספרייה נותנת לנו היסטוריה שלטון ו SourceRule. הם יכולים לאמת סיסמאות מול סיסמאות היסטוריות או תוכן טקסט ממקורות שונים.

בואו נסתכל על הדוגמה:

SourceRule sourceRule = SourceRule חדש (); HistoryRule historyRule = חדש HistoryRule (); PasswordData passwordData = PasswordData חדש ("123"); passwordData.setPasswordReferences (PasswordData.SourceReference חדש ("מקור", "סיסמה"), PasswordData.HistoricalReference חדש ("12345")); PasswordValidator passwordValidator = PasswordValidator חדש (historyRule, sourceRule);

היסטוריה שולט עזור לנו לבדוק אם סיסמא שימשה בעבר. מכיוון ששיטות עבודה כאלה אינן מאובטחות, איננו רוצים שמשתמשים ישתמשו בסיסמאות ישנות.

מצד שני, SourceRule מאפשר לנו לבדוק אם הסיסמה שונה מאלו המופיעות בה מקור הפניות. אנו יכולים למנוע את הסיכון שיש אותן סיסמאות במערכות או ביישומים שונים.

ראוי להזכיר שיש כללים כמו DigestSourceRule ו DigestHistoryRule. נסקור אותם בפסקה הבאה.

6.4. כללי עיכול

ישנם שני כללי עיכול ב פסאי סִפְרִיָה: DigestHistoryRule ו DigestSourceRule. כללי העיכול נועדו לעבוד עם סיסמאות המאוחסנות כעיכול או חשיש. לפיכך, כדי להגדיר אותם עלינו לספק קידוד HashBean לְהִתְנַגֵד.

בואו נראה איך זה נעשה:

רשימת היסטורי-הפניות = Arrays.asList (PasswordData.HistoricalReference חדש ("SHA256", "2e4551de804e27aacf20f9df5be3e8cd384ed64488b21ab079fb58e8c90068ab")); EncodingHashBean encodingHashBean = EncodingHashBean חדש (CodecSpec חדש ("Base64"), DigestSpec חדש ("SHA256"), 1, שקר); 

הפעם אנו יוצרים התייחסות היסטורית על ידי תווית והסיסמה המקודדת לבנאי. אחרי זה, יצרנו רגע קידוד HashBean עם אלגוריתם ה- Codec והעיכול המתאים.

בנוסף, אנו יכולים לציין את מספר האיטרציות והאם האלגוריתם מומלח.

ברגע שיש לנו שעועית קידוד, אנו יכולים לאמת את סיסמת העיכול שלנו:

PasswordData passwordData = PasswordData חדש ("דוגמא!"); passwordData.setPasswordReferences (historicalReferences); PasswordValidator passwordValidator = PasswordValidator חדש (DigestHistoryRule חדש (encodingHashBean)); RuleResult validate = passwordValidator.validate (passwordData); Assert.assertTrue (validate.isValid ());

אנחנו יכולים ללמוד עוד על קידוד HashinBean בדף האינטרנט של הספרייה Cryptacular.

6.5. חזור על CharacterRegexRule

כלל אימות מעניין נוסף הוא חזור על CharacterRegexRule. אנו יכולים להשתמש בו כדי לבדוק אם הסיסמה מכילה חזרה ASCII תווים.

הנה קוד לדוגמא:

PasswordValidator passwordValidator = חדש PasswordValidator (חדש RepeatCharacterRegexRule (3)); RuleResult validate = passwordValidator.validate (PasswordData חדש ("aaabbb")); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_MATCH: {match = aaa, pattern = ([^ \ x00 - \ x1F]) \ 1 {2}}", getDetail (validate, 0));

6.6. UsernameRule

הכלל האחרון שעליו נדון בפרק זה הוא UsernameRule. זה מאפשר לנו לאסור להשתמש בשם המשתמש בסיסמה.

כפי שלמדנו בעבר, עלינו לאחסן את שם המשתמש ב סיסמת נתונים:

PasswordValidator passwordValidator = PasswordValidator חדש (UsernameRule חדש ()); PasswordData passwordData = PasswordData חדש ("testuser1234"); passwordData.setUsername ("testuser"); RuleResult validate = passwordValidator.validate (passwordData); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_USERNAME: {username = testuser, matchBehavior = contains}", getDetail (validate, 0));

7. הודעות מותאמות אישית

פסאי הספרייה מאפשרת לנו להתאים אישית הודעות שהוחזרו לפי כללי אימות. ראשית, עלינו להגדיר את ההודעות ולהקצות אותן לקודי שגיאה.

אנחנו יכולים להכניס אותם לקובץ פשוט. בואו נראה כמה זה קל:

TOO_LONG = אסור להכיל סיסמה יותר תווים מ-% 2 $ s. TOO_SHORT = הסיסמה לא יכולה להכיל פחות תווים מ-% 2 $ s.

ברגע שיש לנו הודעות, עלינו לטעון את הקובץ הזה. לבסוף, נוכל להעביר אותו פנימה אימות סיסמאות לְהִתְנַגֵד.

הנה קוד לדוגמא:

URL URL = this.getClass (). GetClassLoader (). GetResource ("messages.properties"); אביזרי מאפיינים = מאפיינים חדשים (); props.load (FileInputStream חדש (resource.getPath ())); MessageResolver resolver = new PropertiesMessageResolver (props); 

כפי שאנו רואים, העמסנו את message.properties קובץ והעבירו אותו אל נכסים לְהִתְנַגֵד. ואז נוכל להשתמש ב- נכסים אובייקט ליצור PropertiesMessageResolver.

בואו נסתכל על הדוגמה כיצד להשתמש בפותר ההודעות:

Validator PasswordValidator = PasswordValidator חדש (resolver, LengthRule חדש (8, 16), WhitespaceRule חדש ()); RuleResult tooShort = validator.validate (סיסמת נתונים חדשה ("XXXX")); RuleResult tooLong = validator.validate (סיסמת נתונים חדשה ("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ)); Assert.assertEquals ("הסיסמה לא יכולה להכיל פחות תווים מ- 16.", validator.getMessages (tooShort) .get (0)); Assert.assertEquals ("הסיסמה לא יכולה להכיל יותר תווים מ- 16.", validator.getMessages (tooLong) .get (0));

הדוגמה מראה בבירור שנוכל לתרגם את כל קודי השגיאה באמצעות המאמת המצויד במפתור הודעות.

8. מסקנה

במדריך זה למדנו כיצד להשתמש פסאי סִפְרִיָה. ניתחנו כמה דוגמאות כיצד ניתן להשתמש בספריה בקלות לאימות סיסמאות. כללים מסופקים מכסים את רוב הדרכים הנפוצות להבטיח כי סיסמה בטוחה.

אך עלינו לזכור שספריית Passay עצמה אינה מאבטחת את הסיסמה שלנו. ראשית, עלינו ללמוד מהם הכללים הכלליים ואז להשתמש בספרייה כדי ליישם אותם.

את כל הדוגמאות, כמו תמיד, ניתן למצוא באתר GitHub.


$config[zx-auto] not found$config[zx-overlay] not found