streamalism.org

1. Inleiding

Tegenwoordig hebben de meeste webapplicaties hun wachtwoordbeleid - dat is, simpel gezegd, gemaakt om gebruikers te dwingen moeilijk te breken wachtwoorden te maken.

Om dergelijke wachtwoorden te genereren of te valideren, kunnen we gebruik maken van de Passay-bibliotheek.

2. Maven Afhankelijkheid

Als we de Passay-bibliotheek in ons project willen gebruiken, is het noodzakelijk om de volgende afhankelijkheid toe te voegen aan onze pom.xml:

 org.passay passay 1.3.1 

We kunnen het hier vinden.

3. Wachtwoordvalidatie

Wachtwoordvalidatie is een van de twee belangrijkste functionaliteiten van de Passay-bibliotheek. Het is moeiteloos en intuïtief. Laten we het ontdekken.

3.1. Wachtwoordgegevens

Om ons wachtwoord te valideren, moeten we gebruiken Wachtwoordgegevens. Het is een container voor informatie die nodig is voor validatie. Het kan gegevens opslaan zoals:

• wachtwoord
• gebruikersnaam
• lijst met wachtwoordreferenties
• oorsprong

Wachtwoord- en gebruikersnaameigenschappen verklaren zichzelf. Passay-bibliotheek geeft ons Historische referentie en Bronreferentie die we kunnen toevoegen aan de lijst met wachtwoordreferenties.

We kunnen het oorsprongveld gebruiken om informatie te bewaren over of het wachtwoord is gegenereerd of gedefinieerd door een gebruiker.

3.2. WachtwoordValidator

We moeten weten dat we het nodig hebben Wachtwoordgegevens en WachtwoordValidator objecten om wachtwoorden te valideren. We hebben het al besproken Wachtwoordgegevens. Laten we creëren WachtwoordValidator nu.

Ten eerste moeten we een reeks regels definiëren voor wachtwoordvalidatie. We moeten ze doorgeven aan de constructor tijdens het maken van een WachtwoordValidator voorwerp:

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

Er zijn twee manieren om ons wachtwoord door te geven aan een Wachtwoordgegevens voorwerp. We geven het door aan de constructor of de setter-methode:

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

We kunnen ons wachtwoord valideren door te bellen valideren () methode op WachtwoordValidator:

RuleResult validate = passwordValidator.validate (passwordData);

Als resultaat krijgen we een RuleResult voorwerp.

3.3. RuleResult

RuleResult bevat interessante informatie over een validatieproces. Het komt als resultaat van de valideren () methode.

Allereerst kan het ons vertellen of het wachtwoord geldig is:

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

Bovendien kunnen we leren welke fouten worden geretourneerd als het wachtwoord ongeldig is. Foutcodes en validatiebeschrijvingen worden bewaard in 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"));

Ten slotte kunnen we de metadata van de wachtwoordvalidatie verkennen met RuleResultMetadata:

Geheel getal lengthCount = valideren .getMetadata () .getCounts () .get (RuleResultMetadata.CountCategory.Length); Assert.assertEquals (Integer.valueOf (4), lengthCount);

4. Wachtwoord genereren

Naast validatie, de Passay library stelt ons in staat wachtwoorden te genereren. We kunnen regels geven die de generator moet gebruiken.

Om een ​​wachtwoord te genereren, hebben we een Wachtwoord generator voorwerp. Zodra we het hebben, noemen we het Genereer wachtwoord() methode en passlijst van Karakterregels. Hier is een voorbeeldcode:

CharacterRule cijfers = nieuwe CharacterRule (EnglishCharacterData.Digit); PasswordGenerator passwordGenerator = nieuwe PasswordGenerator (); String wachtwoord = wachtwoordGenerator.generatePassword (10, cijfers); Assert.assertTrue (wachtwoord.length () == 10); Assert.assertTrue (containsOnlyCharactersFromSet (wachtwoord, "0123456789"));

We moeten weten dat we een voorwerp nodig hebben CharacterData maken Karakterregel. Een ander interessant feit is dat de bibliotheek ons ​​voorziet EnglishCharacterData. Het is een opsomming van vijf sets karakters:

• cijfers
• Engels alfabet in kleine letters
• hoofdletters Engels alfabet
• combinatie van kleine letters en hoofdletters
• speciale karakters

Niets kan ons er echter van weerhouden om onze reeks karakters te definiëren. Het is net zo eenvoudig als het implementeren van het CharacterData koppel. Laten we eens kijken hoe we het kunnen doen:

