{'fraction_non_alphanumeric': 0.02761048827944038, 'fraction_numerical': 0.004262021680718984, 'mean_word_length': 4.902925895542794, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Tug-of-War: Observations on Unified Content Handling

Modern applications and Operating Systems vary greatly with respect to how they register and identify different types of content. These discrepancies lead to exploits and inconsistencies in user experience. In this paper, we highlight the issues arising in the modern content handling ecosystem, and examine how the operating system can be used to achieve unified and consistent content identification.


Introduction
Data handling lies at the very heart of modern applications. The Operating System (OS), as well as the applications running in user space, perform complex tasks on a multitude of file types, applying different security policies each time. File-associated metadata such as the Multipurpose Internet Mail Extensions (MIMEs), the extended file attributes, or the filename extension itself, provide indications about the type of data being handled. However, applications are free to perform their own processing of files at will, without the interposition of the OS. This scheme, although allowing for flexibility and specialized handling of app-specific content, comes with a cost: as file parsing logic is propagated, with variations, amongst similar applications, bugs are introduced. Such bugs have been exploited for over a decade, resulting in the execution of active content without the users' knowledge.
Current systems do not fully support unified handling for different types of content. Instead, in the majority of cases, applications are responsible for performing their own processing or analysis on a particular file. This may logically contradict analyses or processing performed on the same file by the OS, or other applications. For instance, it is possible that a given file may be treated as an image by a particular application, but as a text file by a different application running on the same machine [4]. More importantly, no mechanism exists between the OS and the user space programs so that security policies or assumptions for a particular file or file type can be updated dynamically. For instance, despite the fact that a PDF might be deemed malicious by a sophisticated PDF reader and executed in a sandbox, this information is not communicated to less sophisticated PDF readers that may be installed in the same host, and might treat the file in a different manner. If the file is not deleted by the first PDF reader, it will continue to exist in the system, and the OS will be unaware of the (malicious) char-acteristics of the file. Moreover, although applications often perform their own scanning or sniffing on a file's contents, ignoring the MIME or extension directives of the OS, they do not communicate their different view of the application to the OS.
As a result, the current content-handling ecosystem is heavily fragmented, with different entities involved implementing different policies. In this paper, we examine the current status of the content handling practices and how this can be exploited by attackers or degrade user experience. Drawing from the weaknesses of current systems, we introduce our recommendations on how the OS can serve as a reference oracle concerning file properties.
In particular, we propose extending the existing extended file attributes mechanism so that, whenever an application has a different view of a file than the OS, this new view is registered back to the host OS and communicated to all the other applications handling the file. Thus, any differences in MIME type identification amongst different applications, or between applications and the OS, can be made known to the user. This simple addition to file metadata does not impose backwards compatibility limitations, but allows applications to act as crossreference oracles. Also, it enables the OS to detect any changes in the properties of a file, and inform the user accordingly (e.g., the user will be able to receive a warning every time non-active is about to be executed as active or if active content is about to be flagged as non-active).

Motivating Example
Determining a file's content is not trivial, especially in cases of polyglots, where a file can have two different content types (e.g., a GIF that may simultaneously be a valid image and contain JavaScript). In this case, the interpretation of the file might solely depend on the context [6]. However, there are many cases in which mis-interpretation of content does not match the user's expectations regarding the execution. An example of such scenario is presented in Figure 1: Alice, a Mac OS X user, is tricked into clicking a link that is supposed to contain a PDF attachment. However, the website is malicious, and the attacker, instead of a legitimate PDF, instead provides as attachment a ZIP file that contains a Javascript executable script. The attacker has removed the extension from the file, and has given it an icon that matches the PDF icon for Alice's OS. Once Alice accesses the link with her Safari browser, the ZIP file is extracted into the Downloads folder, with all the attacker's modifications on the icon and extension preserved. Alice clicks on the PDF file, however, instead of Mac OS X's default PDF viewer rendering the PDF, the malicious Javascript is executed in the browser with localhost permissions. As a result, Alice's sensitive information such as her system logs leak to the attacker.
From the user's perspective, this is clearly unwanted behavior. This attack is still present in today's Mac OS X El Capitan, despite the fact that similar attacks have appeared in the past (e.g., where a Javascript vulnerability allowed loading of local files and browser-specific privileged pages into an IFrame [1]). Regardless of the exploitation scenario, Alice would perhaps have not fallen for the clickjacking attack, had the OS enforced stricter policies with respect to maching the icon and extension of the file with the payload to be executed, or had the OS prompt her with a warning message.

The Content Handling Ecosystem
Data are seldom processed by a single application. Instead, a file is usually accessed by multiple programs, often running in different machines. In a typical scenario, a payload is served from a server and then passes through a series of intermediate entities on the Web (e.g., Ad networks, firewalls, proxies -to end up on the client side ( Fig. 2). Once data reaches the client application, it might be stored on the disk, passed into the OS, or it can be used as input for other applications. Data type identification throughout this cycle is primarily achieved through Multipurpose Internet Mail Extension (MIME) types, which characterize the nature of a particular payload. Public MIME types should be registered with the Internet Assigned Numbers Authority (IANA). IANA MIME types fall within nine major categories, namely: application, audio, font, image, message, model, multipart, text and video [5]. Whenever a file is transferred from one entity to another, the MIME type of the file is usually stored as part of the metadata of the file, sent via request headers or, left to be determined by the target entity from scratch. At the end of this process, a file might be written to disk to be processed in the future. Once a file is written on disk and it is accessed by the user, the OS is responsible to invoke the appropriate application for each file.

MIME handling by the OS
Operating Systems associate certain file extensions with a set of MIME types, and, likewise, applications register the MIME types they can handle back to the host OS. Where and how this information gets stored varies depending on the OS. 1 If a file has a known extension the OS will open it with the default application for the corresponding MIME type. In the case of an extensionless file, the OS performs MIME-type sniffing based on magic values present in the contents of the file.  Except for the public (registered) IANA MIME types, OSes also support numerous "unofficial" MIME types, which are used in the wild. Figure 3 shows the total MIME types register with IANA, as well as in the MIME types present in default install of Mac OS X El Capitan, Windows 10 and Ubuntu 16.04 distributions, per category. We notice that, in total, the three popular 1 For instance, Ubuntu stores the mapping between file extensions and MIME types primarily in /etc/mime.types, Mac OS X handles MIME associations via the LaunchServices sub-system, whilst in Windows the respective mappings are stored in the system Registry in

HKEY_CLASSES_ROOT\MIME\Database\Content.
OSes support an additional Surprisingly, out of the total unique 1261 unique MIME types in the three popular OSes, 546 MIMEs, a staggering 43.29%, are not registered with IANA. Moreover, we encountered 7 MIME types for El Capitan and 63 MIME types for Ubuntu 16.04 that do not even fall within the nine major IANA categories (such instances include MIME types that fall within the chemical, inode, and x-conference families). The fact that the above numbers originate from vanilla systems, in which no third-party applications are installed, is indicative of the current status in the MIME type ecosystem. Further discrepancies are introduced if third-party applications are installed in the system. As an example, let us consider the different extensions that are handled by four major browsers in Mac OS X El Capitan, presented in Fig. 4. We notice that despite the fact that most extensions are handled by at least three Browsers, there are cases (e.g., for filetypes such as .mhtml, .webp, .mht) for which only two of the four browsers are registered in the OS settings. Such instances are indicative of the underlying discrepancies between similar applications. However, with regards to file type detection in particular, additional complexities are introduced from the sniffing performed both by the OS as well as the applications, which might result in a misidentification of a file.

Handling Utrusted Content
Although the OS stores a hardcoded MIME mapping so that different payloads can be processed by the appropriate applications, content transferred across Operating Systems, applications or the Web may undergo several stages of processing. Each of these stages might modify the transferred content itself, or treat it as if it has a different type (e.g., treat non-executable content as executable and vice-versa). However, such assumptions or modifications are not made known across all involved entities. For instance, suppose that a .zip file is stored on disk on server A and is being copied from server A to server B with a MIME type of application/zip. If the file is transferred from server B to an FTP server C as of type application/x-zip, server C has no way of knowing that the same file was transferred from server A to B as application/zip.
Thus, applications processing untrusted files often perform their own filtering, attempting to sniff the type of each file they are handling. Moreover, on certain OSes and configurations, whenever an application writes a file on disk from an untrusted source such as the Web, it informs the OS writing metadata in the files extended file attributes.
Currently on Linux there are four namespaces for extended file attributes, namely: user, trusted, security and system. The system namespace is used primarily by the kernel for access control lists (ACLs) and can only be set by root. Whenever a file gets downloaded from the Internet, its origin URL is stored in the dedicated extended attribute user.xdg.origin.url. If there was a referrer URL present, the respective attribute is also set in user.xdg.referrer.url. Windows and OS X support similar attributes. For instance, in OS X the com.apple.quarantine attribute is set by quarantine-aware applications to inform users about content that originated from the Web or an untrusted source. If an application has the Info.plist key LSFileQuarantineEnabled set, all files created by that application will be quarantined by OS X. However, although such attributes exist, not all OSes strictly enforce properties associated with a particular file type. Thus, it is possible for a file to have a PDF icon, without being a valid PDF document. Such inconsistencies have been used in clickjacking attacks [19], and are still present. Finally, despite the extended file attributes being present, they are underutilized, and are not used to implement security policies to achieve extended access control.

Observations on Current Content Handling
In this section we present some of the problems arising from the current MIME handling ecosystem. Although MIME-related attacks are known for more than a decade, they are still present today [4,7].
Observation 1: Reliable content identification at the application level is hard: Relying on applications for proper content identification is not scalable, as it is hard for all applications responsible for handling a particular file to behave exactly the same. To demonstrate the difficulty of achieving a unified content policy enforcement at the application level, we examine one of the most prevalent and well-tested categories of software: Web browsers. Whenever a browser attempts to identify the type of a payload, the result depends on multiple parameters. Examples of such parameters are: • Payload: The real payload of the file being served.
• Extension: The file extension in the URL download link or the file extension of the payload.  • Content-type: The header sent by the server indicating the MIME type of the file being served. Again, this may or may not match the real MIME type of the file. Given the fact that there exist more than a thousand MIME types [5], it is almost inevitable that differences in browsers' handling of content will continue to exist. To demonstrate the extent of the discrepancies of modern browser, we depict in Fig. 5 the key points in payload identification over HTTP for the Opera and Firefox browsers. The complexity of the schemes, and the differences between only two browsers indicate that there is high probability where a user will encounter unexpected behavior, if the payloads are crafted properly. Web browsers are perhaps amongst the most complex pieces of software, and browser developers often "peek" into the implementations of other vendors to determine what functionality they should support. Representative of the current developer workflow is the following comment, extracted from Chromium's mime_util.cc, regarding MIME type identification: "We implement the same algorithm as Mozilla for mapping a file extension to a mime type. That is, we first check a hard-coded list (that cannot be overridden), and then if not found there, we defer to the system registry. Finally, we scan a secondary hard-coded list to catch types that we can deduce but that we also want to allow the OS to override." Unfortunately, discrepancies between different vendors are omnipresent: many such cases have been encountered in browser's differences in CSS and Javascript handling. With the constant adoption of new features, such discrepancies are prone to lead to attacks [2,22,25,29]. Not adopting a centralized scheme, not only degrades user experience with users seeing different behavior when accessing the same resources or websites from a different browsers, but, more importantly, leaves users vulnerable. Observation 2: Application-level content identification is risky: There have been multiple instances in the wild, where inactive content has been misclassified as active and vice-versa. Such cases include input sanitization bypasses of web-forms [9, 17,18,26,30], or unwanted execution [4,7]. Often exploitation is achieved due to poor sanitization on the application side, accepting files with fake file extensions [3], double extensions [10][11][12][13][14][15] or no extensions at all. Although old, this technique is still used today [4]. Most of these exploitation instances however, would have been easily detected had the OS provided a richer and reliable content identification interface to the applications, so that the latter could delegated this task to the Operating System.
Several clickjacking attacks abuse current content handling mechanisms. For instance, Unicode character tricks have been used so that victims think that a file has an expected, legal extension, whereas no extension is present [27]. When executed, the file will be opened according to the MIME-sniffing properties of the host OS. Similar problems arise when users associate a particular icon with its legal file type while the host OS allows for an arbitrary icon assignment for each file. Even in modern OSes like the OS X, it is possible for a file to have an icon associated with a different filetype, as we showed in our motivating example.

Recommendations for OS-based Content Policies
Except for instances of privilege escalation attacks within the realm of a single application [16], exploitation of MIME handling weaknesses often achieves unwanted execution across applications. For instance, the auto-open browser feature has been exploited in the past to achieve unwanted execution [8]. Alternatively, attackers who are aware of the fact that browsers follow different sandboxing policies when executing local versus remote JavaScript, might attempt to force a browser to download a malicious payload and store it on disk, so that it executes in a non-sandboxed environment when accessed, as was the case in our motivating example. In the aforementioned scenarios, a discrepancy exists between either the view of different applications on a file, or between applications and the OS. Another common characteristic is the lack of interfaces for communicating content-related attributes between applications as well as between applications and the OS. This allows for a class of attacks in which the attacker "disguises" a payload and presents it to the appropriate application as of a different type, so that it executes under different security policies. Since applications often invoke other applications directly to process a particular payload, it is necessary that they get all the possible information they could use with regards to content identification. More importantly, any different view an application might have for a particular file should be communicated back to the OS, so that the user can be warned accordingly. In summary, it is important that the following properties are maintained: • Each payload should be identified uniquely by all applications in the same OS. This uniform identification should also reflect in the respective properties of the payload such as the file extension (if any), or the icon which is associated with that payload type: All PDFs of a given type, should have a single icon in the system and share the same extension. Any discrepancies found should be reported to the user. • Active content should be explicitly flagged based on its type, in a centralized manner. Applications should let the OS know what types of content they consider active and file properties should be updated dynami-cally if a discrepancy is detected. • If a user trusts a file once, this should be made known across all applications. Reversely, if an application detects some inconsistency in the type of a file that the user trusts, this should be made known to the user (e.g., the user thinks this file is inactive but in reality it contains active content). We believe that current extended file attribute mechanism can be expanded to provide support for the above properties. Paired with an interface for applications to update this metadata dynamically, such a design can serve as the basis for applying fine-grained access control at a file level. For instance, applications may register the set of third-party executables that are allowed to be invoked when processing a particular file.

Related Work
Throughout Section 4, we refered to multiple attacks [4,7] exploiting the current content handling ecosystem. Except for the aforementioned examples, multiple XSS techniques have appeared in the literature, exploiting either application flaws, discrepancies or content mishandling [20,23,28]. A related technique proposed by Heiderich et al. [24] is based on Scalable Vector Graphics (SVG). Specifically, the authors have illustrated that SVG images embedded via <img> tag and CSS can execute arbitrary JavaScript code.
Similar attacks utilize savvy vectors to inject JavaScript in the web user's browsers include Crosschannel Scripting (XCS) [21] attacks. In an XCS attack, the Simple Network Management Protocol (SNMP) can be used as an attack vector. For instance, there are several Network-Attached Storage (NAS) devices that let web users upload files via the Server Message Block (SMB) protocol. An attacker could upload a file with a name that contains a malicious script. When a benign user connects over to the device to browse its contents, the device will send through an HTTP response the list of all filenames, including the malicious one. Hence, the script that exists in this file is going to be interpreted as legitimate by the browser.

Conclusion
In this work, we highlighted a number of problems arising from the currently fragmented content handling ecosystem and possible directions that can be taken by the OS towards resolving these issues. Content identification should not be hard. We hope that our paper will encourage OS designers to revisit currently deployed schemes and take steps to enable unified, cross-application content policies.