23131a54-c6fa-42ef-8653-fb40299741f1

Committed 04 Mar 2025 07:56AM UTC coverage: 68.364% (-1.3%) from 69.709%

Build # 23131a54-c6fa-42ef-8653-fb40299741f1

Build Type

Pull #3904

circleci

Committed by

sr258

Commit Message

chore: fix package lock after merge

Pull Request Pull Request #3904: feat: file sanitizers and malware scanners

Run Details

2294 of 3850 branches covered (59.58%)

Branch coverage included in aggregate %.

79 of 84 new or added lines in 6 files covered. (94.05%)

170 existing lines in 8 files now uncovered.

5172 of 7071 relevant lines covered (73.14%)

339.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.21

/packages/h5p-server/src/ContentFileScanner.ts

import { ContentScanner } from './ContentScanner';
import Logger from './helpers/Logger';
import LibraryManager from './LibraryManager';
import { ILibraryName, ISemanticsEntry } from './types';

const log = new Logger('ContentFileScanner');

/**
 * Describes a reference to a file that is embedded inside the content.
 */
export interface IFileReference {
    /**
     * Information about where the file reference was found
     */
    context: {
        /**
         * The path of the object **inside the params tree**. You can use this
         * path to later modify the params, if needed.
         */
        jsonPath: string;
        /**
         * The raw parameters of the object.
         */
        params: any;
        /**
         * The semantic structure of the object (as defined in semantics.json).
         *
         * Can be null or undefined if there is no semantic structure for the
         * element (happens if the file can be found somewhere that is not
         * described by the semantics)
         */
        semantics?: ISemanticsEntry;
    };
    /**
     * The path of the file **inside the H5P content directory** as can be used
     * to reference it in ContentManager (without any suffixes like #tmp).
     */
    filePath: string;
    /**
     * The mime type specified in the params
     */
    mimeType?: string;
    /**
     * If true, the file was marked as temporary (by the #tmp suffix). The
     * suffix is **not included** in filePath
     */
    temporary: boolean;
}

/**
 * Scans the content parameters (=content.json) of a piece of content and
 * returns a list of references to file that are embedded inside the content.
 */
export class ContentFileScanner extends ContentScanner {
    constructor(libraryManager: LibraryManager) {
        super(libraryManager);
        log.info('initialize');
    }

    /**
     * Used to differentiate between local files and URLs.
     */
    private static urlRegExp: RegExp = /^https?:\/\//;

    /**
     * Loads the specified content from the ContentManager and scans its
     * parameters (= content.json) for references to local files (= audio,
     * video, images, generic files).
     * @param contentId the content to scan
     * @param user the user who wants to access the file
     * @returns a list of local files
     */
    public async scanForFiles(
        mainParams: any,
        mainLibraryName: ILibraryName
    ): Promise<IFileReference[]> {
        const results: IFileReference[] = [];
        await this.scanContent(
            mainParams,
            mainLibraryName,
            (semantics, params, jsonPath) => {
                log.debug(
                    `Checking entry ${jsonPath} (type ${semantics.type})`
                );
                switch (semantics.type) {
                    case 'file':
                    case 'image': {
                        log.debug(`found ${semantics.type} element`);
                        const element = this.pushIfDefined(
                            results,
                            this.checkFileElement(semantics, params, jsonPath)
                        );
                        if (element) {
                            log.debug(
                                `Found file is a reference to ${element.filePath}`
                            );
                        }
                        if (params.originalImage) {
                            const originalImageElement = this.pushIfDefined(
                                results,
                                this.checkFileElement(
                                    null,
                                    params.originalImage,
                                    `${jsonPath}.originalImage`
                                )
                            );
                            if (originalImageElement) {
                                log.debug(
                                    `Found file is a reference to ${originalImageElement.filePath}`
                                );
                            }
                        }
                        return true; // returning true aborts further recursion
                    }
                    case 'video':
                    case 'audio':
                        if (Array.isArray(params)) {
                            for (
                                let index = 0;
                                index < params.length;
                                index += 1
                            ) {
                                const arrayElement = this.pushIfDefined(
                                    results,
                                    this.checkFileElement(
                                        null,
                                        params[index],
                                        `${jsonPath}[${index}]`
                                    )
                                );
                                if (arrayElement) {
                                    log.debug(
                                        `Found file is a reference to ${arrayElement.filePath}`
                                    );
                                }
                            }
                        }
                        return true; // returning true aborts further recursion
                    default:
                        return false;
                }
            }
        );
        return results;
    }