CharacterRule specialCharacterRule = nieuwe CharacterRule (nieuwe CharacterData () {@Override public String getErrorCode () {return "SAMPLE_ERROR_CODE";} @Override public String getCharacters () {return "[email protected] #";}}); PasswordGenerator passwordGenerator = nieuwe PasswordGenerator (); String wachtwoord = passwordGenerator.generatePassword (10, specialCharacterRule); Assert.assertTrue (containsOnlyCharactersFromSet (wachtwoord, "[email protected] #"));

5. Positieve afstemmingsregels

We hebben al geleerd hoe we wachtwoorden kunnen genereren en valideren. Om dat te doen, moeten we een aantal regels definiëren. Om die reden moeten we weten dat er twee soorten regels beschikbaar zijn in Passay: positieve afstemmingsregels en negatieve afstemmingsregels.

Laten we eerst eens kijken wat de positieve regels zijn en hoe we ze kunnen gebruiken.

Positieve matching-regels accepteren wachtwoorden die opgegeven tekens of reguliere expressies bevatten of passen in een aantal beperkingen.

Er zijn zes positieve matching-regels:

• ToegestaanCharacterRule - definieert alle tekens die het wachtwoord moet bevatten
• ToegestaanRegexRule - definieert een reguliere expressie waaraan het wachtwoord moet voldoen
• Karakterregel - definieert een karakterset en een minimaal aantal tekens dat in het wachtwoord moet worden opgenomen
• Lengteregel - definieert een minimale lengte van het wachtwoord
• CharacterCharacteristicsRule - controleert of het wachtwoord voldoet N van gedefinieerde regels.
• LengthComplexityRule - stelt ons in staat om verschillende regels te definiëren voor verschillende wachtwoordlengtes

5.1. Eenvoudige positieve afstemmingsregels

Nu behandelen we alle regels die een eenvoudige configuratie hebben. Ze definiëren een reeks legale tekens of patronen of de lengte van een acceptabel wachtwoord.

Hier is een kort voorbeeld van de besproken regels:

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

We kunnen zien dat elke regel ons een duidelijke uitleg geeft als het wachtwoord niet geldig is. Er zijn meldingen dat het wachtwoord te kort is en twee ongeldige tekens heeft. We kunnen ook opmerken dat het wachtwoord niet overeenkomt met de opgegeven reguliere expressie.

Bovendien is ons geïnformeerd dat het onvoldoende kleine letters bevat.

5.2. CharacterCharacterisitcsRule

CharcterCharacterisitcsRule is complexer dan eerder gepresenteerde regels. Om een CharcterCharacterisitcsRule object, moeten we een lijst met Karakterregels. Bovendien moeten we instellen hoeveel van hen het wachtwoord moet overeenkomen. We kunnen het op deze manier doen:

CharacterCharacteristicsRule characterCharacteristicsRule = nieuwe CharacterCharacteristicsRule (3, nieuwe CharacterRule (EnglishCharacterData.LowerCase, 5), nieuwe CharacterRule (EnglishCharacterData.UpperCase, 5), nieuwe CharacterRule (EnglishCharacterData.Digit), nieuwe CharacterRule (EnglishCharacter )Data.Special);

Gepresenteerd CharacterCharacteristicsRule vereist een wachtwoord om drie van de vier opgegeven regels te bevatten.

5.3. LengthComplexityRule

Aan de andere kant, Passay bibliotheek biedt ons LengthComplexityRule. Het stelt ons in staat om te bepalen welke regels moeten worden toegepast op het wachtwoord van welke lengte. In contrast met CharacterCharacteristicsRule, ze stellen ons in staat om allerlei regels te gebruiken - niet alleen Karakterregel.

Laten we het voorbeeld analyseren:

LengthComplexityRule lengthComplexityRule = nieuw LengthComplexityRule (); lengthComplexityRule.addRules ("[1,5]", nieuwe CharacterRule (EnglishCharacterData.LowerCase, 5)); lengthComplexityRule.addRules ("[6,10]", new AllowCharacterRule (new char [] {'a', 'b', 'c', 'd'})));

Zoals we kunnen zien voor een wachtwoord met één tot vijf tekens, passen we toe Karakterregel. Maar voor een wachtwoord van zes tot tien tekens, willen we dat het wachtwoord overeenkomt ToegestaanCharacterRule.

6. Negatieve afstemmingsregels

In tegenstelling tot positieve koppelingsregels, weigeren negatieve koppelingsregels wachtwoorden die opgegeven tekens, reguliere expressies, invoer, enz. Bevatten.

Laten we eens kijken wat de negatieve matching-regels zijn:

• IllegalCharacterRule - definieert alle tekens die een wachtwoord niet mag bevatten
• IllegalRegexRule - definieert een reguliere expressie die niet mag overeenkomen
• IllegalSequenceRule - controleert of een wachtwoord een ongeldige reeks tekens heeft
• NumberRangeRule - definieert een reeks cijfers die een wachtwoord niet mag bevatten
• WitruimteRegel - controleert of een wachtwoord spaties bevat
• Woordenboekregel - controleert of een wachtwoord gelijk is aan een woordenboekrecord
• DictionarySubstringRule - controleert of een wachtwoord een woordenboekrecord bevat
• Geschiedenis Regel - controleert of een wachtwoord een historische wachtwoordreferentie bevat
• DigestHistoryRule - controleert of een wachtwoord een verteerde historische wachtwoordreferentie bevat
• Bronregel - controleert of een wachtwoord een bronwachtwoordreferentie bevat
• DigestSourceRule - controleert of een wachtwoord een wachtwoordreferentie voor de digest-bron bevat
• Gebruikersnaam Regel - controleert of een wachtwoord een gebruikersnaam bevat
• RepeatCharacterRegexRule - controleert of een wachtwoord herhaalde ASCII karakters

6.1. Eenvoudige regels voor negatieve overeenkomsten

Ten eerste gaan we kijken hoe we eenvoudige regels kunnen gebruiken, zoals IllegalCharacterRule, IllegalRegexRule, etc. Hier is een kort voorbeeld:

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

Het voorbeeld laat zien hoe de beschreven regels werken. Net als bij positieve matching-regels, geven ze ons volledige feedback over validatie.

6.2. Woordenboek regels

Wat als we willen controleren of een wachtwoord niet gelijk is aan de opgegeven woorden.

Om die reden is de Passay library geeft ons daar uitstekende tools voor. Laten we ontdekken Woordenboekregel en DictionarySubstringRule:

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

We kunnen zien dat woordenboekregels ons in staat stellen een lijst met verboden woorden te verstrekken. Het is handig als we een lijst hebben met de meest voorkomende of gemakkelijkst te kraken wachtwoorden. Daarom is het redelijk om gebruikers te verbieden ze te gebruiken.

In het echte leven zouden we zeker een lijst met woorden laden uit een tekstbestand of een database. In dat geval kunnen we gebruik maken van Woordlijsten. Het heeft drie overbelaste methoden die een reeks van Lezers en creëer ArrayWordList.

6.3. Geschiedenis Regel en Bronregel

Bovendien is de Passay bibliotheek geeft ons Geschiedenis Regel en Bronregel. Ze kunnen wachtwoorden valideren tegen historische wachtwoorden of tekstinhoud uit verschillende bronnen.

Laten we het voorbeeld eens bekijken:

SourceRule sourceRule = nieuwe SourceRule (); HistoryRule historyRule = nieuwe HistoryRule (); PasswordData passwordData = nieuwe PasswordData ("123"); passwordData.setPasswordReferences (nieuw PasswordData.SourceReference ("source", "wachtwoord"), nieuw PasswordData.HistoricalReference ("12345")); PasswordValidator passwordValidator = nieuwe PasswordValidator (historyRule, sourceRule);

Geschiedenis regels help ons te controleren of er eerder een wachtwoord is gebruikt. Omdat dergelijke praktijken onveilig zijn, willen we niet dat gebruikers oude wachtwoorden gebruiken.

Aan de andere kant, Bronregel stelt ons in staat om te controleren of het wachtwoord anders is dan het wachtwoord dat is opgegeven in Bronverwijzingen. We kunnen het risico vermijden dat we dezelfde wachtwoorden in verschillende systemen of applicaties hebben.

Het is vermeldenswaard dat er regels zijn zoals DigestSourceRule en DigestHistoryRule. We behandelen ze in de volgende paragraaf.

6.4. Digest-regels

Er zijn twee overzichtsregels in het Passay bibliotheek: DigestHistoryRule en DigestSourceRule. Digest-regels zijn bedoeld om te werken met wachtwoorden die zijn opgeslagen als digest of hash. Om ze te definiëren, moeten we daarom een EncodingHashBean voorwerp.

Laten we eens kijken hoe het moet:

List historicReferences = Arrays.asList (nieuwe PasswordData.HistoricalReference ("SHA256", "2e4551de804e27aacf20f9df5be3e8cd384ed64488b21ab079fb58e8c90068ab")); EncodingHashBean encodingHashBean = nieuwe EncodingHashBean (nieuwe CodecSpec ("Base64"), nieuwe DigestSpec ("SHA256"), 1, false); 

