PasswordVerifier.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.crypt;

  24. import java.io.File;
  25. import java.io.FileInputStream;
  26. import java.io.InputStream;
  27. import java.io.Serializable;
  28. import java.util.ArrayList;
  29. import java.util.Date;
  30. import java.util.Enumeration;
  31. import java.util.List;
  32. import java.util.Properties;

  34. import org.apache.commons.lang.StringUtils;
  35. import org.openspcoop2.utils.Utilities;
  36. import org.openspcoop2.utils.UtilsException;
  37. import org.openspcoop2.utils.date.DateManager;
  38. import org.openspcoop2.utils.regexp.RegularExpressionEngine;

  40. /**
  41.  * PasswordVerifier
  42.  *
  43.  * @author Andrea Poli (apoli@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  */

  48. public class PasswordVerifier implements Serializable {
  49.     
  50.     private static final long serialVersionUID = 1L;
  51.     
  52.     private static final String PROPERTY_REGULAR_EXPRESSIONS_PREFIX = "passwordVerifier.regularExpression.";
  53.     private static final String PROPERTY_LOGIN_CONTAINS = "passwordVerifier.notContainsLogin";
  54.     private static final String PROPERTY_RESTRICTED_WORDS = "passwordVerifier.restrictedWords";
  55.     private static final String PROPERTY_MIN_LENGTH = "passwordVerifier.minLength";
  56.     private static final String PROPERTY_MAX_LENGTH = "passwordVerifier.maxLength";
  57.     private static final String PROPERTY_INCLUDE_LOWER_CASE_LETTER = "passwordVerifier.lowerCaseLetter";
  58.     private static final String PROPERTY_INCLUDE_UPPER_CASE_LETTER = "passwordVerifier.upperCaseLetter";
  59.     private static final String PROPERTY_INCLUDE_NUMBER = "passwordVerifier.includeNumber";
  60.     private static final String PROPERTY_INCLUDE_NOT_ALPHANUMERIC_SYMBOL = "passwordVerifier.includeNotAlphanumericSymbol";
  61.     private static final String PROPERTY_ALL_DISTINCT_CHARACTERS = "passwordVerifier.allDistinctCharacters";
  62.     private static final String PROPERTY_EXPIRE = "passwordVerifier.expireDays";
  63.     private static final String PROPERTY_HISTORY = "passwordVerifier.history";
  64.     
  65.     protected List<String> regulaExpressions = new ArrayList<>();
  66.     protected boolean notContainsLogin = false;
  67.     protected List<String> restrictedWords = new ArrayList<>();
  68.     protected int minLenght = -1;
  69.     protected int maxLenght = -1;
  70.     protected boolean includeLowerCaseLetter = false;
  71.     protected boolean includeUpperCaseLetter = false;
  72.     protected boolean includeNumber = false;
  73.     protected boolean includeNotAlphanumericSymbol = false;
  74.     protected boolean allDistinctCharacters = false;
  75.     protected boolean checkPasswordExpire;
  76.     protected int expireDays;
  77.     protected boolean history;

  79.     public PasswordVerifier(){}
  80.     public PasswordVerifier(PasswordVerifier pv){
  81.         this.regulaExpressions = pv.regulaExpressions;
  82.         this.notContainsLogin = pv.notContainsLogin;
  83.         this.restrictedWords = pv.restrictedWords;
  84.         this.minLenght = pv.minLenght;
  85.         this.maxLenght = pv.maxLenght;
  86.         this.includeLowerCaseLetter = pv.includeLowerCaseLetter;
  87.         this.includeUpperCaseLetter = pv.includeUpperCaseLetter;
  88.         this.includeNumber = pv.includeNumber;
  89.         this.includeNotAlphanumericSymbol = pv.includeNotAlphanumericSymbol;
  90.         this.allDistinctCharacters = pv.allDistinctCharacters;
  91.         this.checkPasswordExpire = pv.checkPasswordExpire;
  92.         this.expireDays = pv.expireDays;
  93.         this.history = pv.history;
  94.     }
  95.     public PasswordVerifier(String resource) throws UtilsException{
  96.         this(resource, true);
  97.     }
  98.     public PasswordVerifier(String resource, boolean useDefaultIfNotFound) throws UtilsException{
  99.         InputStream is = null;
  100.         try{
  101.             File f = new File(resource);
  102.             if(f.exists()){
  103.                 is = new FileInputStream(f);
  104.             }
  105.             else{
  106.                 is = PasswordVerifier.class.getResourceAsStream(resource);
  107.             }
  108.             if(is==null) {
  109.                 is = PasswordVerifier.class.getResourceAsStream("/org/openspcoop2/utils/crypt/consolePassword.properties");
  110.             }
  111.             if(is!=null){
  112.                 Properties p = new Properties();
  113.                 p.load(is);
  114.                 this._init(p);
  115.             }
  116.             else{
  117.                 throw new Exception("Resource ["+resource+"] not found");
  118.             }
  119.         }catch(Exception e){
  120.             throw new UtilsException(e.getMessage(),e);
  121.         }finally{
  122.             try{
  123.                 if(is!=null){
  124.                     is.close();
  125.                 }
  126.             }catch(Exception eClose){
  127.                 // close
  128.             }
  129.         }
  130.     }
  131.     public PasswordVerifier(InputStream is) throws UtilsException{
  132.         try{
  133.             Properties p = new Properties();
  134.             p.load(is);
  135.             this._init(p);
  136.         }catch(Exception e){
  137.             throw new UtilsException(e.getMessage(),e);
  138.         }
  139.     }
  140.     public PasswordVerifier(Properties p) throws UtilsException{
  141.         this._init(p);
  142.     }
  143.     private void _init(Properties p) throws UtilsException{
  144.         try{
  145.             
  146.             Properties tmpP = Utilities.readProperties(PROPERTY_REGULAR_EXPRESSIONS_PREFIX, p);
  147.             if(tmpP!=null && tmpP.size()>0){
  148.                 Enumeration<?> en =tmpP.keys();
  149.                 while (en.hasMoreElements()) {
  150.                     String key = (String) en.nextElement();
  151.                     String value = tmpP.getProperty(key);
  152.                     this.regulaExpressions.add(value);
  153.                 }
  154.             }
  155.             
  156.             String tmp = p.getProperty(PROPERTY_LOGIN_CONTAINS);
  157.             if(tmp!=null){
  158.                 tmp=tmp.trim();
  159.                 try{
  160.                     this.notContainsLogin = Boolean.parseBoolean(tmp);
  161.                 }catch(Exception e){
  162.                     throw new Exception("Property '"+PROPERTY_LOGIN_CONTAINS+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  163.                 }
  164.             }
  165.             
  166.             tmp = p.getProperty(PROPERTY_RESTRICTED_WORDS);
  167.             if(tmp!=null){
  168.                 tmp=tmp.trim();
  169.                 if(tmp.contains(",")){
  170.                     String [] split = tmp.split(",");
  171.                     for (int i = 0; i < split.length; i++) {
  172.                         this.restrictedWords.add(split[i].trim());
  173.                     }
  174.                 }
  175.                 else{
  176.                     this.restrictedWords.add(tmp);
  177.                 }
  178.             }

  180.             tmp = p.getProperty(PROPERTY_MIN_LENGTH);
  181.             if(tmp!=null){
  182.                 tmp=tmp.trim();
  183.                 try{
  184.                     this.minLenght = Integer.parseInt(tmp);
  185.                 }catch(Exception e){
  186.                     throw new Exception("Property '"+PROPERTY_MIN_LENGTH+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  187.                 }
  188.             }
  189.             
  190.             tmp = p.getProperty(PROPERTY_MAX_LENGTH);
  191.             if(tmp!=null){
  192.                 tmp=tmp.trim();
  193.                 try{
  194.                     this.maxLenght = Integer.parseInt(tmp);
  195.                 }catch(Exception e){
  196.                     throw new Exception("Property '"+PROPERTY_MAX_LENGTH+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  197.                 }
  198.             }
  199.             
  200.             tmp = p.getProperty(PROPERTY_INCLUDE_LOWER_CASE_LETTER);
  201.             if(tmp!=null){
  202.                 tmp=tmp.trim();
  203.                 try{
  204.                     this.includeLowerCaseLetter = Boolean.parseBoolean(tmp);
  205.                 }catch(Exception e){
  206.                     throw new Exception("Property '"+PROPERTY_INCLUDE_LOWER_CASE_LETTER+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  207.                 }
  208.             }
  209.             
  210.             tmp = p.getProperty(PROPERTY_INCLUDE_UPPER_CASE_LETTER);
  211.             if(tmp!=null){
  212.                 tmp=tmp.trim();
  213.                 try{
  214.                     this.includeUpperCaseLetter = Boolean.parseBoolean(tmp);
  215.                 }catch(Exception e){
  216.                     throw new Exception("Property '"+PROPERTY_INCLUDE_UPPER_CASE_LETTER+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  217.                 }
  218.             }
  219.             
  220.             tmp = p.getProperty(PROPERTY_INCLUDE_NUMBER);
  221.             if(tmp!=null){
  222.                 tmp=tmp.trim();
  223.                 try{
  224.                     this.includeNumber = Boolean.parseBoolean(tmp);
  225.                 }catch(Exception e){
  226.                     throw new Exception("Property '"+PROPERTY_INCLUDE_NUMBER+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  227.                 }
  228.             }
  229.             
  230.             tmp = p.getProperty(PROPERTY_INCLUDE_NOT_ALPHANUMERIC_SYMBOL);
  231.             if(tmp!=null){
  232.                 tmp=tmp.trim();
  233.                 try{
  234.                     this.includeNotAlphanumericSymbol = Boolean.parseBoolean(tmp);
  235.                 }catch(Exception e){
  236.                     throw new Exception("Property '"+PROPERTY_INCLUDE_NOT_ALPHANUMERIC_SYMBOL+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  237.                 }
  238.             }
  239.             
  240.             tmp = p.getProperty(PROPERTY_ALL_DISTINCT_CHARACTERS);
  241.             if(tmp!=null){
  242.                 tmp=tmp.trim();
  243.                 try{
  244.                     this.allDistinctCharacters = Boolean.parseBoolean(tmp);
  245.                 }catch(Exception e){
  246.                     throw new Exception("Property '"+PROPERTY_ALL_DISTINCT_CHARACTERS+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  247.                 }
  248.             }
  249.             
  250.             tmp = p.getProperty(PROPERTY_EXPIRE);
  251.             if(tmp!=null){
  252.                 tmp=tmp.trim();
  253.                 try{
  254.                     this.expireDays = Integer.parseInt(tmp);
  255.                     this.checkPasswordExpire = this.expireDays>0;
  256.                 }catch(Exception e){
  257.                     throw new Exception("Property '"+PROPERTY_EXPIRE+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  258.                 }
  259.             }

  261.             tmp = p.getProperty(PROPERTY_HISTORY);
  262.             if(tmp!=null){
  263.                 tmp=tmp.trim();
  264.                 try{
  265.                     this.history = Boolean.parseBoolean(tmp);
  266.                 }catch(Exception e){
  267.                     throw new Exception("Property '"+PROPERTY_HISTORY+"' with wrong value '"+tmp+"': "+e.getMessage(),e);
  268.                 }
  269.             }
  270.             
  271.         }catch(Exception e){
  272.             throw new UtilsException(e.getMessage(),e);
  273.         }
  274.     }
  275.     
  276.     public List<String> getRegulaExpressions() {
  277.         return this.regulaExpressions;
  278.     }
  279.     public void setRegulaExpressions(List<String> regulaExpressions) {
  280.         this.regulaExpressions = regulaExpressions;
  281.     }
  282.     public boolean isNotContainsLogin() {
  283.         return this.notContainsLogin;
  284.     }
  285.     public void setNotContainsLogin(boolean notContainsLogin) {
  286.         this.notContainsLogin = notContainsLogin;
  287.     }
  288.     public List<String> getRestrictedWords() {
  289.         return this.restrictedWords;
  290.     }
  291.     public void setRestrictedWords(List<String> restrictedWords) {
  292.         this.restrictedWords = restrictedWords;
  293.     }
  294.     public int getMinLenght() {
  295.         return this.minLenght;
  296.     }
  297.     public void setMinLenght(int minLenght) {
  298.         this.minLenght = minLenght;
  299.     }
  300.     public int getMaxLenght() {
  301.         return this.maxLenght;
  302.     }
  303.     public void setMaxLenght(int maxLenght) {
  304.         this.maxLenght = maxLenght;
  305.     }
  306.     public boolean isIncludeLowerCaseLetter() {
  307.         return this.includeLowerCaseLetter;
  308.     }
  309.     public void setIncludeLowerCaseLetter(boolean includeLowerCaseLetter) {
  310.         this.includeLowerCaseLetter = includeLowerCaseLetter;
  311.     }
  312.     public boolean isIncludeUpperCaseLetter() {
  313.         return this.includeUpperCaseLetter;
  314.     }
  315.     public void setIncludeUpperCaseLetter(boolean includeUpperCaseLetter) {
  316.         this.includeUpperCaseLetter = includeUpperCaseLetter;
  317.     }
  318.     public boolean isIncludeNumber() {
  319.         return this.includeNumber;
  320.     }
  321.     public void setIncludeNumber(boolean includeNumber) {
  322.         this.includeNumber = includeNumber;
  323.     }
  324.     public boolean isIncludeNotAlphanumericSymbol() {
  325.         return this.includeNotAlphanumericSymbol;
  326.     }
  327.     public void setIncludeNotAlphanumericSymbol(boolean includeNotAlphanumericSymbol) {
  328.         this.includeNotAlphanumericSymbol = includeNotAlphanumericSymbol;
  329.     }
  330.     public boolean isAllDistinctCharacters() {
  331.         return this.allDistinctCharacters;
  332.     }
  333.     public void setAllDistinctCharacters(boolean allDistinctCharacters) {
  334.         this.allDistinctCharacters = allDistinctCharacters;
  335.     }
  336.     public int getExpireDays() {
  337.         return this.expireDays;
  338.     }
  339.     public void setExpireDays(int expireDays) {
  340.         this.expireDays = expireDays;
  341.         this.checkPasswordExpire = this.expireDays>0;
  342.     }
  343.     public boolean isCheckPasswordExpire() {
  344.         return this.checkPasswordExpire;
  345.     }
  346.     public boolean isHistory() {
  347.         return this.history;
  348.     }
  349.     public void setHistory(boolean history) {
  350.         this.history = history;
  351.     }
  352.     
  353.     public boolean validate(String login, String password){
  354.         StringBuilder bf = new StringBuilder();
  355.         return this.validate(login,password,bf);
  356.     }
  357.     public boolean validate(String login, String password,StringBuilder bfMotivazioneErrore){
  358.         if(password==null) {
  359.             bfMotivazioneErrore.append("Password non fornita");
  360.             return false;
  361.         }
  362.         password = password.trim();
  363.         if(this.regulaExpressions.size()>0){
  364.             for (String regExp : this.regulaExpressions) {
  365.                 try{
  366.                     if (RegularExpressionEngine.isMatch(password, regExp) == false){
  367.                         bfMotivazioneErrore.append("La password non rispetta l'espressione regolare: "+regExp);
  368.                         return false;
  369.                     }
  370.                 }catch(Exception e){
  371.                     bfMotivazioneErrore.append("Rilevato un errore durante la verifica della password con l'espressione regolare '"+regExp+"': "+e.getMessage());
  372.                     return false;
  373.                 }
  374.             }
  375.         }
  376.         if(this.notContainsLogin){
  377.             if(password.contains(login)){
  378.                 bfMotivazioneErrore.append("La password contiene il nome di login");
  379.                 return false;
  380.             }
  381.         }
  382.         if(this.restrictedWords.size()>0){
  383.             for (String word : this.restrictedWords) {
  384.                 if(password.toLowerCase().equals(word)){
  385.                     bfMotivazioneErrore.append("La password corrisponde ad una delle parole riservate: "+word);
  386.                     return false;
  387.                 }
  388.             }
  389.         }
  390.         if(this.minLenght>0){
  391.             if(password.length()<this.minLenght){
  392.                 bfMotivazioneErrore.append("La password deve essere composta almeno da ").append(this.minLenght).
  393.                     append(" caratteri mentre quella fornita ha una lunghezza di ").append(password.length()).append(" caratteri");
  394.                 return false;
  395.             }
  396.         }
  397.         if(this.maxLenght>0){
  398.             if(password.length()>this.maxLenght){
  399.                 bfMotivazioneErrore.append("La password non deve essere composta da più di ").append(this.minLenght).
  400.                     append(" caratteri mentre quella fornita ha una lunghezza di ").append(password.length()).append(" caratteri");
  401.                 return false;
  402.             }
  403.         }
  404.         if(this.includeLowerCaseLetter){
  405.             boolean found = false;
  406.             for (int i = 0; i < password.length(); i++) {
  407.                 String c = password.charAt(i)+"";
  408.                 if(StringUtils.isAllLowerCase(c)){
  409.                     found = true;
  410.                     break;
  411.                 }
  412.             }
  413.             if(!found){
  414.                 bfMotivazioneErrore.append("La password deve contenere almeno una lettera minuscola (a - z)");
  415.                 return false;
  416.             }
  417.         }
  418.         if(this.includeUpperCaseLetter){
  419.             boolean found = false;
  420.             for (int i = 0; i < password.length(); i++) {
  421.                 String c = password.charAt(i)+"";
  422.                 if(StringUtils.isAllUpperCase(c)){
  423.                     found = true;
  424.                     break;
  425.                 }
  426.             }
  427.             if(!found){
  428.                 bfMotivazioneErrore.append("La password deve contenere almeno una lettera maiuscola (A - Z)");
  429.                 return false;
  430.             }
  431.         }
  432.         if(this.includeNumber){
  433.             boolean found = false;
  434.             for (int i = 0; i < password.length(); i++) {
  435.                 String c = password.charAt(i)+"";
  436.                 if(StringUtils.isNumeric(c)){
  437.                     found = true;
  438.                     break;
  439.                 }
  440.             }
  441.             if(!found){
  442.                 bfMotivazioneErrore.append("La password deve contenere almeno un numero (0 - 9)");
  443.                 return false;
  444.             }
  445.         }
  446.         if(this.includeNotAlphanumericSymbol){
  447.             boolean found = false;
  448.             for (int i = 0; i < password.length(); i++) {
  449.                 String c = password.charAt(i)+"";
  450.                 if(!StringUtils.isNumeric(c) && !StringUtils.isAlpha(c)){
  451.                     found = true;
  452.                     break;
  453.                 }
  454.             }
  455.             if(!found){
  456.                 bfMotivazioneErrore.append("La password deve contenere almeno un carattere non alfanumerico (ad esempio, !, $, #, %, @)");
  457.                 return false;
  458.             }
  459.         }
  460.         if(this.allDistinctCharacters){
  461.             for (int i = 0; i < password.length(); i++) {
  462.                 String c = password.charAt(i)+"";
  463.                 int count = 0;
  464.                 for (int j = 0; j < password.length(); j++) {
  465.                     String check = password.charAt(j)+"";
  466.                     if(check.equals(c)){
  467.                         count++;
  468.                     }
  469.                 }
  470.                 if(count>1){
  471.                     bfMotivazioneErrore.append("Tutti i caratteri utilizzati devono essere differenti mentre nella password fornita il carattere '"+c+"' appare "+count+" volte");
  472.                     return false;
  473.                 }
  474.             }
  475.         }
  476.         return true;
  477.     }
  478.     
  479.     public boolean isPasswordExpire(Date lastUpdatePassword){
  480.         StringBuilder bf = new StringBuilder();
  481.         return this.isPasswordExpire(lastUpdatePassword,bf);
  482.     }
  483.     public boolean isPasswordExpire(Date lastUpdatePassword, StringBuilder bfMotivazioneErrore) {
  484.         if(this.checkPasswordExpire) {
  485.             Date now = DateManager.getDate();
  486.             long expireMs = ((long) this.expireDays * 24 * 60 * 60 * 1000);
  487.             Date expireDate = new Date(lastUpdatePassword.getTime() + expireMs );
  488.             if(expireDate.before(now)) {
  489.                 bfMotivazioneErrore.append("Password impostata da più di "+this.expireDays+" giorni");
  490.                 return true;
  491.             }
  492.         }
  493.         return false;
  494.     }
  495.     
  496.     public boolean existsRestriction(){
  497.         String s = this.help("", "", false, false);
  498.         return s != null && !"".equals(s);
  499.     }
  500.     
  501.     public String help(){
  502.         return this.help("\n", "- ", true, false);
  503.     }
  504.     public String help(String separator){
  505.         return this.help(separator, "- ", true, false);
  506.     }
  507.     public boolean existsRestrictionUpdate(){
  508.         String s = this.help("", "", false, true);
  509.         return s != null && !"".equals(s);
  510.     }
  511.     
  512.     public String helpUpdate(){
  513.         return this.help("\n", "- ", true, true);
  514.     }
  515.     public String helpUpdate(String separator){
  516.         return this.help(separator, "- ", true, true);
  517.     }
  518.     public String help(String separator, String elenco, boolean premessa, boolean update){
  519.         StringBuilder bf = new StringBuilder();
  520.         if(premessa){
  521.             bf.append("La password deve rispettare i seguenti vincoli: ");
  522.         }
  523.         if(this.regulaExpressions.size()>0){
  524.             for (String regExp : this.regulaExpressions) {
  525.                 bf.append(separator);
  526.                 bf.append(elenco).append("deve soddisfare l'espressione regolare: "+regExp);
  527.             }
  528.         }
  529.         if(this.notContainsLogin){
  530.             bf.append(separator);
  531.             bf.append(elenco).append("non deve contenere il nome di login dell'utente");
  532.         }
  533.         if(this.restrictedWords.size()>0){
  534.             bf.append(separator);
  535.             bf.append(elenco).append("non deve corrispondere ad una delle seguenti parole riservate: "+this.restrictedWords);
  536.         }
  537.         if(this.minLenght>0){
  538.             bf.append(separator);
  539.             bf.append(elenco).append("deve essere composta almeno da ").append(this.minLenght).append(" caratteri");
  540.         }
  541.         if(this.maxLenght>0){
  542.             bf.append(separator);
  543.             bf.append(elenco).append("non deve essere composta da più di ").append(this.maxLenght).append(" caratteri");
  544.         }
  545.         if(this.includeLowerCaseLetter){
  546.             bf.append(separator);
  547.             bf.append(elenco).append("deve contenere almeno una lettera minuscola (a - z)");
  548.         }
  549.         if(this.includeUpperCaseLetter){
  550.             bf.append(separator);
  551.             bf.append(elenco).append("deve contenere almeno una lettera maiuscola (A - Z)");
  552.         }
  553.         if(this.includeNumber){
  554.             bf.append(separator);
  555.             bf.append(elenco).append("deve contenere almeno un numero (0 - 9)");
  556.         }
  557.         if(this.includeNotAlphanumericSymbol){
  558.             bf.append(separator);
  559.             bf.append(elenco).append("deve contenere almeno un carattere non alfanumerico (ad esempio, !, $, #, %, @)");
  560.         }
  561.         if(this.allDistinctCharacters){
  562.             bf.append(separator);
  563.             bf.append(elenco).append("tutti i caratteri utilizzati devono essere differenti");
  564.         }
  565.         if(this.history){
  566.             if(update) {
  567.                 bf.append(separator);
  568.                 bf.append(elenco).append("non deve corrispondere ad una precedente password");
  569.             }
  570.         }
  571.         return bf.toString();
  572.     }
  573. }
Created with JaCoCo 0.8.8.202204050719