    /**
     * Checks if an element in the parameter tree contains a valid reference to
     * a local file and removes temporary markers.
     * @param semantics The semantic structure of the element to check
     * @param params the parameter object of the element to check
     * @param jsonPath the JSONPath at which the element can be found in the
     * parameter object
     * @returns an object with information about the file reference; undefined
     * if the file reference is invalid
     */
    private checkFileElement(
        semantics: ISemanticsEntry,
        params: any,
        jsonPath: string
    ): IFileReference {
        if (!params.path) {
            // Path shouldn't be empty, but we simply ignore the entry in this
            // case.
            return undefined;
        }
        if (ContentFileScanner.urlRegExp.test(params.path)) {
            // If the file is a reference to a URL, we don't return it.
            return undefined;
        }

        let temporary = false;
        let cleanFileReferencePath = params.path;
        if (params.path.endsWith('#tmp')) {
            // files marked as temporary will be identified as such
            temporary = true;
            cleanFileReferencePath = params.path.substr(
                0,
                params.path.length - 4
            );
        }

        return {
            context: { semantics, params, jsonPath },
            filePath: cleanFileReferencePath,
            mimeType: params.mime,
            temporary
        };
    }

    /**
     * Helper function that pushes an item to an array if the item is defined.
     * @param array the array to push to
     * @param item the item to push
     * @returns the item (if defined); otherwise undefined
     */
    private pushIfDefined<T>(array: T[], item: T): T {
        if (item !== undefined) {
            array.push(item);
            return item;
        }
        return undefined;
    }
}

