Merge branch 'main' into feature-minclasses

Author: mikibakaiki

package-lock.json

@@ -1,6 +1,6 @@
 {
 	"name": "@passcert/pwrules-annotations",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "This package allows the parsing of Apple's password rules.",
 	"main": "./lib/cjs/index.js",
 	"module": "./lib/esm/index.js",
@@ -9,9 +9,10 @@
 	],
 	"scripts": {
 		"test": "echo \"Error: no test specified\" && exit 1",
-		"tsc": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
+		"tsc": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && npm run copy-blocklist-data",
 		"prepublish": "npm run tsc",
-        "test-program": "cd test-package && npm run tsc"
+		"test-program": "cd test-package && npm run tsc",
+        "copy-blocklist-data":"echo \"./lib/cjs/data/ ./lib/esm/data\" | xargs -n 1 cp -v src/data/*.txt"
 	},
 	"repository": {
 		"type": "git",
@@ -28,5 +29,8 @@
 		"@typescript-eslint/parser": "^4.26.0",
 		"eslint": "^7.27.0",
 		"typescript": "^4.3.2"
+	},
+	"dependencies": {
+		"@types/node": "^16.9.1"
 	}
 }

package.json

@@ -1,12 +1,14 @@
-// Copyright (c) 2019 - 2020 Apple Inc. Licensed under MIT License.
+// Copyright (c) 2019 - 2021 Apple Inc. Licensed under MIT License.
 // Adapted to typescript and Bitwarden by João Miguel P. Campos (github @mikibakaiki) for PassCert project.
 // npm package by João Miguel P. Campos (github @mikibakaiki) for PassCert project.
 
+import { PasswordBlocklist } from './data/passwordBlocklist';
 import { CustomCharacterData } from './data/customCharacterData';
-import { CHARACTER_CLASS_END_SENTINEL, CHARACTER_CLASS_START_SENTINEL, Identifier, PROPERTY_SEPARATOR, PROPERTY_VALUE_SEPARATOR, PROPERTY_VALUE_START_SENTINEL, RuleName, SHOULD_NOT_BE_REACHED, SPACE_CODE_POINT } from './data/data.enum';
+import { BlockListIdentifier, CHARACTER_CLASS_END_SENTINEL, CHARACTER_CLASS_START_SENTINEL, Identifier, PROPERTY_SEPARATOR, PROPERTY_VALUE_SEPARATOR, PROPERTY_VALUE_START_SENTINEL, RuleName, SHOULD_NOT_BE_REACHED, SPACE_CODE_POINT } from './data/data.enum';
 import { NamedCharacterData } from './data/namedCharacterData';
 import { RuleData } from './data/ruleData';
 
+
 export class PasswordRulesParser {
 
     /**
@@ -60,6 +62,9 @@ export class PasswordRulesParser {
                 case RuleName.MIN_CLASSES:
                     actualMinClasses = rule.value;
                     break;
+                case RuleName.BLOCK_LIST:
+                    newPasswordRules.push(new RuleData(RuleName.BLOCK_LIST, rule.value));
+
             }
         }
         newAllowedValues = this._canonicalizedPropertyValues(newAllowedValues, suppressCopyingRequiredToAllowed);
@@ -81,13 +86,15 @@ export class PasswordRulesParser {
         if (minimumMaxLength !== null) {
             newPasswordRules.push(new RuleData(RuleName.MAX_LENGTH, minimumMaxLength));
         }
+
         if (actualMinClasses >= 1 && actualMinClasses <= 4) {
             newPasswordRules.push(new RuleData(RuleName.MIN_CLASSES, actualMinClasses));
         } else if (actualMinClasses < 1) {
             newPasswordRules.push(new RuleData(RuleName.MIN_CLASSES, 1));
         } else {
             newPasswordRules.push(new RuleData(RuleName.MIN_CLASSES, 4));
         }
+
         return newPasswordRules;
     }
 
@@ -381,6 +388,14 @@ export class PasswordRulesParser {
         return identifier && Object.values(Identifier).includes(identifier.toLowerCase());
     }
 
+    /**
+     * Check if the identifier is a valid one for the "blocklist" rule.
+     * @param identifier The identifier to verify.
+     * @returns True if it is a valid identifier. False if it is not a valid identifier.
+     */
+    private _isValidBlockListPropertyValueIdentifier(identifier: string): boolean {
+        return identifier && Object.values(BlockListIdentifier).includes(identifier.toLowerCase());
+    }
 
     /**
      * Parse a custom character class. These classes are defined by the user and are surrounded by squared brackets ([]).
@@ -492,6 +507,35 @@ export class PasswordRulesParser {
         return [propertyValues, position];
     }
 
+    /**
+     * Parse the values given to the rule "blocklist". If it's 'default', there is a list with the 100 000 most commonly used passwords. 
+     * @param input The string that contains the rules to be parsed.
+     * @param position The position from where to start parsing the input.
+     * @returns Returns an array with the information about the blocklist and the last position analyzed
+     */
+    private _parseBlockListPropertyValue(input: string, position: number): [string[], number] {
+        let propertyValues = [];
+        if (this._isIdentifierCharacter(input[position])) {
+            let identifierStartPosition = position;
+            let [propertyValue, index] = this._parseIdentifier(input, position);
+            position = index;
+            if (!this._isValidBlockListPropertyValueIdentifier(propertyValue)) {
+                console.error("Unrecognized property value identifier: " + propertyValue);
+                return [null, identifierStartPosition];
+            }
+            // TODO maybe here we can fetch the default word list and make this the value of the rule: an array of all the words
+            if (propertyValue === 'default') {
+                const passwordBlocklist = PasswordBlocklist.getInstance();
+                passwordBlocklist.blocklist.forEach(pw => {
+                    propertyValues.push(pw);
+                })
+            } else {
+                propertyValues.push(propertyValue);
+            }
+        }
+        return [propertyValues, position];
+    }
+
     /**
      * Parse a password rule.
      * @param input The string that contains the rules to be parsed.
@@ -565,6 +609,14 @@ export class PasswordRulesParser {
                 }
                 return [new RuleData(property.name, property.propValue), position];
             }
+            case RuleName.BLOCK_LIST: {
+                let [blocklist, index] = this._parseBlockListPropertyValue(input, position);
+                position = index;
+                if (blocklist) {
+                    property.propValue = blocklist;
+                }
+                return [new RuleData(property.name, property.propValue), position];
+            }
         }
         console.assert(false, SHOULD_NOT_BE_REACHED);
     }