Vejledning til Passay

1. Introduktion

I dag har de fleste webapplikationer deres adgangskodepolitik - som simpelthen er oprettet for at tvinge brugere til at oprette vanskelige adgangskoder.

For at generere sådanne adgangskoder eller validere dem kan vi bruge Passay-biblioteket.

2. Maven-afhængighed

Hvis vi vil bruge Passay-biblioteket i vores projekt, er det nødvendigt at tilføje følgende afhængighed til vores pom.xml:

 org.passay passay 1.3.1 

Vi kan finde det her.

3. Validering af adgangskode

Validering af adgangskode er en af ​​to hovedfunktioner, der leveres af Passay-biblioteket. Det er ubesværet og intuitivt. Lad os opdage det.

3.1. PasswordData

For at validere vores adgangskode skal vi bruge PasswordData. Det er en container med oplysninger, der er nødvendige for validering. Det kan gemme sådanne data som:

  • adgangskode
  • brugernavn
  • liste over adgangskodereferencer
  • oprindelse

Egenskaber for adgangskode og brugernavn forklarer sig selv. Passay-biblioteket giver os Historisk henvisning og SourceReference som vi kan tilføje til listen over adgangskodereferencer.

Vi kan bruge oprindelsesfeltet til at indeholde oplysninger om, hvorvidt adgangskoden blev genereret eller defineret af en bruger.

3.2. PasswordValidator

Vi skal vide, at vi har brug for det PasswordData og PasswordValidator objekter til at starte validering af adgangskoder. Vi har allerede diskuteret PasswordData. Lad os skabe PasswordValidator nu.

For det første skal vi definere et sæt regler for adgangskodevalidering. Vi skal videregive dem til konstruktøren, mens vi opretter en PasswordValidator objekt:

PasswordValidator passwordValidator = ny PasswordValidator (ny LengthRule (5));

Der er to måder at videregive vores adgangskode til PasswordData objekt. Vi videregiver det til enten konstruktøren eller settermetoden:

PasswordData passwordData = nye PasswordData ("1234"); PasswordData passwordData2 = nye PasswordData (); passwordData.setPassword ("1234");

Vi kan validere vores adgangskode ved at ringe valider () metode til PasswordValidator:

RuleResult validate = passwordValidator.validate (passwordData);

Som et resultat får vi en RuleResult objekt.

3.3. RuleResult

RuleResult har interessante oplysninger om en valideringsproces. Det kommer som et resultat af valider () metode.

Først og fremmest kan det fortælle os, om adgangskoden er gyldig:

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

Desuden kan vi lære, hvilke fejl der returneres, når adgangskoden er ugyldig. Fejlkoder og valideringsbeskrivelser opbevares RuleResultDetail:

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

Endelig kan vi undersøge adgangskodevaliderings metadata med RuleResultMetadata:

Heltal længdeCount = valider .getMetadata () .getCounts () .get (RuleResultMetadata.CountCategory.Length); Assert.assertEquals (Integer.valueOf (4), lengthCount);

4. Generering af adgangskode

Ud over validering er Passay bibliotek giver os mulighed for at generere adgangskoder. Vi kan give regler, som generatoren skal bruge.

For at generere en adgangskode skal vi have en PasswordGenerator objekt. Når vi har det, kalder vi createPassword () metode og beståelsesliste over CharacterRules. Her er en prøvekode:

CharacterRule cifre = nye CharacterRule (EnglishCharacterData.Digit); PasswordGenerator passwordGenerator = ny PasswordGenerator (); Strengadgangskode = passwordGenerator.generatePassword (10, cifre); Assert.assertTrue (password.length () == 10); Assert.assertTrue (indeholderOnlyCharactersFromSet (adgangskode, "0123456789"));

Vi skal vide, at vi har brug for et objekt fra CharacterData at skabe CharacterRule. En anden interessant kendsgerning er, at biblioteket giver os Engelsk karakterdata. Det er en enum med fem sæt tegn:

  • cifre
  • små bogstaver engelsk alfabet
  • store bogstaver i engelsk alfabet
  • kombination af små og store bogstaver
  • specialtegn

Intet kan dog forhindre os i at definere vores sæt tegn. Det er lige så ligetil som at implementere CharacterData interface. Lad os se, hvordan vi kan gøre det:

CharacterRule specialCharacterRule = new CharacterRule (new CharacterData () {@Override public String getErrorCode () {return "SAMPLE_ERROR_CODE";} @ Override public String getCharacters () {return "[email protected] #";}}); PasswordGenerator passwordGenerator = ny PasswordGenerator (); Strengadgangskode = passwordGenerator.generatePassword (10, specialCharacterRule); Assert.assertTrue (indeholderOnlyCharactersFromSet (adgangskode, "[e-mailbeskyttet] #"));

