Guide til Passay

1. Introduksjon

I dag har de fleste webapplikasjoner sin passordpolicy - som ganske enkelt er laget for å tvinge brukere til å lage vanskelige å bryte passord.

For å generere slike passord eller validere dem kan vi bruke Passay-biblioteket.

2. Maven avhengighet

Hvis vi vil bruke Passay-biblioteket i prosjektet vårt, er det nødvendig å legge til følgende avhengighet til vårt pom.xml:

 org.passay passay 1.3.1 

Vi finner den her.

3. Passordvalidering

Passordgodkjenning er en av to hovedfunksjoner levert av Passay-biblioteket. Det er uanstrengt og intuitivt. La oss oppdage det.

3.1. PasswordData

For å validere passordet vårt, bør vi bruke PasswordData. Det er en beholder for informasjon som er nødvendig for validering. Den kan lagre data som:

  • passord
  • brukernavn
  • liste over passordreferanser
  • opprinnelse

Egenskaper for passord og brukernavn forklarer seg selv. Passay bibliotek gir oss Historisk referanse og Kilde Referanse som vi kan legge til i listen over passordreferanser.

Vi kan bruke opprinnelsesfeltet til å holde informasjon om passordet ble generert eller definert av en bruker.

3.2. PasswordValidator

Vi burde vite at vi trenger PasswordData og PasswordValidator objekter for å starte validering av passord. Vi har allerede diskutert PasswordData. La oss lage PasswordValidator nå.

For det første bør vi definere et sett med regler for passordvalidering. Vi må overføre dem til konstruktøren mens vi lager en PasswordValidator gjenstand:

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

Det er to måter å overføre passordet vårt til PasswordData gjenstand. Vi sender den til enten konstruktøren eller settermetoden:

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

Vi kan validere passordet vårt ved å ringe validere() metode på PasswordValidator:

RuleResult validate = passwordValidator.validate (passwordData);

Som et resultat får vi en RuleResult gjenstand.

3.3. RuleResult

RuleResult har interessant informasjon om en valideringsprosess. Det kommer som et resultat av validere() metode.

Først og fremst kan den fortelle oss om passordet er gyldig:

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

Videre kan vi lære hvilke feil som returneres når passordet er ugyldig. Feilkoder og valideringsbeskrivelser holdes inne 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"));

Til slutt kan vi utforske passordvaliderings metadata med RuleResultMetadata:

Heltall lengthCount = valider .getMetadata () .getCounts () .get (RuleResultMetadata.CountCategory.Length); Assert.assertEquals (Integer.valueOf (4), lengthCount);

4. Passordgenerering

I tillegg til validering, har Passay biblioteket gjør at vi kan generere passord. Vi kan gi regler som generatoren skal bruke.

For å generere et passord, må vi ha et PasswordGenerator gjenstand. Når vi har det, kaller vi createPassword () metode og bestått liste over CharacterRules. Her er en eksempelkode:

CharacterRule sifre = nye CharacterRule (EnglishCharacterData.Digit); PasswordGenerator passwordGenerator = ny PasswordGenerator (); Strengpassord = passwordGenerator.generatePassword (10, sifre); Assert.assertTrue (password.length () == 10); Assert.assertTrue (inneholderOnlyCharactersFromSet (passord, "0123456789"));

Vi bør vite at vi trenger et objekt av CharacterData å lage CharacterRule. Et annet interessant faktum er at biblioteket gir oss Engelsk karakterdata. Det er en enum med fem sett med tegn:

  • sifre
  • små bokstaver engelsk alfabet
  • store bokstaver i engelsk
  • kombinasjon av små og store bokstaver
  • spesielle karakterer

Imidlertid kan ingenting hindre oss i å definere vårt sett med tegn. Det er like greit som å implementere CharacterData grensesnitt. La oss se hvordan vi kan gjø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 (); Strengpassord = passwordGenerator.generatePassword (10, specialCharacterRule); Assert.assertTrue (inneholderOnlyCharactersFromSet (passord, "[email protected] #"));

5. Positive samsvarsregler

Vi har allerede lært hvordan vi kan generere og validere passord. For å gjøre det, må vi definere et sett med regler. Av den grunn bør vi vite at det er to typer regler tilgjengelig i Passay: positive matchingsregler og negative matchingregler.

For det første, la oss finne ut hva som er de positive reglene og hvordan vi kan bruke dem.

Positive samsvaringsregler godtar passord som inneholder oppgitte tegn, regulære uttrykk eller passer inn i noen begrensninger.