Deze keer creëren we Historische referentie door een label en het gecodeerde wachtwoord naar de constructor. Daarna hebben we geïnstantieerd EncodingHashBean met het juiste codec- en digest-algoritme.

Bovendien kunnen we het aantal iteraties specificeren en of het algoritme gezouten is.

Zodra we een coderingsboon hebben, kunnen we ons digest-wachtwoord valideren:

PasswordData passwordData = nieuwe PasswordData ("voorbeeld!"); passwordData.setPasswordReferences (historicReferences); PasswordValidator passwordValidator = nieuw PasswordValidator (nieuwe DigestHistoryRule (encodingHashBean)); RuleResult validate = passwordValidator.validate (passwordData); Assert.assertTrue (validate.isValid ());

We kunnen er meer over leren Codering HashinBean op de webpagina van de cryptaculaire bibliotheek.

6.5. RepeatCharacterRegexRule

Een andere interessante validatieregel is RepeatCharacterRegexRule. We kunnen het gebruiken om te controleren of het wachtwoord herhalen bevat ASCII karakters.

Hier is een voorbeeldcode:

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

6.6. Gebruikersnaam Regel

De laatste regel die we in dit hoofdstuk gaan bespreken is Gebruikersnaam Regel. Het stelt ons in staat om het gebruik van de gebruikersnaam in het wachtwoord te verbieden.

Zoals we eerder hebben geleerd, moeten we de gebruikersnaam opslaan in Wachtwoordgegevens:

PasswordValidator passwordValidator = nieuwe PasswordValidator (nieuwe UsernameRule ()); PasswordData passwordData = nieuwe PasswordData ("testuser1234"); passwordData.setUsername ("testgebruiker"); RuleResult validate = passwordValidator.validate (passwordData); assertFalse (validate.isValid ()); assertEquals ("ILLEGAL_USERNAME: {gebruikersnaam = testgebruiker, matchBehavior = bevat}", getDetail (validate, 0));

7. Aangepaste berichten

Passay bibliotheek stelt ons in staat om berichten aan te passen die worden geretourneerd door validatieregels. Ten eerste moeten we de berichten definiëren en ze aan foutcodes toewijzen.

We kunnen ze in een eenvoudig bestand plaatsen. Laten we eens kijken hoe gemakkelijk het is:

TOO_LONG = Wachtwoord mag niet meer tekens bevatten dan% 2 $ s. TOO_SHORT = Wachtwoord mag niet minder tekens bevatten dan% 2 $ s.

Zodra we berichten hebben, moeten we dat bestand laden. Eindelijk kunnen we het doorgeven aan WachtwoordValidator voorwerp.

Hier is een voorbeeldcode:

URL-bron = this.getClass (). GetClassLoader (). GetResource ("messages.properties"); Eigenschappen rekwisieten = nieuwe Eigenschappen (); props.load (nieuwe FileInputStream (resource.getPath ())); MessageResolver resolver = nieuwe PropertiesMessageResolver (rekwisieten); 

Zoals we kunnen zien, hebben we het message.properties bestand en gaf het door aan Eigendommen voorwerp. Vervolgens kunnen we de Eigendommen object om te creëren EigenschappenMessageResolver.

Laten we eens kijken naar het voorbeeld van het gebruik van de berichtoplosser:

PasswordValidator validator = nieuwe PasswordValidator (resolver, nieuwe LengthRule (8, 16), nieuwe WhitespaceRule ()); RuleResult tooShort = validator.validate (nieuwe PasswordData ("XXXX")); RuleResult tooLong = validator.validate (nieuwe PasswordData ("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ")); Assert.assertEquals ("Wachtwoord mag niet minder dan 16 tekens bevatten", validator.getMessages (tooShort) .get (0)); Assert.assertEquals ("Wachtwoord mag niet meer dan 16 tekens bevatten", validator.getMessages (tooLong) .get (0));

Het voorbeeld laat duidelijk zien dat we alle foutcodes kunnen vertalen met de validator die is uitgerust met een berichtoplosser.

8. Conclusie

In deze zelfstudie hebben we geleerd hoe u Passay bibliotheek. We hebben verschillende voorbeelden geanalyseerd van hoe de bibliotheek gemakkelijk kan worden gebruikt voor wachtwoordvalidatie. De meegeleverde regels hebben betrekking op de meeste gebruikelijke manieren om ervoor te zorgen dat een wachtwoord veilig is.

Maar we moeten niet vergeten dat de Passay-bibliotheek zelf ons wachtwoord niet veilig maakt. Ten eerste moeten we leren wat algemene regels zijn en vervolgens de bibliotheek gebruiken om ze te implementeren.

Alle voorbeelden zijn, zoals altijd, te vinden op GitHub.