Add parsing option to fix broken/missing nulls

Author: LachlanArthur

readme.md

@@ -62,6 +62,26 @@ data.toJs();
 */
 ```
 
+### Parsing options
+
+The main `parse()` function takes two parameters, the input string, and an options object.
+
+```js
+parse( input, options? )
+```
+
+|Option|Type|Default|Description|
+|---|---|---|---|
+|`fixNulls`|Boolean|`false`|Attempt to fix missing/broken null chars in input.<br>Useful when the input was pasted from the clipboard.|
+
+The `fixNulls` option attempts to fix the following scenarios:
+
+- Nulls have been replaced with the Unicode replacement character &#xfffd;. This can happen if the serialized string was output into a HTML page.
+- Nulls are missing. This usually happens if the value was copied to the clipboard. If the string byte count was larger than the content, then the following fixes are attempted, depending on the content of the string.
+  - If the byte count is larger by 1, and the value starts with `lambda_`, then the string is probably a serialized lambda function.
+  - If the byte count is larger by 2, and the value starts with an asterisk `*`, then the string is probably a protected property.
+  - If the byte count is larger by 2, and the other scenarios do not apply, the string is probably a private class property.
+
 ## JS Value Conversion
 
 Use the `.toJs()` method on the output to convert to native JavaScript types.

src/parse.spec.ts

@@ -111,21 +111,58 @@ describe( 'Object', () => {
 			} );
 	} );
 
-	test( 'Private properties', () => {
-		const value = parse( 'O:8:"stdClass":2:{s:3:"foo";s:3:"bar";s:16:"\u0000stdClass\u0000secret";s:3:"shh";}' );
+	test( 'Private/protected properties', () => {
+		const value = parse( 'O:8:"stdClass":3:{s:3:"foo";s:3:"bar";s:9:"\u0000*\u0000locked";s:9:"\u0000lambda_1";s:16:"\u0000stdClass\u0000secret";s:3:"shh";}' );
 		expect( value )
 			.toEqual( new PHPTypes.PHPObject(
-				73,
+				105,
 				new Map( [
 					[ new PHPTypes.PHPString( 10, 'foo' ), new PHPTypes.PHPString( 10, 'bar' ) ],
+					[ new PHPTypes.PHPString( 16, '\u0000*\u0000locked' ), new PHPTypes.PHPString( 16, '\u0000lambda_1' ) ],
 					[ new PHPTypes.PHPString( 24, '\u0000stdClass\u0000secret' ), new PHPTypes.PHPString( 10, 'shh' ) ],
 				] ),
 				'stdClass'
 			) );
 		expect( value.toJs() )
 			.toEqual( { foo: 'bar' } );
 		expect( value.toJs( { private: true } ) )
-			.toEqual( { foo: 'bar', secret: 'shh' } );
+			.toEqual( { foo: 'bar', locked: 'lambda_1', secret: 'shh' } );
+	} );
+
+	test( 'Private/protected properties - replaced nulls', () => {
+		const value = parse( 'O:8:"stdClass":3:{s:3:"foo";s:3:"bar";s:9:"\ufffd*\ufffdlocked";s:9:"\ufffdlambda_1";s:16:"\ufffdstdClass\ufffdsecret";s:3:"shh";}', { fixNulls: true } );
+		expect( value )
+			.toEqual( new PHPTypes.PHPObject(
+				105,
+				new Map( [
+					[ new PHPTypes.PHPString( 10, 'foo' ), new PHPTypes.PHPString( 10, 'bar' ) ],
+					[ new PHPTypes.PHPString( 16, '\u0000*\u0000locked' ), new PHPTypes.PHPString( 16, '\u0000lambda_1' ) ],
+					[ new PHPTypes.PHPString( 24, '\u0000stdClass\u0000secret' ), new PHPTypes.PHPString( 10, 'shh' ) ],
+				] ),
+				'stdClass'
+			) );
+		expect( value.toJs() )
+			.toEqual( { foo: 'bar' } );
+		expect( value.toJs( { private: true } ) )
+			.toEqual( { foo: 'bar', locked: 'lambda_1', secret: 'shh' } );
+	} );
+
+	test( 'Private/protected properties - missing nulls', () => {
+		const value = parse( 'O:8:"stdClass":3:{s:3:"foo";s:3:"bar";s:9:"*locked";s:9:"lambda_1";s:16:"stdClasssecret";s:3:"shh";}', { fixNulls: true } );
+		expect( value )
+			.toEqual( new PHPTypes.PHPObject(
+				100,
+				new Map( [
+					[ new PHPTypes.PHPString( 10, 'foo' ), new PHPTypes.PHPString( 10, 'bar' ) ],
+					[ new PHPTypes.PHPString( 14, '\u0000*\u0000locked' ), new PHPTypes.PHPString( 15, '\u0000lambda_1' ) ],
+					[ new PHPTypes.PHPString( 22, '\u0000\u0000stdClasssecret' ), new PHPTypes.PHPString( 10, 'shh' ) ],
+				] ),
+				'stdClass'
+			) );
+		expect( value.toJs() )
+			.toEqual( { foo: 'bar' } );
+		expect( value.toJs( { private: true } ) )
+			.toEqual( { foo: 'bar', locked: 'lambda_1', secret: 'shh' } );
 	} );
 
 } );
@@ -246,6 +283,38 @@ describe( 'String', () => {
 			.toBe( '🐊' );
 	} );
 
+	test( 'Fix broken nulls - utf-8 replacement character', () => {
+		const value = parse( 's:16:"\ufffdstdClass\ufffdsecret";', { fixNulls: true } );
+		expect( value )
+			.toEqual( new PHPTypes.PHPString( 24, '\u0000stdClass\u0000secret' ) );
+		expect( value.toJs() )
+			.toEqual( '\u0000stdClass\u0000secret' );
+	} );
+
+	test( 'Fix missing nulls - protected property', () => {
+		const value = parse( 's:9:"*secret";', { fixNulls: true } );
+		expect( value )
+			.toEqual( new PHPTypes.PHPString( 14, '\u0000*\u0000secret' ) );
+		expect( value.toJs() )
+			.toEqual( '\u0000*\u0000secret' );
+	} );
+
+	test( 'Fix missing nulls - private property', () => {
+		const value = parse( 's:16:"stdClasssecret";', { fixNulls: true } );
+		expect( value )
+			.toEqual( new PHPTypes.PHPString( 22, '\u0000\u0000stdClasssecret' ) );
+		expect( value.toJs() )
+			.toEqual( '\u0000\u0000stdClasssecret' );
+	} );
+
+	test( 'Fix missing nulls - lambda', () => {
+		const value = parse( 's:9:"lambda_1";', { fixNulls: true } );
+		expect( value )
+			.toEqual( new PHPTypes.PHPString( 15, '\u0000lambda_1' ) );
+		expect( value.toJs() )
+			.toEqual( 'lambda_1' );
+	} );
+
 	test( 'Missing opening delimiter', () => {
 		expect( () => parse( 's:1:a";' ) )
 			.toThrowError( 'Failed to parse fixed-length string' );

src/parse.ts

@@ -1,6 +1,22 @@
-let objectReferences: any[] = [ null ]; // 1-indexed
+let objectReferences: any[];
 
-export function parse( input: string, resetReferences = true ) {
+export type ParseOptions = {
+	fixNulls: boolean,
+};
+
+let parseOptions: Partial<ParseOptions> = {};
+
+export function parse( input: string, options: Partial<ParseOptions> = {} ) {
+
+	objectReferences = [ null ];
+
+	parseOptions = options;
+
+	return _parse( input );
+
+}
+
+function _parse( input: string ) {
 
 	if ( typeof input !== 'string' ) {
 		throw new TypeError( 'Input must be a string' );
@@ -10,10 +26,6 @@ export function parse( input: string, resetReferences = true ) {
 
 	const tokenIdentifier = input.substr( 0, 1 ) as PHPTypes.Identifiers;
 
-	if ( resetReferences ) {
-		objectReferences = [ null ];
-	}
-
 	if ( tokenIdentifier in PHPTypes.identifierMap ) {
 		return PHPTypes.identifierMap[ tokenIdentifier ].build( input );
 	} else {
@@ -99,7 +111,59 @@ export function parseFixedLengthString( input: string, openingDelimiter = '"', c
 		if ( input.substr( offset, closingDelimiter.length ) === closingDelimiter ) {
 			offset += closingDelimiter.length;
 		} else {
-			throw new Error( 'Failed to parse fixed-length string' );
+
+			if ( parseOptions.fixNulls ) {
+				// Let's see what we can do about this
+
+				// Maybe the nulls have been converted into a replacement character.
+				// This is the easiest to fix.
+				if ( value.substr( 0, 1 ) === '\ufffd' ) {
+					input = input.replace( /\ufffd/g, '\u0000' );
+					return parseFixedLengthString( input, openingDelimiter, closingDelimiter );
+				}
+
+				// Maybe the nulls are missing, and we overshot the end of the string.
+
+				let nullCount: number;
+				const valueStart = byteCountMatches[ 0 ].length + openingDelimiter.length;
+
+				// Check for lambdas. String should have ended one byte early, and the value should start with "lambda_".
+				nullCount = 1;
+				if (
+					decoder.decode( allBytes.slice( byteCount - nullCount, byteCount - nullCount + closingDelimiter.length + 1 ) ) === closingDelimiter + ';'
+					&& /^lambda_\d+$/.test( value.substr( 0, value.length - nullCount ) )
+				) {
+					input = input.substr( 0, valueStart ) + '\u0000' + input.substr( valueStart );
+					let [ value ] = parseFixedLengthString( input, openingDelimiter, closingDelimiter );
+					return [ value, offset - nullCount + closingDelimiter.length ]; // Original offset to keep everything matched up
+				}
+
+				// Check for protected properties with a leading asterisk. String should have ended two bytes early.
+				nullCount = 2;
+				if (
+					decoder.decode( allBytes.slice( byteCount - nullCount, byteCount - nullCount + closingDelimiter.length + 1 ) ) === closingDelimiter + ';'
+					&& value.substr( 0, 1 ) === '*'
+				) {
+					input = input.replace( '*', '\u0000*\u0000' );
+					let [ value ] = parseFixedLengthString( input, openingDelimiter, closingDelimiter );
+					return [ value, offset - nullCount + closingDelimiter.length ]; // Original offset to keep everything matched up
+				}
+
+				// Check for private properties. String should have ended two bytes early.
+				nullCount = 2;
+				if ( decoder.decode( allBytes.slice( byteCount - nullCount, byteCount - nullCount + closingDelimiter.length + 1 ) ) === closingDelimiter + ';' ) {
+					// Can't determine the class name from here.
+					// Just prefix with two nulls and check in the toJS method.
+					input = input.substr( 0, valueStart ) + '\u0000\u0000' + input.substr( valueStart );
+					let [ value ] = parseFixedLengthString( input, openingDelimiter, closingDelimiter );
+					return [ value, offset - nullCount + closingDelimiter.length ]; // Original offset to keep everything matched up
+				}
+
+			} else {
+
+				throw new Error( 'Failed to parse fixed-length string' );
+
+			}
 		}
 
 		return [ value, offset ];
@@ -268,13 +332,13 @@ export namespace PHPTypes {
 
 				for ( let i = 0; i < count; i++ ) {
 
-					const key = parse( input.substr( offset ), false ) as unknown as K;
+					const key = _parse( input.substr( offset ) ) as unknown as K;
 					offset += key.length;
 
 					// Keys cannot be referenced
 					objectReferences.pop();
 
-					const value = parse( input.substr( offset ), false );
+					const value = _parse( input.substr( offset ) );
 					offset += value.length;
 
 					map.set( key, value );
@@ -361,7 +425,9 @@ export namespace PHPTypes {
 
 				if ( typeof key === 'string' && key.charCodeAt( 0 ) === 0 ) {
 					if ( options.private ) {
-						key = key.replace( /\u0000.+\u0000/, '' );
+						key = key.replace( new RegExp( `\u0000(\\*|${instance.className})\u0000` ), '' );
+						// Also handle double nulls caused by fixing missing nulls
+						key = key.replace( new RegExp( `\u0000\u0000${instance.className}` ), '' );
 					} else {
 						continue;
 					}
@@ -500,6 +566,12 @@ export namespace PHPTypes {
 		}
 
 		static toJs( instance: PHPString ) {
+
+			// Remove nulls from lambdas
+			if ( /^\u0000lambda_\d+$/.test( instance.value ) ) {
+				return instance.value.replace( /\u0000/g, '' );
+			}
+
 			return instance.value;
 		}