Det er seks positive samsvaringsregler:

  • Tillatt karakterregel - definerer alle tegn som passordet må inneholde
  • TillattRegexRule - definerer et regulært uttrykk som passordet må matche
  • CharacterRule - definerer et tegnsett og et minimalt antall tegn som skal inkluderes i passordet
  • LengthRule - definerer en minimum lengde på passordet
  • Karakter Karakteristikk Regel - sjekker om passordet oppfyller N av definerte regler.
  • LengthComplexityRule - lar oss definere forskjellige regler for forskjellige passordlengder

5.1. Enkle positive regler for samsvar

Nå skal vi dekke alle reglene som har en enkel konfigurasjon. De definerer et sett med juridiske tegn eller mønstre eller et akseptabelt passordlengde.

Her er et kort eksempel på de diskuterte reglene:

PasswordValidator passwordValidator = nytt PasswordValidator (ny TillattCharacterRule (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 = inneholder}", getDetail (validere, 0)); assertEquals ("ALLOWED_CHAR: {illegalCharacter = 2, matchBehavior = inneholder}", getDetail (validere, 1)); assertEquals ("TOO_SHORT: {minimumLength = 8, maximumLength = 10}", getDetail (validate, 4));

Vi kan se at hver regel gir oss en klar forklaring hvis passordet ikke er gyldig. Det varsles om at passordet er for kort og har to ulovlige tegn. Vi kan også legge merke til at passordet ikke samsvarer med det oppgitte regulære uttrykket.

I tillegg får vi beskjed om at den inneholder utilstrekkelige små bokstaver.

5.2. KarakterCarakterisitcsRegel

CharcterCharacterisitcsRule er mer komplisert enn regler presentert før. Å lage en CharcterCharacterisitcsRule objekt, må vi gi en liste over CharacterRules. I tillegg må vi stille inn hvor mange av passordet må matche. Vi kan gjøre det på denne måten:

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

Presentert Karakter Karakteristikk Regel krever et passord for å inneholde tre av fire angitte regler.

5.3. LengthComplexityRule

På den andre siden, Passay biblioteket gir oss LengthComplexityRule. Det lar oss definere hvilke regler som skal brukes på passordet med hvilken lengde. I motsetning til Karakter Karakteristikk Regel, de tillater oss å bruke alle slags regler - ikke bare CharacterRule.

La oss analysere eksemplet:

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

Som vi kan se for passord som inneholder ett til fem tegn, bruker vi det CharacterRule. Men for et passord som inneholder seks til ti tegn, vil vi at passordet skal matche Tillatt karakterregel.

6. Negative samsvaringsregler

I motsetning til regler for positiv samsvar, avviser regler for negativ samsvar passord som inneholder oppgitte tegn, regulære uttrykk, oppføringer osv.

La oss finne ut hva som er de negative samsvaringsreglene:

  • Ulovlig karakterregel - definerer alle tegn som et passord ikke må inneholde
  • UlovligRegexRule - definerer et regulært uttrykk som ikke må matche
  • IllegalSequenceRule - sjekker om passordet har en ulovlig sekvens av tegn
  • NumberRangeRule - definerer en rekke tall som et passord ikke må inneholde
  • WhitespaceRule - sjekker om et passord inneholder mellomrom
  • DictionaryRule - sjekker om et passord er lik en ordbokspost
  • DictionarySubstringRule - sjekker om et passord inneholder noen ordboksposter
  • HistoryRule - sjekker om et passord inneholder noen historisk passordreferanser
  • DigestHistoryRule - sjekker om et passord inneholder noen fordøyd historisk passordreferanse
  • SourceRule - sjekker om et passord inneholder noen kildepassordreferanser
  • DigestSourceRule - sjekker om et passord inneholder referanse for fordøyelseskildepassord
  • BrukernavnRegel - sjekker om et passord inneholder et brukernavn
  • RepeatCharacterRegexRule - sjekker om et passord inneholder gjentatt ASCII tegn

6.1. Enkle negative regler for samsvar

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

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

Eksemplet viser oss hvordan de beskrevne reglene fungerer. På samme måte som positive matchingsregler, gir de oss full tilbakemelding om validering.

6.2. Ordbokregler

Hva om vi ønsker å sjekke om et passord ikke er lik oppgitte ord.

Av den grunn, Passay biblioteket gir oss gode verktøy for det. La oss oppdage 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 ordbokens regler som gjør det mulig for oss å gi en liste over utestengte ord. Det er gunstig når vi har en liste over de vanligste eller enkleste å bryte passord. Derfor er det rimelig å forby brukere å bruke dem.

I virkeligheten vil vi absolutt laste inn en liste med ord fra en tekstfil eller en database. I så fall kan vi bruke Ordlister. Den har tre overbelastede metoder som tar en rekke Lesers og lage ArrayWordList.

6.3. HistoryRule og SourceRule

Videre er den Passay biblioteket gir oss HistoryRule og SourceRule. De kan validere passord mot historiske passord eller tekstinnhold fra forskjellige kilder.

La oss ta en titt på eksemplet:

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

HistoryRules hjelpe oss med å sjekke om et passord har blitt brukt før. Fordi slik praksis er usikker, vil vi ikke at brukerne skal bruke gamle passord.

På den andre siden, SourceRule lar oss sjekke om passordet er annerledes enn det som er angitt i Kilde Referanser. Vi kan unngå risikoen for å ha de samme passordene i forskjellige systemer eller applikasjoner.

Det er verdt å nevne at det er slike regler som DigestSourceRule og DigestHistoryRule. Vi vil dekke dem i neste avsnitt.

6.4. Fordøyelsesregler

Det er to fordøyelsesregler i Passay bibliotek: DigestHistoryRule og DigestSourceRule. Fordøyelsesregler er ment å fungere med passord som er lagret som fordøyelse eller hasj. Derfor må vi gi en for å definere dem KodingHashBean gjenstand.

La oss se hvordan det gjøres:

Liste historiske referanser = Arrays.asList (ny PasswordData.HistoricalReference ("SHA256", "2e4551de804e27aacf20f9df5be3e8cd384ed64488b21ab079fb58e8c90068ab")); EncodingHashBean kodingHashBean = ny EncodingHashBean (ny CodecSpec ("Base64"), ny DigestSpec ("SHA256"), 1, falsk); 

Denne gangen skaper vi Historisk referanse av en etikett og det kodede passordet til konstruktøren. Etter det har vi instantiert KodingHashBean med riktig Codec og digest algoritme.

I tillegg kan vi spesifisere antall iterasjoner og om algoritmen er saltet.

Når vi har en kodende bønne, kan vi validere fordøyelsespassordet vårt:

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

Vi kan lære mer om KodingHashinBean på Cryptacular biblioteks webside.

6.5. RepeatCharacterRegexRule

En annen interessant valideringsregel er RepeatCharacterRegexRule. Vi kan bruke den til å sjekke om passordet inneholder gjentakelse ASCII tegn.

Her er en eksempelkode:

PasswordValidator passwordValidator = nytt 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. BrukernavnRegel

Den siste regelen vi skal diskutere i dette kapittelet er BrukernavnRegel. Det gjør det mulig for oss å forby bruk av brukerens navn i passordet.

Som vi har lært før, bør vi lagre brukernavnet i PasswordData:

PasswordValidator passwordValidator = nytt PasswordValidator (nytt brukernavn regel ()); PasswordData passwordData = nye PasswordData ("testbruker1234"); passwordData.setUsername ("testbruker"); RuleResult validate = passwordValidator.validate (passwordData); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_USERNAME: {brukernavn = testbruker, matchBehavior = inneholder}", getDetail (validere, 0));

7. Tilpassede meldinger

Passay biblioteket gjør det mulig for oss å tilpasse meldinger som returneres etter valideringsregler. For det første bør vi definere meldingene og tilordne dem til feilkoder.

Vi kan sette dem i en enkel fil. La oss se hvor enkelt det er:

TOO_LONG = Passordet må ikke ha flere tegn enn% 2 $ s. TOO_SHORT = Passordet må ikke inneholde mindre tegn enn% 2 $ s.

Når vi har meldinger, må vi laste den filen. Endelig kan vi gi den inn PasswordValidator gjenstand.

Her er en eksempelkode:

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

Som vi kan se, har vi lastet inn melding.egenskaper filen og sendte den til Eiendommer gjenstand. Deretter kan vi bruke Eiendommer objekt å lage PropertiesMessageResolver.

La oss se på eksemplet hvordan du bruker meldingsløseren:

PasswordValidator validator = new PasswordValidator (resolver, new LengthRule (8, 16), new WhitespaceRule ()); RuleResult tooShort = validator.validate (nye PasswordData ("XXXX")); RuleResult tooLong = validator.validate (ny PasswordData ("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ")); Assert.assertEquals ("Passordet må ikke inneholde færre tegn enn 16.", validator.getMessages (tooShort) .get (0)); Assert.assertEquals ("Passordet må ikke ha flere tegn enn 16.", validator.getMessages (tooLong) .get (0));

Eksemplet viser tydelig at vi kan oversette alle feilkoder med validatoren utstyrt med en meldingsløsning.

8. Konklusjon

I denne opplæringen har vi lært hvordan du bruker Passay bibliotek. Vi har analysert flere eksempler på hvordan biblioteket enkelt kan brukes til validering av passord. Medfølgende regler dekker de fleste vanlige måter å sikre at et passord er trygt.

Men vi bør huske at Passay-biblioteket i seg selv ikke gjør passordet vårt sikkert. For det første bør vi lære hva som er generelle regler, og deretter bruke biblioteket til å implementere dem.

Alle eksempler, som alltid, finner du på GitHub.