Mirrors/node-red-contrib-password-generator
1
0
Fork 0
mirror of https://github.com/yuto-yuto/node-red-contrib-password-generator.git synced 2024-11-21 19:06:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add options

Browse Source
This commit is contained in:
yuto-yuto 2021-07-11 09:03:32 +02:00
parent 456f4332e3
commit 4af3cb4be1
3 changed files with 107 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
lib/PasswordGenerator.ts
View File

@ -7,14 +7,35 @@ const AsciiRange = {
/** childe mark ~ */
max: 126,
}
const optRegexes = {
space: " ",
special: "!\"#\\$%&'\\(\\)\\*\\+,-./:;<=>\\?@\\[\\\\\\]\\^_`\\{|\\}~",
number: "\\d",
};
export interface DisableOptions {
space?: boolean;
special?: boolean;
number?: boolean;
}
export async function generatePassword(length: number, disableOpts?: DisableOptions): Promise<string> {
if (length < 5) {
throw new Error("Password length must be longer than 5.");
}
export async function generatePassword(length: number): Promise<string> {
let result = "";
const regex = createRegex(disableOpts)
while (true) {
const bytes = await promisify(crypto.randomBytes)(length * 2);
const byteArray = Array.from(bytes);
const filtered = byteArray.filter(isInAsciiRange);
result += String.fromCharCode(...filtered);
if (regex) {
result = result.replace(regex, "");
}
if (result.length >= length) {
result = result.slice(0, length);
break;
@ -25,4 +46,16 @@ export async function generatePassword(length: number): Promise<string> {
function isInAsciiRange(value: number) {
return AsciiRange.min <= value && value <= AsciiRange.max;
}
function createRegex(disableOpts?: DisableOptions): RegExp | undefined {
if (!disableOpts) {
return undefined;
}
let reg = "";
if (disableOpts?.space) { reg += optRegexes.space };
if (disableOpts?.special) { reg += optRegexes.special };
if (disableOpts?.number) { reg += optRegexes.number };
return new RegExp(`[${reg}]`, "g");
}

23
lib/PasswordGeneratorNode.html
View File

@ -5,8 +5,11 @@
color: "#D8BFD8",
defaults: {
name: { value: "" },
length: { value: "", required: true, validate: RED.validators.number() },
length: { value: "", required: true, validate: (v) => v > 4 },
setTo: { value: "" },
isNumberDisabled: { value: false, require: true },
isSpecialCharsDisabled: { value: false, require: true },
isSpaceDisabled: { value: false, require: true },
},
inputs: 1,
outputs: 1,
@ -26,9 +29,21 @@
<input type="text" id="node-input-length">
</div>
<div class="form-row">
<label for="node-input-setTo"><i class="fa fa-ellipsis-he"></i> to</label>
<label for="node-input-setTo"><i class="fa fa-ellipsis-h"></i> to</label>
<input type="text" id="node-input-setTo">
</div>
<div class="form-row">
<label for="node-input-isNumberDisabled"> Disable Number</label>
<input type="checkbox" id="node-input-isNumberDisabled">
</div>
<div class="form-row">
<label for="node-input-isSpecialCharsDisabled"> Disable Special chars</label>
<input type="checkbox" id="node-input-isSpecialCharsDisabled">
</div>
<div class="form-row">
<label for="node-input-isSpaceDisabled"> Disable Space</label>
<input type="checkbox" id="node-input-isSpaceDisabled">
</div>
</script>
<script type="text/html" data-help-name="password-generator">
@ -40,5 +55,7 @@
<dd> Password length. </dd>
<dt>to</dt>
<dd> The property to set generated password. </dd>
<dt>Disable options</dt>
<dd> Excludes the characters from the generated password. </dd>
</dl>
</script>
</script>

68
test/PasswordGenerator_spec.ts
View File

@ -1,22 +1,60 @@
import "mocha";
import * as crypto from "crypto";
import { expect } from "chai";
import * as sinon from "sinon";
import { generatePassword } from "../lib/PasswordGenerator";
import { generatePassword, DisableOptions } from "../lib/PasswordGenerator";
describe("PasswordGenerator", () => {
it("should return true for the first time", async () => {
const result = await generatePassword(10);
expect(result).to.lengthOf(10);
afterEach(() => {
sinon.restore();
});
it("should throw an error when length is 4", (done) => {
generatePassword(4)
.then(() => done("Error didn't occur."))
.catch(() => done());
});
it("should return password when length is 5", async () => {
const result = await generatePassword(5);
expect(result).to.lengthOf(5);
});
[
{ regex: /0123456789/, title: "number" },
{ regex: / /, title: "space" },
{ regex: /abcdefghijklmnopqrstuvwxyz/, title: "lowercase" },
{ regex: /ABCDEFGHIJKLMNOPQRSTUVWXYZ/, title: "uppercase" },
{ regex: /!\"#\$%&'\(\)\*\+,-.\//, title: "special characters group 1" },
{ regex: /:;<=>\?@/, title: "special characters group 2" },
{ regex: /\[\\\]\^_`/, title: "special characters group 3" },
{ regex: /\{|\}~/, title: "special characters group 4" },
].forEach((testData) => {
it(`should contain ${testData.title} without option`, async () => {
const fakeData = Array.from(Array(256).keys());
sinon.stub(Array, "from").returns(fakeData);
const result = await generatePassword(256);
expect(result).to.match(testData.regex);
});
});
it("should not contain number when option number is true", async () => {
const fakeData = Array.from(Array(256).keys());
sinon.stub(Array, "from").returns(fakeData);
const result = await generatePassword(256, { number: true });
expect(result).not.to.match(/\d/);
});
it("should not contain space when option space is true", async () => {
const fakeData = Array.from(Array(256).keys());
sinon.stub(Array, "from").returns(fakeData);
const result = await generatePassword(256, { space: true });
expect(result).not.to.contain(" ");
});
it("should not contain special characters when option space is true", async () => {
const fakeData = Array.from(Array(256).keys());
sinon.stub(Array, "from").returns(fakeData);
const result = await generatePassword(256, { special: true });
expect(result).not.to.match(/[\[!\"#\$%&'\(\)\*\+,\-./:;<=>\?@\[\\\]\^_`{|}\]]/);
});
// it.only("should return true for the first time", async () => {
// const testData = Buffer.from([31, 32, 126, 127]);
// sinon.stub(crypto, "randomBytes")
// .callsFake((size: number, cb: (err: Error | null, buf: Buffer) => void) => {
// console.log("HEY")
// cb(null, testData);
// });
// const result = await generatePassword(10);
// expect(result).to.equal(" ~");
// });
});