5. Positive matchningsregler

Vi har allerede lært, hvordan vi kan generere og validere adgangskoder. For at gøre det skal vi definere et sæt regler. Af den grund skal vi vide, at der er to typer regler tilgængelige i Passay: positive matchningsregler og negative matchingregler.

Lad os først finde ud af, hvad der er de positive regler, og hvordan vi kan bruge dem.

Positive matchingsregler accepterer adgangskoder, der indeholder angivne tegn, regulære udtryk eller passer i nogle begrænsninger.

Der er seks positive matchningsregler:

  • Tilladt karakterregel - definerer alle tegn, som adgangskoden skal indeholde
  • TilladtRegexRule - definerer et regulært udtryk, som adgangskoden skal matche
  • CharacterRule - definerer et tegnsæt og et minimalt antal tegn, der skal inkluderes i adgangskoden
  • LengthRule - definerer en minimal længde af adgangskoden
  • Karakter Karakteristik Regel - kontrollerer, om adgangskoden opfylder N af definerede regler.
  • LengthComplexityRule - giver os mulighed for at definere forskellige regler for forskellige adgangskodelængder

5.1. Enkle positive matchende regler

Nu dækker vi alle de regler, der har en enkel konfiguration. De definerer et sæt juridiske tegn eller mønstre eller en acceptabel adgangskodelængde.

Her er et kort eksempel på de diskuterede regler:

PasswordValidator passwordValidator = ny PasswordValidator (ny TilladtCharacterRule (ny tegn [] {'a', 'b', 'c'}), ny CharacterRule (EnglishCharacterData.LowerCase, 5), ny LengthRule (8, 10)); RuleResult validate = passwordValidator.validate (new PasswordData ("12abc")); assertFalse (validate.isValid ()); assertEquals ("ALLOWED_CHAR: {illegalCharacter = 1, matchBehavior = indeholder}", getDetail (validere, 0)); assertEquals ("ALLOWED_CHAR: {illegalCharacter = 2, matchBehavior = indeholder}", getDetail (validere, 1)); assertEquals ("TOO_SHORT: {minimumLength = 8, maximumLength = 10}", getDetail (validate, 4));

Vi kan se, at hver regel giver os en klar forklaring, hvis adgangskoden ikke er gyldig. Der underrettes om, at adgangskoden er for kort og har to ulovlige tegn. Vi kan også bemærke, at adgangskoden ikke stemmer overens med det angivne regulære udtryk.

Derudover informeres vi om, at den indeholder utilstrækkelige små bogstaver.

5.2. TegnCarakterisitcsRegel

CharcterCharacterisitcsRule er mere kompleks end regler, der blev præsenteret før. At oprette en CharcterCharacterisitcsRule objekt, skal vi give en liste over CharacterRules. Hvad mere er, skal vi indstille, hvor mange af dem adgangskoden skal matche. Vi kan gøre det på denne måde:

CharacterCharacteristicsRule characterCharacteristicsRule = new CharacterCharacteristicsRule (3, new CharacterRule (EnglishCharacterData.LowerCase, 5), new CharacterRule (EnglishCharacterData.UpperCase, 5), new CharacterRule (EnglishCharacterData.Digit), new CharacterRule (EnglishCharacterata);

Forelagde Karakter Karakteristik Regel kræver en adgangskode til at indeholde tre af fire angivne regler.

5.3. LengthComplexityRule

På den anden side, Passay bibliotek giver os LengthComplexityRule. Det giver os mulighed for at definere, hvilke regler der skal anvendes på adgangskoden af ​​hvilken længde. I kontrast til Karakter Karakteristik Regel, de tillader os at bruge alle slags regler - ikke kun CharacterRule.

Lad os analysere eksemplet:

LengthComplexityRule lengthComplexityRule = ny LengthComplexityRule (); lengthComplexityRule.addRules ("[1,5]", ny CharacterRule (EnglishCharacterData.LowerCase, 5)); lengthComplexityRule.addRules ("[6,10]", ny TilladtCharacterRule (ny tegn [] {'a', 'b', 'c', 'd'}));

Som vi kan se for en adgangskode med et til fem tegn, anvender vi CharacterRule. Men for en adgangskode, der indeholder seks til ti tegn, ønsker vi, at adgangskoden skal matche Tilladt karakterregel.

6. Negative matchningsregler

I modsætning til regler for positiv matchning afviser regler for negativ matchning adgangskoder, der indeholder angivne tegn, regulære udtryk, poster osv.

Lad os finde ud af, hvad der er de negative matchningsregler:

  • Ulovlig karakterregel - definerer alle tegn, som en adgangskode ikke må indeholde
  • UlovligRegexRule - definerer et regulært udtryk, som ikke må matche
  • IllegalSequenceRule - kontrollerer, om en adgangskode har en ulovlig rækkefølge af tegn
  • NumberRangeRule - definerer en række numre, som et kodeord ikke må indeholde
  • Hvidrumsregel - kontrollerer, om en adgangskode indeholder mellemrum
  • DictionaryRule - kontrollerer, om en adgangskode er lig med en ordbogspost
  • DictionarySubstringRule - kontrollerer, om en adgangskode indeholder en ordbogspost
  • HistoryRule - kontrollerer, om en adgangskode indeholder en historisk adgangskodereference
  • DigestHistoryRule - kontrollerer, om en adgangskode indeholder en fordøjet historisk adgangskodereference
  • SourceRule - kontrollerer, om en adgangskode indeholder en kildeadgangskodehenvisning
  • DigestSourceRule - kontrollerer, om en adgangskode indeholder nogen referat til fordøjelseskildeadgangskoden
  • UsernameRule - kontrollerer, om en adgangskode indeholder et brugernavn
  • GentagCharacterRegexRule - kontrollerer, om en adgangskode indeholder gentaget ASCII tegn

6.1. Enkle negative matchende regler

For det første skal vi se, hvordan vi kan bruge enkle regler som f.eks Ulovlig karakterregel, UlovligRegexRuleosv. Her er et kort eksempel:

PasswordValidator passwordValidator = nyt PasswordValidator (nyt IllegalCharacterRule (nyt tegn [] {'a'}), nyt NumberRangeRule (1, 10), nyt WhitespaceRule ()); RuleResult validate = passwordValidator.validate (new PasswordData ("abcd22")); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_CHAR: {illegalCharacter = a, matchBehavior = indeholder}", getDetail (validere, 0)); assertEquals ("ILLEGAL_NUMBER_RANGE: {number = 2, matchBehavior = indeholder}", getDetail (valider, 4)); assertEquals ("ILLEGAL_WHITESPACE: {whitespaceCharacter =, matchBehavior = indeholder}", getDetail (valider, 5));

Eksemplet viser os, hvordan de beskrevne regler fungerer. På samme måde som positive matchningsregler giver de os fuld feedback om validering.

6.2. Ordbog regler

Hvad hvis vi vil kontrollere, om en adgangskode ikke svarer til de angivne ord.

Af den grund er den Passay biblioteket giver os fremragende værktøjer til det. Lad os opdage DictionaryRule og DictionarySubstringRule:

WordListDictionary wordListDictionary = ny WordListDictionary (ny ArrayWordList (ny streng [] {"bar", "foobar"})); DictionaryRule dictionaryRule = ny DictionaryRule (wordListDictionary); DictionarySubstringRule dictionarySubstringRule = ny DictionarySubstringRule (wordListDictionary);

Vi kan se ordbogens regler gør det muligt for os at give en liste over forbudte ord. Det er gavnligt, når vi har en liste over de mest almindelige eller de nemmeste at bryde adgangskoder. Derfor er det rimeligt at forbyde brugere at bruge dem.

I det virkelige liv ville vi helt sikkert indlæse en liste med ord fra en tekstfil eller en database. I så fald kan vi bruge Ordlister. Det har tre overbelastede metoder, der tager en række Læsers og opret ArrayWordList.

6.3. HistoryRule og SourceRule

Desuden er den Passay bibliotek giver os HistoryRule og SourceRule. De kan validere adgangskoder mod historiske adgangskoder eller tekstindhold fra forskellige kilder.

Lad os se på eksemplet:

SourceRule sourceRule = ny SourceRule (); HistoryRule historyRule = ny HistoryRule (); PasswordData passwordData = nye PasswordData ("123"); passwordData.setPasswordReferences (nyt PasswordData.SourceReference ("kilde", "kodeord"), nyt PasswordData.HistoricalReference ("12345")); PasswordValidator passwordValidator = ny PasswordValidator (historyRule, sourceRule);

HistorieRegler hjælp os med at kontrollere, om en adgangskode har været brugt før. Da sådan praksis er usikker, ønsker vi ikke, at brugerne bruger gamle adgangskoder.

På den anden side, SourceRule giver os mulighed for at kontrollere, om adgangskoden er forskellig fra dem, der er angivet i SourceReferences. Vi kan undgå risikoen for at have de samme adgangskoder i forskellige systemer eller applikationer.

Det er værd at nævne, at der er sådanne regler som DigestSourceRule og DigestHistoryRule. Vi dækker dem i næste afsnit.

6.4. Fordøjelsesregler

Der er to fordøjelsesregler i Passay bibliotek: DigestHistoryRule og DigestSourceRule. Fordøjelsesregler er beregnet til at arbejde med adgangskoder, der er gemt som fordøjelse eller hash. Derfor skal vi definere dem for at definere dem KodningHashBean objekt.

Lad os se, hvordan det er gjort:

Liste historiskReferencer = Arrays.asList (nyt PasswordData.HistoricalReference ("SHA256", "2e4551de804e27aacf20f9df5be3e8cd384ed64488b21ab079fb58e8c90068ab")); EncodingHashBean encodingHashBean = ny EncodingHashBean (ny CodecSpec ("Base64"), ny DigestSpec ("SHA256"), 1, falsk); 

Denne gang skaber vi Historisk henvisning ved hjælp af en etiket og det kodede kodeord til konstruktøren. Derefter har vi instantificeret KodningHashBean med den rigtige Codec og digest algoritme.

Derudover kan vi specificere antallet af iterationer, og om algoritmen er saltet.

Når vi har en kodende bønne, kan vi validere vores fordøjelsesadgangskode:

PasswordData passwordData = nye PasswordData ("eksempel!"); passwordData.setPasswordReferences (historicalReferences); PasswordValidator passwordValidator = ny PasswordValidator (ny DigestHistoryRule (kodning af HashBean)); RuleResult validate = passwordValidator.validate (passwordData); Assert.assertTrue (validate.isValid ());

Vi kan lære mere om Kodning af HashinBean på Cryptacular biblioteks webside.

6.5. GentagCharacterRegexRule

En anden interessant valideringsregel er GentagCharacterRegexRule. Vi kan bruge den til at kontrollere, om adgangskoden indeholder gentagelse ASCII tegn.

Her er en prøvekode:

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

6.6. UsernameRule

Den sidste regel, vi skal diskutere i dette kapitel, er UsernameRule. Det giver os mulighed for at forbyde at bruge brugerens navn i adgangskoden.

Som vi har lært før, skal vi gemme brugernavnet i PasswordData:

PasswordValidator passwordValidator = nyt PasswordValidator (nyt brugernavn regel ()); PasswordData passwordData = nye PasswordData ("testbruger1234"); passwordData.setUsername ("testbruger"); RuleResult validate = passwordValidator.validate (passwordData); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_USERNAME: {username = testuser, matchBehavior = contain}", getDetail (validate, 0));

7. Tilpassede meddelelser

Passay bibliotek giver os mulighed for at tilpasse beskeder, der returneres efter valideringsregler. For det første skal vi definere meddelelserne og tildele dem til fejlkoder.

Vi kan sætte dem i en simpel fil. Lad os se, hvor let det er:

TOO_LONG = Adgangskoden må ikke have flere tegn end% 2 $ s. TOO_SHORT = Adgangskode må ikke indeholde mindre tegn end% 2 $ s.

Når vi først har beskeder, skal vi indlæse den fil. Endelig kan vi give det videre PasswordValidator objekt.

Her er en prøvekode:

URL-ressource = this.getClass (). GetClassLoader (). GetResource ("messages.properties"); Egenskaber rekvisitter = nye egenskaber (); props.load (ny FileInputStream (resource.getPath ())); MessageResolver resolver = nye PropertiesMessageResolver (rekvisitter); 

Som vi kan se, har vi indlæst besked. ejendomme fil og overførte den til Ejendomme objekt. Derefter kan vi bruge Ejendomme objekt at skabe PropertiesMessageResolver.

Lad os se på eksemplet, hvordan du bruger meddelelsesopløseren:

PasswordValidator validator = ny PasswordValidator (resolver, ny LengthRule (8, 16), ny WhitespaceRule ()); RuleResult tooShort = validator.validate (nye PasswordData ("XXXX")); RuleResult tooLong = validator.validate (nyt PasswordData ("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ")); Assert.assertEquals ("Adgangskoden må ikke indeholde færre tegn end 16.", validator.getMessages (tooShort) .get (0)); Assert.assertEquals ("Adgangskoden må ikke have flere tegn end 16.", validator.getMessages (tooLong) .get (0));

Eksemplet viser tydeligt, at vi kan oversætte alle fejlkoder med validatoren udstyret med en meddelelsesopløsning.

8. Konklusion

I denne vejledning har vi lært, hvordan man bruger Passay bibliotek. Vi har analyseret flere eksempler på, hvordan biblioteket let kan bruges til validering af adgangskode. Medfølgende regler dækker de fleste af de almindelige måder at sikre, at en adgangskode er sikker.

Men vi skal huske, at Passay-biblioteket i sig selv ikke gør vores adgangskode sikkert. For det første skal vi lære, hvad der er generelle regler, og derefter bruge biblioteket til at implementere dem.

Alle eksempler kan som altid findes på GitHub.