First approach to for a toggable printableStringConsumer

Author: 434b

packages/core/FuzzedDataProvider.test.ts

@@ -945,6 +945,24 @@ describe("FuzzedDataProvider checks", () => {
 		expect(strings).toContain("or si");
 		expect(strings).toContain("t ame");
 	});
+	it("verifyPrintableString", () => {
+		const data = new FuzzedDataProvider(Buffer.from(Data));
+		const consumedStrAsArr = [...data.consumeString(1024, "ascii", true)];
+		consumedStrAsArr.forEach((c) => {
+			const charAsNum = c.charCodeAt(0);
+			expect(charAsNum >= 32 && charAsNum <= 126).toBeTruthy();
+		});
+	});
+	it("verifyNonPrintableString", () => {
+		const data = new FuzzedDataProvider(Buffer.from(Data));
+		const consumedStrAsArr = [...data.consumeString(1024)];
+		expect(
+			consumedStrAsArr.some((ele) => {
+				const eleAsNum = ele.charCodeAt(0);
+				return eleAsNum < 32 || eleAsNum > 126;
+			})
+		).toBeTruthy();
+	});
 });
 
 const Data = Buffer.from([

packages/core/FuzzedDataProvider.ts

@@ -372,33 +372,100 @@ export class FuzzedDataProvider {
 	 * is not sufficiently long.
 	 * @param maxLength the maximum length of the string
 	 * @param encoding the encoding of the string
+	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
+	 * should be forced to contain only valid printable characters
 	 * @returns a `string` of length between 0 and `maxLength` (inclusive)
 	 */
 	consumeString(
 		maxLength: number,
-		encoding: BufferEncoding | undefined = "ascii"
+		encoding: BufferEncoding | undefined = "ascii",
+		printable: boolean | undefined = false
 	): string {
 		if (maxLength < 0) throw new Error("maxLength must be non-negative");
+		let result;
 		const arrayLength = Math.min(maxLength, this._remainingBytes);
-		const result = this.data.toString(
-			encoding,
-			this.dataPtr,
-			this.dataPtr + arrayLength
-		);
+
+		if (printable) {
+			result = this.bufToPrintableString(
+				this.data,
+				this.dataPtr,
+				this.dataPtr + arrayLength,
+				encoding
+			);
+		} else {
+			result = this.data.toString(
+				encoding,
+				this.dataPtr,
+				this.dataPtr + arrayLength
+			);
+		}
 		this.dataPtr += arrayLength;
 		this._remainingBytes -= arrayLength;
 		return result;
 	}
 
+	/**
+	 * Wrapping subtraction function that returns a number within a set limit
+	 * @param min is a number representing the minuend
+	 * @param sub is a number representing the subtrahend
+	 * @param lim sets the upper boundary
+	 * @returns a number n with the constraint 0 <= n < lim, as long as lim >=2
+	 */
+	wrappingSub(min: number, sub: number, lim: number): number {
+		if (lim < 2) {
+			throw new Error("Upper boundary should be greater than or equal to 2");
+		}
+		return (min - sub + lim) % lim;
+	}
+
+	/**
+	 * A simple conversion helper that yields the ASCII representaion of a character.
+	 * @param char is a single character from a string represented as a number
+	 * @returns a 'string' from a single character that was represented by a number
+	 */
+	toAscii(char: number): number {
+		if (char < 32 || char > 126) {
+			char = (this.wrappingSub(char, 32, 255) % 95) + 32;
+		}
+		return char;
+	}
+
+	/**
+	 * Helper function that converts the given string type into one that only
+	 * contains printable characters. This conversion produces seemingly arbitrary
+	 * (non-smart) but printable strings, IFF the entropy of the input buffer is
+	 * high enough. Limitations are that there are collisions such that, e.g.:
+	 * the conversion of values: `0x1`, `0x42`, and `0xa2` all yield the character `B`.
+	 * @param buf - Buffer that contains arbitrary values
+	 * @param min - lower bound at which processing of the provided `Buffer` shall begin
+	 * @param max - upper bound, analogous to the lower bound
+	 * @param encoding - a valid `BufferEncoding`.
+	 * @returns a string that was sanitized and only contains printable characters
+	 */
+	bufToPrintableString(
+		buf: Buffer,
+		min: number,
+		max: number,
+		encoding: BufferEncoding
+	): string {
+		for (let i = min; i < max; i++) {
+			buf[i] = this.toAscii(buf[i]);
+		}
+		return buf.subarray(min, max).toString(encoding);
+	}
+
 	/**
 	 * Consumes the remaining bytes of the fuzzer input as a string.
 	 * @param encoding - the encoding of the string
+	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
+	 * should be forced to contain only valid printable characters
 	 * @returns a string constructed from the remaining bytes of the fuzzer input using the given encoding
 	 */
 	consumeRemainingAsString(
-		encoding: BufferEncoding | undefined = "ascii"
+		encoding: BufferEncoding | undefined = "ascii",
+		printable: boolean | undefined = false
 	): string {
-		return this.consumeString(this._remainingBytes, encoding);
+		return this.consumeString(this._remainingBytes, encoding, printable);
 	}
 
 	/**
@@ -408,16 +475,19 @@ export class FuzzedDataProvider {
 	 * @param maxArrayLength the maximum length of the array
 	 * @param maxStringLength the maximum length of the strings
 	 * @param encoding the encoding of the strings
+	 * @param printable - a boolean, which defaults to false that indicates whether consumed strings
+	 * should be forced to contain only valid printable characters
 	 * @returns an array containing strings constructed from the remaining bytes of the fuzzer input using the given encoding
 	 */
 	consumeStringArray(
 		maxArrayLength: number,
 		maxStringLength: number,
-		encoding: BufferEncoding | undefined = "ascii"
+		encoding: BufferEncoding | undefined = "ascii",
+		printable: boolean | undefined = false
 	) {
 		const strs = [];
 		while (strs.length < maxArrayLength && this.remainingBytes > 0) {
-			const str = this.consumeString(maxStringLength, encoding);
+			const str = this.consumeString(maxStringLength, encoding, printable);
 			if (str) {
 				strs.push(str);
 			}