1	import { ContentScanner } from './ContentScanner';	26✔
2	import Logger from './helpers/Logger';	26✔
3	import LibraryManager from './LibraryManager';
4	import { ILibraryName, ISemanticsEntry } from './types';
5
6	const log = new Logger('ContentFileScanner');	26✔
7
8	/**
9	* Describes a reference to a file that is embedded inside the content.
10	*/
11	export interface IFileReference {
12	/**
13	* Information about where the file reference was found
14	*/
15	context: {
16	/**
17	* The path of the object inside the params tree. You can use this
18	* path to later modify the params, if needed.
19	*/
20	jsonPath: string;
21	/**
22	* The raw parameters of the object.
23	*/
24	params: any;
25	/**
26	* The semantic structure of the object (as defined in semantics.json).
27	*
28	* Can be null or undefined if there is no semantic structure for the
29	* element (happens if the file can be found somewhere that is not
30	* described by the semantics)
31	*/
32	semantics?: ISemanticsEntry;
33	};
34	/**
35	* The path of the file inside the H5P content directory as can be used
36	* to reference it in ContentManager (without any suffixes like #tmp).
37	*/
38	filePath: string;
39	/**
40	* The mime type specified in the params
41	*/
42	mimeType?: string;
43	/**
44	* If true, the file was marked as temporary (by the #tmp suffix). The
45	* suffix is not included in filePath
46	*/
47	temporary: boolean;
48	}
49
50	/**
51	* Scans the content parameters (=content.json) of a piece of content and
52	* returns a list of references to file that are embedded inside the content.
53	*/
54	export class ContentFileScanner extends ContentScanner {	26✔
55	constructor(libraryManager: LibraryManager) {
56	super(libraryManager);	128✔
57	log.info('initialize');	128✔
58	}
59
60	/**
61	* Used to differentiate between local files and URLs.
62	*/
63	private static urlRegExp: RegExp = /^https?:\/\//;	26✔
64
65	/**
66	* Loads the specified content from the ContentManager and scans its
67	* parameters (= content.json) for references to local files (= audio,
68	* video, images, generic files).
69	* @param contentId the content to scan
70	* @param user the user who wants to access the file
71	* @returns a list of local files
72	*/
73	public async scanForFiles(
74	mainParams: any,
75	mainLibraryName: ILibraryName
76	): Promise<IFileReference[]> {
77	const results: IFileReference[] = [];	126✔
78	await this.scanContent(	126✔
79	mainParams,
80	mainLibraryName,
81	(semantics, params, jsonPath) => {
82	log.debug(	672✔
83	`Checking entry ${jsonPath} (type ${semantics.type})`
84	);
85	switch (semantics.type) {	672!
86	case 'file':
87	case 'image': {
88	log.debug(`found ${semantics.type} element`);	116✔
89	const element = this.pushIfDefined(	116✔
90	results,
91	this.checkFileElement(semantics, params, jsonPath)
92	);
93	if (element) {	116✔
94	log.debug(	116✔
95	`Found file is a reference to ${element.filePath}`
96	);
97	}
98	if (params.originalImage) {	116!
UNCOV 99	const originalImageElement = this.pushIfDefined(	×
100	results,
101	this.checkFileElement(
102	null,
103	params.originalImage,
104	`${jsonPath}.originalImage`
105	)
106	);
UNCOV 107	if (originalImageElement) {	×
UNCOV 108	log.debug(	×
109	`Found file is a reference to ${originalImageElement.filePath}`
110	);
111	}
112	}
113	return true; // returning true aborts further recursion	116✔
114	}
115	case 'video':
116	case 'audio':
UNCOV 117	if (Array.isArray(params)) {	×
UNCOV 118	for (	×
UNCOV 119	let index = 0;	×
120	index < params.length;
121	index += 1
122	) {
UNCOV 123	const arrayElement = this.pushIfDefined(	×
124	results,
125	this.checkFileElement(
126	null,
127	params[index],
128	`${jsonPath}[${index}]`
129	)
130	);
UNCOV 131	if (arrayElement) {	×
UNCOV 132	log.debug(	×
133	`Found file is a reference to ${arrayElement.filePath}`
134	);
135	}
136	}
137	}
UNCOV 138	return true; // returning true aborts further recursion	×
139	default:
140	return false;	556✔
141	}
142	}
143	);
144	return results;	126✔
145	}
146
147	/**
148	* Checks if an element in the parameter tree contains a valid reference to
149	* a local file and removes temporary markers.
150	* @param semantics The semantic structure of the element to check
151	* @param params the parameter object of the element to check
152	* @param jsonPath the JSONPath at which the element can be found in the
153	* parameter object
154	* @returns an object with information about the file reference; undefined
155	* if the file reference is invalid
156	*/
157	private checkFileElement(
158	semantics: ISemanticsEntry,
159	params: any,
160	jsonPath: string
161	): IFileReference {
162	if (!params.path) {	116!
163	// Path shouldn't be empty, but we simply ignore the entry in this
164	// case.
UNCOV 165	return undefined;	×
166	}
167	if (ContentFileScanner.urlRegExp.test(params.path)) {	116!
168	// If the file is a reference to a URL, we don't return it.
UNCOV 169	return undefined;	×
170	}
171
172	let temporary = false;	116✔
173	let cleanFileReferencePath = params.path;	116✔
174	if (params.path.endsWith('#tmp')) {	116✔
175	// files marked as temporary will be identified as such
176	temporary = true;	38✔
177	cleanFileReferencePath = params.path.substr(	38✔
178	0,
179	params.path.length - 4
180	);
181	}
182
183	return {	116✔
184	context: { semantics, params, jsonPath },
185	filePath: cleanFileReferencePath,
186	mimeType: params.mime,
187	temporary
188	};
189	}
190
191	/**
192	* Helper function that pushes an item to an array if the item is defined.
193	* @param array the array to push to
194	* @param item the item to push
195	* @returns the item (if defined); otherwise undefined
196	*/
197	private pushIfDefined<T>(array: T[], item: T): T {
198	if (item !== undefined) {	116✔
199	array.push(item);	116✔
200	return item;	116✔
201	}
UNCOV 202	return undefined;	×
203	}
204	}

Lumieducation / H5P-Nodejs-library / 23131a54-c6fa-42ef-8653-fb40299741f1

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous