Confirm Before Opening Program Attachments and Load Only HTTPS Images

Opening a project attachment whose type runs as a program or script
(executables, installers, shortcuts, shell and PowerShell scripts, macOS
command files and apps, Linux desktop entries) now asks for confirmation
first. The check lives in libslic3r as is_executable_file_name and ignores
the trailing dots and spaces Windows strips from file names.

Images in project descriptions are kept only when they load over https,
so opening the Project tab no longer issues plain-http requests.

resources/web/model/model.js

@@ -214,9 +214,9 @@ function ShowModelInfo( pModel )
 	
 	SendWXDebugInfo("Model Name:  "+sModelName);
 	
-	$('#ModelName').html(sModelName);
+	$('#ModelName').text(sModelName);
 	$('#ModelName').attr('title',sModelName);
-    $('#ModelAuthorName').html(sModelAuthor);
+    $('#ModelAuthorName').text(sModelAuthor);
 	
 	switch(UploadType)
 	{
@@ -268,7 +268,7 @@ function ShowModelInfo( pModel )
 			break;
 	}
 	
-	$('#Model_Desc').html( html_decode(sModelDesc) );
+	$('#Model_Desc').empty().append( SanitizeDescHtml( html_decode(sModelDesc) ) );
 			
 	let ModelPreviewList=pModel.preview_img;				
     let TotalPreview=ModelPreviewList.length;
@@ -281,16 +281,15 @@ function ShowModelInfo( pModel )
 	
     if(TotalPreview>0)
 	{
-		let htmlPreview='';
+		$('#ModelPreviewList').empty();
 		for(let pn=0;pn<TotalPreview;pn++)			
 		{	
 			//let FTmpPath=decodeURIComponent(ModelPreviewList[pn]);
 			let FTmpPath=ModelPreviewList[pn]['filepath'];
 			
-			htmlPreview+='<div class="swiper-slide"><img class="Model_PrevImg" src="'+FTmpPath+'" /></div>';
+			$('#ModelPreviewList').append( $('<div class="swiper-slide"></div>').append( $('<img class="Model_PrevImg" />').attr('src',FTmpPath) ) );
 		}
 			
-	    $('#ModelPreviewList').html(htmlPreview);
 		$('#Model_Preview_Image').viewer({
 			title: false,
 		    fullsreen: false,
@@ -410,7 +409,8 @@ function ConstructFileHtml( ID, pItem )
 {
 	let fTotal=pItem.length;
 	
-	let strHtml='';
+	let pBoard=$('#'+ID+'  .FileListBoard');
+	pBoard.empty();
 	for( let f=0;f<fTotal;f++ )
 	{
 		let pOne=pItem[f];
@@ -443,39 +443,139 @@ function ConstructFileHtml( ID, pItem )
 			ImgPath='img/default.png';			
 		}		
 			
-		//Add html
+		//Add html. File names come from the 3MF, so build the nodes rather than concatenating markup.
+		let pIconImg=$('<img />').attr('src',ImgPath);
+		let pMenu=$('<div class="FileMenu"><img src="img/s.svg" /></div>');
 		if( strClass!='ImageIcon' )
 		{
-		strHtml+='<div class="FileItem">'+
+			pMenu.on('click', function(){ OnClickOpenFile(tPath); });
-				 '	<div class="'+strClass+'"><img src="'+ImgPath+'" /></div>'+
-				 '	<div class="FileText">'+
-			     '		<div class="FileName">'+tName+'</div>'+
-				 '	</div>'+
-				 '	<div class="FileMenu" onClick="OnClickOpenFile(\''+tPath+'\')"><img src="img/s.svg" /></div>'+
-				 '</div>';
 		}
 		else
 		{
 			ImgID++;
 			let TmpImgID="AF"+ImgID;
 			
-		strHtml+='<div class="FileItem">'+
+			pIconImg.attr('id',TmpImgID);
-				 '	<div class="'+strClass+'"><img id="'+TmpImgID+'" src="'+ImgPath+'" /></div>'+
+			pMenu.on('click', function(){ OnClickOpenImage(TmpImgID); });
-				 '	<div class="FileText">'+
-			     '		<div class="FileName">'+tName+'</div>'+
-				 '	</div>'+
-				 '	<div class="FileMenu" onClick="OnClickOpenImage(\''+TmpImgID+'\')"><img src="img/s.svg" /></div>'+
-				 '</div>';			
 		}
+		
+		let pFileItem=$('<div class="FileItem"></div>');
+		pFileItem.append( $('<div></div>').addClass(strClass).append(pIconImg) );
+		pFileItem.append( $('<div class="FileText"></div>').append( $('<div class="FileName"></div>').text(tName).attr('title',tName) ) );
+		pFileItem.append( pMenu );
+		pBoard.append( pFileItem );
 	}
 	
-	$('#'+ID+'  .FileListBoard').html(strHtml);
-	
     if( fTotal>0 )
 		$('#'+ID).show();
 }
 
 
+// Descriptions are untrusted 3MF metadata that may carry rich-text HTML (e.g. from MakerWorld).
+// Rebuild them from an inert parse, keeping only plain formatting tags and http(s) links and images.
+var DescAllowedTags=['P','BR','B','STRONG','I','EM','U','S','STRIKE','DEL','INS','SUB','SUP','SMALL','MARK',
+	'Q','ABBR','KBD','WBR','H1','H2','H3','H4','H5','H6','UL','OL','LI','DL','DT','DD','BLOCKQUOTE','PRE','CODE',
+	'HR','SPAN','DIV','FIGURE','FIGCAPTION','TABLE','CAPTION','THEAD','TBODY','TFOOT','TR','TH','TD','A','IMG'];
+// Plain attributes kept per tag; the numeric ones must be plain non-negative integers.
+var DescAllowedAttrs={'IMG':['alt','title','width','height'],'TD':['colspan','rowspan'],'TH':['colspan','rowspan'],'OL':['start']};
+var DescNumericAttrs=['width','height','colspan','rowspan','start'];
+// Dropped together with their content; any other unknown tag is unwrapped to its children.
+var DescDroppedTags=['SCRIPT','STYLE','TEMPLATE','NOSCRIPT','TEXTAREA','TITLE','IFRAME','FRAME','OBJECT','EMBED','SVG','MATH'];
+
+function IsHttpUrl( strUrl )
+{
+	// The scheme must be written as is, so nothing the URL parser would strip can precede or split it.
+	if( typeof strUrl!='string' || !/^https?:/i.test(strUrl) )
+		return false;
+	try
+	{
+		let sProtocol=new URL(strUrl).protocol;
+		return sProtocol=='http:' || sProtocol=='https:';
+	}
+	catch(e)
+	{
+		return false;
+	}
+}
+
+// Images load as soon as the page opens, so only https sources are kept: no plain-http requests to the local network.
+function IsHttpsUrl( strUrl )
+{
+	return IsHttpUrl(strUrl) && new URL(strUrl).protocol=='https:';
+}
+
+// Embedded YouTube players become a plain link to the video.
+function GetYouTubeEmbedUrl( pNode )
+{
+	let sSrc=pNode.getAttribute('src');
+	if( !IsHttpUrl(sSrc) )
+		return null;
+	let pUrl=new URL(sSrc);
+	return ( pUrl.origin=='https://www.youtube.com' && pUrl.pathname.indexOf('/embed/')==0 ) ? pUrl.href : null;
+}
+
+function CopyDescNodes( pSrc, pDst )
+{
+	for( let pNode=pSrc.firstChild;pNode!=null;pNode=pNode.nextSibling )
+	{
+		if( pNode.nodeType==Node.TEXT_NODE )
+		{
+			pDst.appendChild( document.createTextNode(pNode.nodeValue) );
+			continue;
+		}
+		if( pNode.nodeType!=Node.ELEMENT_NODE )
+			continue;
+		
+		let sTag=pNode.nodeName.toUpperCase();
+		if( sTag=='IFRAME' )
+		{
+			let sVideoUrl=GetYouTubeEmbedUrl(pNode);
+			if( sVideoUrl!=null )
+			{
+				let pLink=document.createElement('A');
+				pLink.setAttribute('href',sVideoUrl);
+				pLink.textContent=sVideoUrl;
+				pDst.appendChild(pLink);
+			}
+			continue;
+		}
+		if( $.inArray(sTag,DescDroppedTags)>=0 )
+			continue;
+		if( $.inArray(sTag,DescAllowedTags)<0 )
+		{
+			CopyDescNodes(pNode,pDst);
+			continue;
+		}
+		
+		let pElem=document.createElement(sTag);
+		if( sTag=='A' && IsHttpUrl(pNode.getAttribute('href')) )
+			pElem.setAttribute('href',pNode.getAttribute('href'));
+		else if( sTag=='IMG' )
+		{
+			if( !IsHttpsUrl(pNode.getAttribute('src')) )
+				continue;
+			pElem.setAttribute('src',pNode.getAttribute('src'));
+		}
+		$.each( DescAllowedAttrs[sTag]||[], function(i,sAttr){
+			let sValue=pNode.getAttribute(sAttr);
+			if( sValue!=null && ( $.inArray(sAttr,DescNumericAttrs)<0 || /^\d+$/.test(sValue) ) )
+				pElem.setAttribute(sAttr,sValue);
+		});
+		CopyDescNodes(pNode,pElem);
+		pDst.appendChild(pElem);
+	}
+}
+
+function SanitizeDescHtml( strHtml )
+{
+	let pFragment=document.createDocumentFragment();
+	// A DOMParser document is inert: it runs no scripts and loads no resources.
+	let pDoc=new DOMParser().parseFromString(strHtml,'text/html');
+	if( pDoc && pDoc.body )
+		CopyDescNodes(pDoc.body,pFragment);
+	return pFragment;
+}
+
 function ShowProfilelInfo( pProfile )
 {
 	//==========Profile Info==========
@@ -483,10 +583,10 @@ function ShowProfilelInfo( pProfile )
 	let sProfileAuthor=decodeURIComponent(pProfile.author);
 	let sProfileDesc=decodeURIComponent(pProfile.description);
 	
-	$('#ProfileName').html(sProfileName);
+	$('#ProfileName').text(sProfileName);
-    $('#ProfileAuthor').html(sProfileAuthor);
+    $('#ProfileAuthor').text(sProfileAuthor);
 		
-	$('#Profile_Desc').html( html_decode(sProfileDesc) );
+	$('#Profile_Desc').empty().append( SanitizeDescHtml( html_decode(sProfileDesc) ) );
 			
 	let ProfilePreviewList=pProfile.preview_img;				
     let TotalPreview=ProfilePreviewList.length;
@@ -499,15 +599,14 @@ function ShowProfilelInfo( pProfile )
 	
     if(TotalPreview>0)
 	{
-		let htmlPreview='';
+		$('#ProfilePreviewList').empty();
 		for(let pn=0;pn<TotalPreview;pn++)			
 		{	
 			let FTmpPath=ProfilePreviewList[pn]['filepath'];
 			
-			htmlPreview+='<div class="swiper-slide"><img class="Model_PrevImg" src="'+FTmpPath+'" /></div>';
+			$('#ProfilePreviewList').append( $('<div class="swiper-slide"></div>').append( $('<img class="Model_PrevImg" />').attr('src',FTmpPath) ) );
 		}
 			
-		$('#ProfilePreviewList').html(htmlPreview);
 		$('#Profile_Preview_Image').viewer({
 			title: false,
 		    fullsreen: false,

src/libslic3r/Format/3mf.cpp

@@ -307,17 +307,14 @@ bool PrusaFileParser::check_3mf_from_prusa(const std::string filename)
 
             mz_zip_archive_file_stat stat;
             if (!mz_zip_reader_file_stat(&archive, model_file_index, &stat)) goto EXIT;
-            // expat sizes its buffer with an int, so a larger entry cannot be parsed in one piece.
-            if (stat.m_uncomp_size > static_cast<mz_uint64>(std::numeric_limits<int>::max())) goto EXIT;
 
-            const int xml_size = static_cast<int>(stat.m_uncomp_size);
+            void *parser_buffer = XML_GetBuffer(m_parser, (int) stat.m_uncomp_size);
-            void *parser_buffer = XML_GetBuffer(m_parser, xml_size);
             if (parser_buffer == nullptr) goto EXIT;
 
-            mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, static_cast<size_t>(xml_size), 0);
+            mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, (size_t) stat.m_uncomp_size, 0);
             if (res == 0) goto EXIT;
 
-            XML_ParseBuffer(m_parser, xml_size, 1);
+            XML_ParseBuffer(m_parser, (int) stat.m_uncomp_size, 1);
         }
     }
 
@@ -1349,26 +1346,19 @@ ModelVolumeType type_from_string(const std::string &s)
         XML_SetUserData(m_xml_parser, (void*)this);
         XML_SetElementHandler(m_xml_parser, _3MF_Importer::_handle_start_config_xml_element, _3MF_Importer::_handle_end_config_xml_element);
 
-        // expat sizes its buffer with an int, so a larger entry cannot be parsed in one piece.
+        void* parser_buffer = XML_GetBuffer(m_xml_parser, (int)stat.m_uncomp_size);
-        if (stat.m_uncomp_size > static_cast<mz_uint64>(std::numeric_limits<int>::max())) {
-            add_error("Found invalid size");
-            return false;
-        }
-        const int xml_size = static_cast<int>(stat.m_uncomp_size);
-
-        void* parser_buffer = XML_GetBuffer(m_xml_parser, xml_size);
         if (parser_buffer == nullptr) {
             add_error("Unable to create buffer");
             return false;
         }
 
-        mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, static_cast<size_t>(xml_size), 0);
+        mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, (size_t)stat.m_uncomp_size, 0);
         if (res == 0) {
             add_error("Error while reading config data to buffer");
             return false;
         }
 
-        if (!XML_ParseBuffer(m_xml_parser, xml_size, 1)) {
+        if (!XML_ParseBuffer(m_xml_parser, (int)stat.m_uncomp_size, 1)) {
             char error_buf[1024];
             ::sprintf(error_buf, "Error (%s) while parsing xml file at line %d", XML_ErrorString(XML_GetErrorCode(m_xml_parser)), (int)XML_GetCurrentLineNumber(m_xml_parser));
             add_error(error_buf);

src/libslic3r/Format/bbs_3mf.cpp

@@ -2508,26 +2508,19 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         XML_SetEntityDeclHandler(m_xml_parser, nullptr);
         XML_SetExternalEntityRefHandler(m_xml_parser, nullptr);
 
-        // expat sizes its buffer with an int, so a larger entry cannot be parsed in one piece.
+        void* parser_buffer = XML_GetBuffer(m_xml_parser, (int)stat.m_uncomp_size);
-        if (stat.m_uncomp_size > static_cast<mz_uint64>(std::numeric_limits<int>::max())) {
-            add_error("Found invalid size");
-            return false;
-        }
-        const int xml_size = static_cast<int>(stat.m_uncomp_size);
-
-        void* parser_buffer = XML_GetBuffer(m_xml_parser, xml_size);
         if (parser_buffer == nullptr) {
             add_error("Unable to create buffer");
             return false;
         }
 
-        mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, static_cast<size_t>(xml_size), 0);
+        mz_bool res = mz_zip_reader_extract_file_to_mem(&archive, stat.m_filename, parser_buffer, (size_t)stat.m_uncomp_size, 0);
         if (res == 0) {
             add_error("Error while reading config data to buffer");
             return false;
         }
 
-        if (!XML_ParseBuffer(m_xml_parser, xml_size, 1)) {
+        if (!XML_ParseBuffer(m_xml_parser, (int)stat.m_uncomp_size, 1)) {
             char error_buf[1024];
             ::snprintf(error_buf, 1024, "Error (%s) while parsing xml file at line %d", XML_ErrorString(XML_GetErrorCode(m_xml_parser)), (int)XML_GetCurrentLineNumber(m_xml_parser));
             add_error(error_buf);

src/libslic3r/Utils.hpp

@@ -260,6 +260,11 @@ extern bool is_json_file(const std::string& path);
 // Both '/' and '\\' are treated as separators on every platform, so an archive rejected on one OS
 // is rejected on all of them.
 extern bool is_path_within_root(const std::string &rel_path, const boost::filesystem::path &root);
+// True if path names an entry strictly inside root: it must be spelled with root as its prefix,
+// and must still resolve inside root once symlinks are followed.
+extern bool is_absolute_path_within_root(const boost::filesystem::path &path, const boost::filesystem::path &root);
+// True if opening a file with this name through the desktop would run it as a program or script.
+extern bool is_executable_file_name(const std::string &file_name);
 
 // Orca: custom protocal support utils
 inline bool is_orca_open(const std::string& url) { return boost::starts_with(url, "orcaslicer://open"); }

src/libslic3r/utils.cpp

@@ -70,6 +70,7 @@
 #include <boost/shared_ptr.hpp>
 
 #include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/nowide/fstream.hpp>
@@ -1112,6 +1113,34 @@ bool is_path_within_root(const std::string &rel_path, const boost::filesystem::p
     }
 }
 
+bool is_absolute_path_within_root(const boost::filesystem::path &path, const boost::filesystem::path &root)
+{
+    const boost::filesystem::path rel = path.lexically_relative(root);
+    return !rel.empty() && rel != "." && is_path_within_root(rel.string(), root);
+}
+
+bool is_executable_file_name(const std::string &file_name)
+{
+    static const std::vector<std::string> executable_extensions = {
+        // Windows
+        "exe", "com", "bat", "cmd", "scr", "pif", "msi", "msp", "msc", "cpl", "lnk", "url", "hta", "js", "jse", "vbs",
+        "vbe", "wsf", "wsh", "ps1", "psm1", "reg", "jar", "appref-ms", "scf", "inf", "py", "pyw",
+        // macOS
+        "app", "command", "pkg", "terminal", "workflow",
+        // Linux
+        "sh", "bash", "run", "desktop", "appimage"};
+    // Windows ignores trailing dots and spaces, so "setup.exe." still runs as an .exe.
+    const size_t end = file_name.find_last_not_of(". ");
+    if (end == std::string::npos)
+        return false;
+    const std::string name = file_name.substr(0, end + 1);
+    const size_t      dot  = name.find_last_of('.');
+    if (dot == std::string::npos || name.find_first_of("/\\", dot) != std::string::npos)
+        return false;
+    const std::string extension = boost::algorithm::to_lower_copy(name.substr(dot + 1));
+    return std::find(executable_extensions.begin(), executable_extensions.end(), extension) != executable_extensions.end();
+}
+
 bool is_img_file(const std::string &path)
 {
 	return boost::iends_with(path, ".png") || boost::iends_with(path, ".svg");

src/slic3r/GUI/Project.cpp

@@ -27,6 +27,7 @@
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
 #include "MainFrame.hpp"
+#include "MsgDialog.hpp"
 #include <slic3r/GUI/Widgets/WebView.hpp>
 
 namespace Slic3r { namespace GUI {
@@ -293,9 +294,24 @@ void ProjectPanel::OnScriptMessage(wxWebViewEvent& evt)
             if (!accessory_path.empty()) {
                 std::string decode_path = wxGetApp().url_decode(accessory_path.ToStdString());
                 fs::path path(decode_path);
+                // Only open the project's own extracted auxiliary files, with the root built as in Reload().
+                fs::path aux_root(encode_path(wxGetApp().plater()->model().get_auxiliary_file_temp_path().c_str()));
 
-                if (fs::exists(path)) {
+                if (is_absolute_path_within_root(path, aux_root) && fs::is_regular_file(path)) {
-                    wxLaunchDefaultApplication(path.wstring(), 0);
+                    // Attachments come with the project, so ask before running one that is a program or script.
+                    bool open = true;
+                    if (is_executable_file_name(path.filename().string())) {
+                        MessageDialog dlg(this,
+                                          wxString::Format(_L("\"%s\" is a program or script. Opening it will run it on this computer.\n\n"
+                                                              "Only open attachments from projects you trust. Open it anyway?"),
+                                                           from_path(path.filename())),
+                                          _L("Open attachment"), wxICON_WARNING | wxYES_NO);
+                        open = dlg.ShowModal() == wxID_YES;
+                    }
+                    if (open)
+                        wxLaunchDefaultApplication(path.wstring(), 0);
+                } else {
+                    BOOST_LOG_TRIVIAL(warning) << "open_3mf_accessory: ignoring path outside the project auxiliary directory: " << decode_path;
                 }
             }
         }

tests/libslic3r/test_3mf.cpp

@@ -17,7 +17,6 @@
 #include <nlohmann/json.hpp>
 
 #include <boost/filesystem/operations.hpp>
-#include <boost/nowide/fstream.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <algorithm>
 
@@ -1462,79 +1461,3 @@ SCENARIO("bbs_3mf_is_published detects only genuinely published 3MFs", "[3mf]")
     }
 }
 
-// Writes a single-entry zip whose central directory carries a zip64 record declaring an
-// uncompressed size beyond what the 32-bit expat buffer API can take, while the deflated
-// payload inflates to only ~64 KiB. Built by hand because miniz never writes a size that
-// disagrees with the data.
-static void write_zip_with_oversized_entry(const std::string& path, const std::string& entry)
-{
-    const std::string xml = "<?xml version=\"1.0\"?><!--" + std::string(65536, 'A') + "--><a/>";
-    size_t comp_len = 0;
-    void*  comp     = tdefl_compress_mem_to_heap(xml.data(), xml.size(), &comp_len, TDEFL_DEFAULT_MAX_PROBES);
-    REQUIRE(comp != nullptr);
-    const std::string deflated(static_cast<const char*>(comp), comp_len);
-    mz_free(comp);
-    const uint32_t crc = static_cast<uint32_t>(mz_crc32(MZ_CRC32_INIT, reinterpret_cast<const unsigned char*>(xml.data()), xml.size()));
-    const uint64_t claimed_size = (uint64_t(1) << 32) + 16;
-
-    std::string out;
-    auto put = [&out](uint64_t v, int bytes) {
-        for (int i = 0; i < bytes; ++i)
-            out.push_back(static_cast<char>((v >> (8 * i)) & 0xFF));
-    };
-    // local file header, with the true sizes
-    put(0x04034b50, 4); put(45, 2); put(0, 2); put(8, 2); put(0, 2); put(0, 2);
-    put(crc, 4); put(deflated.size(), 4); put(xml.size(), 4); put(entry.size(), 2); put(0, 2);
-    out += entry + deflated;
-    // central directory header, sizes deferred to the zip64 extra field
-    const size_t cd_offset = out.size();
-    put(0x02014b50, 4); put(45, 2); put(45, 2); put(0, 2); put(8, 2); put(0, 2); put(0, 2);
-    put(crc, 4); put(0xFFFFFFFF, 4); put(0xFFFFFFFF, 4); put(entry.size(), 2); put(20, 2);
-    put(0, 2); put(0, 2); put(0, 2); put(0, 4); put(0, 4);
-    out += entry;
-    put(0x0001, 2); put(16, 2); put(claimed_size, 8); put(deflated.size(), 8);
-    const size_t cd_size = out.size() - cd_offset;
-    // end of central directory
-    put(0x06054b50, 4); put(0, 2); put(0, 2); put(1, 2); put(1, 2);
-    put(cd_size, 4); put(cd_offset, 4); put(0, 2);
-
-    boost::nowide::ofstream f(path, std::ios::binary);
-    REQUIRE(f.good());
-    f.write(out.data(), static_cast<std::streamsize>(out.size()));
-    REQUIRE(f.good());
-}
-
-TEST_CASE("3MF XML entries declaring more than an int can hold fail to load", "[3mf]") {
-    ScopedTemporaryFile temp(".3mf");
-    const std::string   path = temp.string();
-
-    SECTION("BBS importer") {
-        write_zip_with_oversized_entry(path, "_rels/.rels");
-        Model                     model;
-        DynamicPrintConfig        config;
-        ConfigSubstitutionContext ctxt{ForwardCompatibilitySubstitutionRule::Enable};
-        PlateDataPtrs             plates;
-        std::vector<Preset*>      project_presets;
-        bool                      is_bbl_3mf = false, is_orca_3mf = false;
-        Semver                    file_version;
-        bool                      loaded = true;
-        REQUIRE_NOTHROW(loaded = load_bbs_3mf(path.c_str(), &config, &ctxt, &model, &plates, &project_presets, &is_bbl_3mf,
-                                              &is_orca_3mf, &file_version, nullptr, LoadStrategy::LoadModel | LoadStrategy::LoadConfig));
-        CHECK_FALSE(loaded);
-        release_PlateData_list(plates);
-    }
-    SECTION("PrusaSlicer importer") {
-        write_zip_with_oversized_entry(path, "Metadata/Slic3r_PE_model.config");
-        Model                     model;
-        DynamicPrintConfig        config;
-        ConfigSubstitutionContext ctxt{ForwardCompatibilitySubstitutionRule::Disable};
-        bool                      loaded = true;
-        REQUIRE_NOTHROW(loaded = load_3mf(path.c_str(), config, ctxt, &model, false));
-        CHECK_FALSE(loaded);
-    }
-    SECTION("PrusaSlicer fingerprint probe") {
-        write_zip_with_oversized_entry(path, "3D/3dmodel.model");
-        PrusaFileParser parser;
-        CHECK_FALSE(parser.check_3mf_from_prusa(path));
-    }
-}

tests/libslic3r/test_utils.cpp

@@ -152,3 +152,65 @@ TEST_CASE("resolve_cli_input_path leaves inputs that must not be completed uncha
         REQUIRE(resolve_cli_input_path("").empty());
     }
 }
+
+TEST_CASE("is_absolute_path_within_root accepts only entries inside the root", "[utils]") {
+    namespace fs = boost::filesystem;
+    ScopedTemporaryDir outer;
+    const fs::path root = outer.path() / "Auxiliaries";
+    fs::create_directories(root / "Others");
+    const fs::path inside = root / "Others" / "note.txt";
+    const fs::path outside = outer.path() / "secret.txt";
+    std::ofstream(inside.string()) << "inside";
+    std::ofstream(outside.string()) << "outside";
+
+    SECTION("a file inside the root") {
+        REQUIRE(is_absolute_path_within_root(inside, root));
+    }
+    SECTION("a path inside the root whose file does not exist yet") {
+        REQUIRE(is_absolute_path_within_root(root / "Others" / "missing.txt", root));
+    }
+    SECTION("the root itself") {
+        REQUIRE_FALSE(is_absolute_path_within_root(root, root));
+    }
+    SECTION("a parent-directory escape spelled under the root") {
+        REQUIRE_FALSE(is_absolute_path_within_root(root / "Others" / ".." / ".." / "secret.txt", root));
+    }
+    SECTION("an absolute path elsewhere") {
+        REQUIRE_FALSE(is_absolute_path_within_root(outside, root));
+    }
+    SECTION("a sibling directory sharing the root's name as a prefix") {
+        const fs::path sibling = outer.path() / "Auxiliaries2" / "note.txt";
+        REQUIRE_FALSE(is_absolute_path_within_root(sibling, root));
+    }
+    SECTION("a relative path") {
+        REQUIRE_FALSE(is_absolute_path_within_root(fs::path("Others") / "note.txt", root));
+    }
+    SECTION("an empty path") {
+        REQUIRE_FALSE(is_absolute_path_within_root(fs::path(), root));
+    }
+#ifndef _WIN32
+    // Creating symlinks on Windows needs elevated rights or developer mode.
+    SECTION("a symlink inside the root that points outside") {
+        const fs::path link = root / "Others" / "link.txt";
+        fs::create_symlink(outside, link);
+        REQUIRE_FALSE(is_absolute_path_within_root(link, root));
+    }
+#endif
+}
+
+TEST_CASE("is_executable_file_name flags attachments that would run as programs", "[utils]") {
+    const std::string executable = GENERATE(as<std::string>{},
+        "setup.exe", "SETUP.EXE", "Manual.pdf.exe", "run.bat", "start.cmd", "shortcut.lnk", "site.url", "script.ps1",
+        "macro.vbs", "tool.jar", "script.py", "Install.command", "Tool.app", "installer.pkg", "install.sh",
+        "launcher.desktop", "Printer.AppImage", "setup.exe.", "setup.exe ", "setup.exe. .", ".exe");
+    INFO(executable);
+    CHECK(is_executable_file_name(executable));
+}
+
+TEST_CASE("is_executable_file_name leaves documents and models alone", "[utils]") {
+    const std::string document = GENERATE(as<std::string>{},
+        "Manual.pdf", "BOM.xlsx", "notes.txt", "photo.JPG", "assembly.step", "part.stl", "project.3mf", "readme",
+        "exe", "setup.exe.pdf", "", "...", "dir.exe/readme");
+    INFO(document);
+    CHECK_FALSE(is_executable_file_name(document));
+}