Minor improvements for base64 content + HAR _content is always base64-encoded

Author: emaheuxPEREN

src/components/intercept/config/android-device-config.tsx

@@ -64,10 +64,7 @@ const Spacer = styled.div`
 `;
 
 function urlSafeBase64(content: string) {
-    return stringToBuffer(content)
-        .toString('base64')
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_');
+    return stringToBuffer(content).toString('base64url');
 }
 
 function getConfigRequestIds(eventsStore: EventsStore) {

src/model/events/content-types.ts

@@ -147,15 +147,25 @@ export function getDefaultMimeType(contentType: ViewableContentType): string {
     return _.findKey(mimeTypeToContentTypeMap, (c) => c === contentType)!;
 }
 
-function isValidBase64Byte(byte: number) {
+function isValidAlphaNumOrSpace(byte: number) {
     return (byte >= 65 && byte <= 90) || // A-Z
         (byte >= 97 && byte <= 122) ||   // a-z
         (byte >= 48 && byte <= 57) ||    // 0-9
-        byte === 43 ||                   // +
-        byte === 47 ||                   // /
         byte === 61;                     // =
 }
 
+function isValidStandardBase64Byte(byte: number) {
+    // + / (standard)
+    return byte === 43 || byte === 47
+        || isValidAlphaNumOrSpace(byte);
+}
+
+function isValidURLSafeBase64Byte(byte: number) {
+    // - _ (URL-safe version)
+    return byte === 45 || byte === 95
+        || isValidAlphaNumOrSpace(byte);
+}
+
 export function getCompatibleTypes(
     contentType: ViewableContentType,
     rawContentType: string | undefined,
@@ -203,10 +213,11 @@ export function getCompatibleTypes(
 
     if (
         body &&
-        body.length > 0 &&
-        body.length % 4 === 0 && // Multiple of 4 bytes
-        body.length < 1000 * 100 && // < 100 KB of content
-        body.every(isValidBase64Byte)
+        !types.has('base64') &&
+        body.length >= 8 &&
+        // body.length % 4 === 0 && // Multiple of 4 bytes (final padding may be omitted)
+        body.length < 100_000 && // < 100 KB of content
+        (body.every(isValidStandardBase64Byte) || body.every(isValidURLSafeBase64Byte))
     ) {
         types.add('base64');
     }

src/model/http/har.ts

@@ -51,15 +51,15 @@ interface HarLog extends HarFormat.Log {
 export type RequestContentData = {
     text: string;
     size: number;
-    encoding?: 'base64';
+    encoding: 'base64';
     comment?: string;
 };
 
 export interface ExtendedHarRequest extends HarFormat.Request {
     _requestBodyStatus?:
-        | 'discarded:too-large'
-        | 'discarded:not-representable'
-        | 'discarded:not-decodable';
+    | 'discarded:too-large'
+    | 'discarded:not-representable' // to indicate that extended field `_content` is populated with base64 `postData`
+    | 'discarded:not-decodable';
     _content?: RequestContentData;
     _trailers?: HarFormat.Header[];
 }
@@ -302,7 +302,7 @@ async function generateHarResponse(
 
     const decoded = await response.body.decodedPromise;
 
-    let responseContent: { text: string, encoding?: string } | { comment: string};
+    let responseContent: { text: string, encoding?: string } | { comment: string };
     try {
         if (!decoded || decoded.byteLength > options.bodySizeLimit) {
             // If no body or the body is too large, don't include it
@@ -435,10 +435,10 @@ function generateHarWebSocketMessage(
     return {
         // Note that msg.direction is from the perspective of Mockttp, not the client.
         type: message.direction === 'sent'
-                ? 'receive'
+            ? 'receive'
             : message.direction === 'received'
                 ? 'send'
-            : unreachableCheck(message.direction),
+                : unreachableCheck(message.direction),
 
         opcode: message.isBinary ? 2 : 1,
         data: message.isBinary
@@ -751,7 +751,7 @@ function parseHttpVersion(
 }
 
 function parseHarRequestContents(data: RequestContentData): Buffer {
-    if (data.encoding && Buffer.isEncoding(data.encoding)) {
+    if (Buffer.isEncoding(data.encoding)) {
         return Buffer.from(data.text, data.encoding);
     }
 

src/services/ui-worker-formatters.ts

@@ -39,7 +39,9 @@ const WorkerFormatters = {
         }
     },
     base64: (content: Buffer) => {
-        return Buffer.from(content.toString('utf8'), 'base64').toString('utf8');
+        const b64 = content.toString('ascii');
+        const encoding = b64.match(/[-_]/) ? 'base64url' : 'base64';
+        return Buffer.from(b64, encoding).toString('utf8');
     },
     markdown: (content: Buffer) => {
         return content.toString('utf8');

test/unit/model/http/content-types.spec.ts

@@ -1,6 +1,6 @@
 import { expect } from '../../../test-setup';
 
-import { getContentType, getEditableContentType } from '../../../../src/model/events/content-types';
+import { getContentType, getEditableContentType, getCompatibleTypes } from '../../../../src/model/events/content-types';
 
 describe('Content type parsing', () => {
     describe('getContentType', () => {
@@ -81,4 +81,21 @@ describe('Content type parsing', () => {
             expect(ct).to.equal(undefined);
         });
     });
+
+    describe('getCompatibleTypes', () => {
+        it('should detect standard base64 text', () => {
+            const cts = getCompatibleTypes('text', 'text/plain', Buffer.from('FWTkm2+ZvMo=', 'ascii'));
+            expect(cts).to.deep.equal(['text', 'base64', 'raw']);
+        });
+
+        it('should detect URL-safe (without padding) base64 text', () => {
+            const cts = getCompatibleTypes('text', 'text/plain', Buffer.from('FWTkm2-ZvMo', 'ascii'));
+            expect(cts).to.deep.equal(['text', 'base64', 'raw']);
+        });
+
+        it('should work even if first character is not ASCII', () => {
+            const cts = getCompatibleTypes('raw', 'application/octet-stream', Buffer.from('1f8d08', 'hex')); // GZIP magic bytes
+            expect(cts).to.deep.equal(['raw', 'text']);
+        });
+    });
 });