DOCSLIB.ORG

Efficient and Secure SMAP-Enabled Intra-Process Memory Isolation

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Efficient and Secure SMAP-Enabled Intra-Process Memory Isolation SEIMI: Efficient and Secure SMAP-Enabled Intra-process Memory Isolation Zhe Wang1;2 Chenggang Wu1;2 Mengyao Xie1;2 Yinqian Zhang3 Kangjie Lu4 Xiaofeng Zhang1;2 Yuanming Lai1;2 Yan Kang1 Min Yang5 1 State Key Laboratory of Computer Architecture, Institute of Computing Technology, Chinese Academy of Sciences, 2 University of Chinese Academy of Sciences, 3 The Ohio State University, 4University of Minnesota, 5Fudan University Abstract—Memory-corruption attacks such as code-reuse at- The effectiveness of all such techniques heavily depends on tacks and data-only attacks have been a key threat to systems the integrity and/or confidentiality of the sensitive data. security. To counter these threats, researchers have proposed a To efficiently protect sensitive data, researchers proposed variety of defenses, including control-flow integrity (CFI), code- pointer integrity (CPI), and code (re-)randomization. All of information hiding (IH) which stores sensitive data in a memory them, to be effective, require a security primitive—intra-process region allocated in a random address and wishes that attackers protection of confidentiality and/or integrity for sensitive data could not know the random address thus could not write or (such as CFI’s shadow stack and CPI’s safe region). read the sensitive data. Unfortunately, recent works show that In this paper, we propose SEIMI, a highly efficient intra- memory disclosures and side channels can be exploited to process memory isolation technique for memory-corruption de- readily reduce the randomization entropy and thus to bypass fenses to protect their sensitive data. The core of SEIMI is to use the efficient Supervisor-mode Access Prevention (SMAP), the information hiding [22–24, 36, 41]. As such, even a robust a hardware feature that is originally used for preventing the IH-based defense can be defeated. kernel from accessing the user space, to achieve intra-process To address this problem, recent research instead opts for memory isolation. To leverage SMAP, SEIMI creatively executes practical memory isolation which provides efficient protection the user code in the privileged mode. In addition to enabling the with a stronger security guarantee. Memory isolation, in general, new design of the SMAP-based memory isolation, we further develop multiple new techniques to ensure secure escalation of can be classified into address-based isolation and domain-based user code, e.g., using the descriptor caches to capture the potential isolation. Address-based isolation checks (e.g., bound-check) segment operations and configuring the Virtual Machine Control each memory access from untrusted code to ensure that it Structure (VMCS) to invalidate the execution result of the control cannot access the sensitive data. The main overhead of this registers related operations. Extensive experimental results show method is brought by the code that performs the checks. The that SEIMI outperforms existing isolation mechanisms, including both the Memory Protection Keys (MPK) based scheme and most efficient address-based isolation is based on Intel Memory the Memory Protection Extensions (MPX) based scheme, while Protection Extensions (MPX), which performs bound-checking providing secure memory isolation. with hardware support [30]. Domain-based isolation instead stores sensitive data in I. INTRODUCTION a protected memory region. The permission to accessing this region is granted when requested by the trusted code, Memory-corruption attacks such as control-flow hijacking and is revoked when the trusted access finished. However, and data-only attacks have been a major threat to systems memory accesses from untrusted code (i.e., the potentially security in the past decades. To defend against such attacks, vulnerable code that can be compromised by attackers) cannot researchers have proposed a variety of advanced mechanisms, enable the permission. The main source of the performance including enhanced control-flow integrity (CFI), code-pointer overhead of domain-based memory isolation is the operations integrity (CPI), fine-grained code (re-)randomization, and data- for enabling and disabling the memory-access permissions. The layout randomization. All these techniques require a security most efficient domain-based isolation is to use Intel Memory primitive—effective intra-process memory protection of the Protection Keys (MPK) [25, 30, 40, 47]. integrity and/or confidentiality of sensitive data from potentially In general, existing address-based isolation and domain- compromised code. The sensitive data includes critical data based isolation both incur non-trivial performance overhead structures that are frequently checked against or used for compared to the IH-based scheme. Worse, the overhead will be protection. For example, O-CFI [39] uses a bounds lookup significantly elevated when the workloads (i.e., the frequency table (BLT), and CCFIR [58] uses a safe SpringBoard to of memory accesses that require bound-checking or permission restrict the control flow; CPI [31] uses a safe region, and switching) increase. For example, when protecting the shadow Shuffler [55] uses a code-pointer table to protect the sensitive stack, the MPK-based scheme (i.e., domain-based) incurs a pointers; Oxymoron [6] maintains a sensitive translation table, runtime overhead of 61.18% [40]. When protecting the safe and Isomeron [19] uses a table to protect randomization secrets. region of CPI using the MPX-based scheme (i.e., address- based), the runtime overhead is 36.86% [21]. Both cases are of untrusted user code with ring-0 privilege will offer valuable discouraging and would prevent practical uses of the defense insights and opportunities for future research. For example, mechanisms. As such, we need a more efficient isolation LBR is a privileged hardware feature used by transparent code- mechanism that can adapt to various workloads. reuse mitigation [42] and context-sensitive CFI [48]. Reading In this paper, we propose SMAP-Enabled Intra-process LBR has to trap into the kernel, which incurs expensive context Memory Isolation (SEIMI), a system for highly efficient switching. With the techniques used in SEIMI, since the user and secure domain-based memory isolation. SEIMI leverages code is running in a privileged mode, it can read LBR efficiently Supervisor-mode Access Prevention (SMAP), a widely used without context switching. and extremely efficient hardware feature for preventing kernel We have implemented SEIMI on the Linux/X86_64 platform. code from accessing user space. SEIMI uses SMAP in a To evaluate and compare the performance overhead, we completely different way. The key idea of SEIMI is to run deployed the MPX-based scheme, the MPK-based scheme, user code in the privileged mode (i.e., ring 0) and to store and SEIMI to protect four defense mechanisms: O-CFI [39], sensitive data in the user space. SEIMI employs SMAP to Shadow Stack [40], CPI [31], and ASLR-Guard [35]. We not prevent memory accesses from the “privileged untrusted user only conduct the experiments on SPEC CPU2006 benchmarks, code” to the “user mode” sensitive data. SMAP is temporarily but also on 12 real-world applications, including web servers, disabled when the trusted code (also in the privileged mode) databases, and JavaScript engines. Compared to the MPK-based accesses the sensitive data, and re-enabled when the trusted scheme, SEIMI is more efficient in almost all test cases; while code finishes the data access. Any memory access to theuser compared with the MPX-based scheme, SEIMI achieves a space will raise a processor exception when SMAP is enabled. lower performance overhead on average. Since SMAP is controlled by the RFLAGS register which is In sum, we make the following contributions in this paper. thread-private, disabling SMAP is only effective in current • A novel domain-based isolation mechanism. We pro- thread. Thus, temporarily enabling SMAP does not allow any pose a novel domain-based memory isolation mechanism concurrent access to sensitive data from other threads. that creatively uses SMAP in a reverse way; it can The new and “reverse” use of SMAP in SEIMI however efficiently protect a variety of software defenses against brings new design challenges: How to prevent the user code in memory-corruption attacks. ring 0 from corrupting the kernel and abusing the privileged • New techniques for isolating user code. We identify hardware resources. To prevent the kernel corruption, we choose new security threats when running untrusted user code to use the hardware-assisted virtualization technique (i.e., Intel in ring 0 and propose new solutions to these threats in VT-x) to run the kernel in a more-privileged mode (i.e., the SEIMI. These techniques are of independent interest and VMX root mode). The user code instead runs in ring 0 of the show that safely running user code in a privileged mode VMX non-root mode. Therefore, the user code is isolated from can be practical. the kernel by virtualization. It is worth noting that Dune [7] • New insights from implementation and evaluation. also uses Intel VT-x to provide user-level code with privileged We implement and evaluate SEIMI, and show that it hardware features. But it requires that the code running in ring outperforms existing approaches. Our study suggests that 0 is secure and trusted. To support untrusted code running in using SMAP for domain-based isolation is not only ring 0, we propose multiple novel techniques to prevent the practical but efficient. The enabling of running the user user code from abusing the following two types of hardware code in a privileged mode will also allow future defenses resources: (1) privileged data structures (e.g., the page tables) to efficiently access privileged hardware. and (2) privileged instructions. First, to prevent the user code from manipulating privileged II. BACKGROUND data structures (e.g., page table), we store the privileged data A. Information Hiding structures in the VMX root mode, and SEIMI leverages Intel Information hiding (IH) protects a memory region by putting VT-x to force all the privileged operations to trigger VM it in a randomized location.
Load more

Recommended publications
  • Draft SP 800-125A Rev. 1, Security Recommendations for Server
    The attached DRAFT document (provided here for historical purposes), released on April 11, 2018, has been superseded by the following publication: Publication Number: NIST Special Publication (SP) 800-125A Rev. 1 Title: Security Recommendations for Server-based Hypervisor Platforms Publication Date: June 2018 • Final Publication: https://doi.org/10.6028/NIST.SP.800-125Ar1 (which links to https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-125Ar1.pdf). • Related Information on CSRC: Final: https://csrc.nist.gov/publications/detail/sp/800-125a/rev-1/final 1 Draft NIST Special Publication 800-125A 2 Revision 1 3 4 Security Recommendations for 5 Hypervisor Deployment on 6 ServersServer-based Hypervisor 7 Platforms 8 9 10 11 12 Ramaswamy Chandramouli 13 14 15 16 17 18 19 20 21 22 23 C O M P U T E R S E C U R I T Y 24 25 Draft NIST Special Publication 800-125A 26 Revision 1 27 28 29 30 Security Recommendations for 31 Server-based Hypervisor Platforms 32 33 Hypervisor Deployment on Servers 34 35 36 37 Ramaswamy Chandramouli 38 Computer Security Division 39 Information Technology Laboratory 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 April 2018 56 57 58 59 60 61 U.S. Department of Commerce 62 Wilbur L. Ross, Jr., Secretary 63 64 National Institute of Standards and Technology 65 Walter Copan, NIST Director and Under Secretary of Commerce for Standards and Technology 66 67 Authority 68 69 This publication has been developed by NIST in accordance with its statutory responsibilities under the 70 Federal Information Security Modernization Act (FISMA) of 2014, 44 U.S.C.
    [Show full text]
  • Designing and Implementing the OP and OP2 Web Browsers
    Designing and Implementing the OP and OP2 Web Browsers CHRIS GRIER, SHUO TANG and SAMUEL T. KING, University of Illinois at Urbana-Champaign Current web browsers are plagued with vulnerabilities, providing hackers with easy access to computer systems via browser-based attacks. Browser security efforts that retrofit existing browsers have had lim- ited success because the design of modern browsers is fundamentally flawed. To enable more secure web browsing, we design and implement a new browser, called the OP web browser, that attempts to improve the state-of-the-art in browser security. We combine operating system design principles with formal methods to design a more secure web browser by drawing on the expertise of both communities. Our design philosophy is to partition the browser into smaller subsystems and make all communication between subsystems sim- ple and explicit. At the core of our design is a small browser kernel that manages the browser subsystems and interposes on all communications between them to enforce our new browser security features. To show the utility of our browser architecture, we design and implement three novel security features. First, we develop flexible security policies that allow us to include browser plugins within our security framework. Second, we use formal methods to prove useful security properties including user interface invariants and browser security policy. Third, we design and implement a browser-level information-flow tracking system to enable post-mortem analysis of browser-based attacks. In addition to presenting the OP browser architecture, we discuss the design and implementation of a second version of OP, OP2, that includes features from other secure web browser designs to improve on the overall security and performance of OP.
    [Show full text]
  • Isolation, Resource Management, and Sharing in Java
    Processes in KaffeOS: Isolation, Resource Management, and Sharing in Java Godmar Back, Wilson C. Hsieh, Jay Lepreau School of Computing University of Utah Abstract many environments for executing untrusted code: for example, applets, servlets, active packets [41], database Single-language runtime systems, in the form of Java queries [15], and kernel extensions [6]. Current systems virtual machines, are widely deployed platforms for ex- (such as Java) provide memory protection through the ecuting untrusted mobile code. These runtimes pro- enforcement of type safety and secure system services vide some of the features that operating systems pro- through a number of mechanisms, including namespace vide: inter-application memory protection and basic sys- and access control. Unfortunately, malicious or buggy tem services. They do not, however, provide the ability applications can deny service to other applications. For to isolate applications from each other, or limit their re- example, a Java applet can generate excessive amounts source consumption. This paper describes KaffeOS, a of garbage and cause a Web browser to spend all of its Java runtime system that provides these features. The time collecting it. KaffeOS architecture takes many lessons from operating To support the execution of untrusted code, type-safe system design, such as the use of a user/kernel bound- language runtimes need to provide a mechanism to iso- ary, and employs garbage collection techniques, such as late and manage the resources of applications, analogous write barriers. to that provided by operating systems. Although other re- The KaffeOS architecture supports the OS abstraction source management abstractions exist [4], the classic OS of a process in a Java virtual machine.
    [Show full text]
  • Cali: Compiler-Assisted Library Isolation
    Cali: Compiler-Assisted Library Isolation Markus Bauer Christian Rossow CISPA Helmholtz Center for Information Security CISPA Helmholtz Center for Information Security Saarbrücken, Saarland, Germany Saarbrücken, Saarland, Germany [email protected] [email protected] ABSTRACT the full program’s privileges and address space. This lack of privi- Software libraries can freely access the program’s entire address lege separation and memory isolation has led to numerous critical space, and also inherit its system-level privileges. This lack of sepa- security incidents. ration regularly leads to security-critical incidents once libraries We can significantly reduce this threat surface by isolating the contain vulnerabilities or turn rogue. We present Cali, a compiler- library from the main program. In most cases, a library (i) neither assisted library isolation system that fully automatically shields a requires access to the entire program’s address space, (ii) nor needs program from a given library. Cali is fully compatible with main- the full program’s privileges to function properly. In fact, even line Linux and does not require supervisor privileges to execute. We complex libraries such as parsers require only limited interaction compartmentalize libraries into their own process with well-defined with the program and/or system. Conceptually, there is thus little security policies. To preserve the functionality of the interactions need to grant an untrusted library access to the program or to between program and library, Cali uses a Program Dependence critical system privileges. Basic compartmentalization principles Graph to track data flow between the program and the library dur- thus help to secure a program from misuse by untrusted code.
    [Show full text]
  • Introduction to Operating Systems Learning Outcomes What Is An
    Learning Outcomes • High-level understand what is an operating Introduction to Operating system and the role it plays Systems • A high-level understanding of the structure of operating systems, applications, and the relationship between them. Chapter 1 – 1.3 • Some knowledge of the services provided by Chapter 1.5 – 1.9 operating systems. • Exposure to some details of major OS concepts. 2 What is an Operating System? 3 4 Block Diagram of Haswell Platform Architecture http://www.pcquest.com Role 1: The Operating System is Disk Users an Abstract Machine • Extends the basic hardware with added Memory functionality • Provides high-level abstractions – More programmer friendly CPU – Common core for all applications Network • E.g. Filesystem instead of just registers on a disk controller Bandwidth • It hides the details of the hardware – Makes application code portable 5 6 1 Structural (Implementation) View: the Role 2: The Operating System Operating System is the Privileged is a Resource Manager Component • Responsible for allocating resources to users and processes Applications Applications Applications • Must ensure User Mode Requests (System Calls) – No Starvation Privileged Mode – Progress – Allocation is according to some desired policy Operating System • First-come, first-served; Fair share; Weighted fair share; limits (quotas), etc… – Overall, that the system is efficiently used Hardware 7 8 The Operating System is Operating System Kernel Privileged • Portion of the operating system that is • Applications should not be able to interfere
    [Show full text]
  • Sealing OS Processes to Improve Dependability and Security
    Sealing OS Processes to Improve Dependability and Safety Galen Hunt, Mark Aiken, Manuel Fähndrich, Chris Hawblitzel, Orion Hodson, James Larus, Steven Levi, Bjarne Steensgaard, David Tarditi, and Ted Wobber Microsoft Research One Microsoft Way Redmond, WA 98052 USA [email protected] ABSTRACT General Terms In most modern operating systems, a process is a Design, Reliability, Experimentation. hardware-protected abstraction for isolating code and data. This protection, however, is selective. Many common Keywords mechanisms—dynamic code loading, run-time code Open process architecture, sealed process architecture, sealed generation, shared memory, and intrusive system APIs— kernel, software isolated process (SIP). make the barrier between processes very permeable. This paper argues that this traditional open process architecture 1. INTRODUCTION exacerbates the dependability and security weaknesses of Processes debuted, circa 1965, as a recognized operating modern systems. system abstraction in Multics [48]. Multics pioneered As a remedy, this paper proposes a sealed process many attributes of modern processes: OS-supported architecture, which prohibits dynamic code loading, self- dynamic code loading, run-time code generation, cross- modifying code, shared memory, and limits the scope of process shared memory, and an intrusive kernel API that the process API. This paper describes the implementation permitted one process to modify directly the state of of the sealed process architecture in the Singularity another process. operating system,
    [Show full text]
  • Security Analysis of Browser Extension Concepts
    Saarland University Faculty of Natural Sciences and Technology I Department of Computer Science Bachelor's thesis Security Analysis of Browser Extension Concepts A comparison of Internet Explorer 9, Safari 5, Firefox 8, and Chrome 14 submitted by Karsten Knuth submitted January 14, 2012 Supervisor Prof. Dr. Michael Backes Advisors Raphael Reischuk Sebastian Gerling Reviewers Prof. Dr. Michael Backes Dr. Matteo Maffei Statement in Lieu of an Oath I hereby confirm that I have written this thesis on my own and that I have not used any other media or materials than the ones referred to in this thesis. Saarbr¨ucken, January 14, 2012 Karsten Knuth Declaration of Consent I agree to make both versions of my thesis (with a passing grade) accessible to the public by having them added to the library of the Computer Science Department. Saarbr¨ucken, January 14, 2012 Karsten Knuth Acknowledgments First of all, I thank Professor Dr. Michael Backes for giving me the chance to write my bachelor's thesis at the Information Security & Cryptography chair. During the making of this thesis I have gotten a deeper look in a topic which I hope to be given the chance to follow up in my upcoming academic career. Furthermore, I thank my advisors Raphael Reischuk, Sebastian Gerling, and Philipp von Styp-Rekowsky for supporting me with words and deeds during the making of this thesis. In particular, I thank the first two for bearing with me since the release of my topic. My thanks also go to Lara Schneider and Michael Zeidler for offering me helpful advice.
    [Show full text]
  • Web Browsers As Operating Systems: Supporting Robust and Secure Web Programs Charles Reis Final Exam - May 27, 2009
    Web Browsers as Operating Systems: Supporting Robust and Secure Web Programs Charles Reis Final Exam - May 27, 2009 1 Web is Evolving Pages Programs More complex, active content Browser now in role of OS, but faces challenges Browsers aren’t built for programs Web content not designed to express programs 2 Concrete Problems Problems Contributions Program Interference Multi-Process Browsers [EuroSys ’09] In-Flight Page Changes Web Tripwires [NSDI ’08] XSS Script Whitelists Browser Exploits BrowserShield [OSDI ’06] 3 Consider OS Landscape Performance isolation Resource accounting Failure isolation Clear program abstraction 4 Browsers Fall Short Unresponsiveness Jumbled accounting Browser crashes Unclear what a program is! 5 Preserve Web’s Strengths Improve program support, but keep it: Easy to publish content Easy to compose content Generally safe to explore 6 Thesis: Adapt lessons from the OS to improve robustness and security of web browsers and web content Support four architectural principles: 1. Identify program boundaries 2. Isolate programs from each other 3. Authorize program code 4. Enforce policies on program behavior [HotNets ’07] 7 Outline Browser Architecture: Chromium Identify program boundaries Isolate programs from each other Web Tripwires Additional Contributions Future Directions 8 Programs in the Browser Mail Doc List Doc Consider an example Doc browsing session Blog Several independent programs Mail News Article 9 Monolithic Browsers Most browsers put all pages in one process Mail Doc List Doc Poor performance isolation Blog Poor failure isolation Mail Poor security News Article Should re-architect the browser 10 Process per Window? Mail Doc List Doc Breaks pages that directly communicate Shared access to Blog data structures, etc.
    [Show full text]
  • Memento: Learning Secrets from Process Footprints
    Memento: Learning Secrets from Process Footprints Suman Jana and Vitaly Shmatikov The University of Texas at Austin Abstract—We describe a new side-channel attack. By track- Our contributions. In the 2000 movie “Memento,” the main ing changes in the application’s memory footprint, a concurrent character, suffering from anterograde amnesia, writes out his process belonging to a different user can learn its secrets. Using memories in small increments using snapshots and tattoos. Web browsers as the target, we show how an unprivileged, local attack process—for example, a malicious Android app—can When put together, these snippets reveal the answer to a infer which page the user is browsing, as well as finer-grained murder mystery. In this paper, we show that the dynamics information: whether she is a paid customer, her interests, etc. of memory footprints—sequences of snapshots of the pro- This attack is an instance of a broader problem. Many gram’s data resident size (DRS)—are correlated with the isolation mechanisms in modern systems reveal accounting in- program’s secrets and allow accurate adversarial inference. formation about program execution, such as memory usage and This robust side channel can be exploited in any multi-user CPU scheduling statistics. If temporal changes in this public information are correlated with the program’s secrets, they environment: for example, by a malicious app on an Android can lead to a privacy breach. To illustrate the pervasiveness of smartphone or a nosy user on a shared workstation. this problem, we show how to exploit scheduling statistics for We focus on Web browsers as an example of a sophis- keystroke sniffing in Linux and Android, and how to combine ticated application that keeps important secrets (browsing scheduling statistics with the dynamics of memory usage for behavior).
    [Show full text]
  • Site Isolation: Process Separation for Web Sites Within the Browser
    Site Isolation: Process Separation for Web Sites within the Browser Charles Reis, Alexander Moshchuk, and Nasko Oskov, Google https://www.usenix.org/conference/usenixsecurity19/presentation/reis This paper is included in the Proceedings of the 28th USENIX Security Symposium. August 14–16, 2019 • Santa Clara, CA, USA 978-1-939133-06-9 Open access to the Proceedings of the 28th USENIX Security Symposium is sponsored by USENIX. Site Isolation: Process Separation for Web Sites within the Browser Charles Reis Alexander Moshchuk Nasko Oskov Google Google Google [email protected] [email protected] [email protected] Abstract ploitable targets of older browsers are disappearing from the web (e.g., Java Applets [64], Flash [1], NPAPI plugins [55]). Current production web browsers are multi-process but place As others have argued, it is clear that we need stronger iso- different web sites in the same renderer process, which is lation between security principals in the browser [23, 33, 53, not sufficient to mitigate threats present on the web today. 62, 63, 68], just as operating systems offer stronger isolation With the prevalence of private user data stored on web sites, between their own principals. We achieve this in a produc- the risk posed by compromised renderer processes, and the tion setting using Site Isolation in Google Chrome, introduc- advent of transient execution attacks like Spectre and Melt- ing OS process boundaries between web site principals. down that can leak data via microarchitectural state, it is no While Site Isolation was originally envisioned to mitigate longer safe to render documents from different web sites in exploits of bugs in the renderer process, the recent discov- the same process.
    [Show full text]
  • Site Isolation Confining Untrustworthy Code in the Web Browser
    Site Isolation Confining Untrustworthy Code in the Web Browser Nasko Oskov, Charlie Reis about:us Nasko Oskov Charlie Reis Defense Offense Browser evolution How to look for bypasses Site Isolation architecture Example vulnerabilities Making it shippable about:history Browser Process Late 1990s Monolithic evil.com Browser Process Late 2000s Renderer Process Multi-process evil.com Browser Process Late 2000s Renderer Process mail.com Multi-process evil.com Browser Process Late 2010s Renderer Process Renderer Process mail.com Site Isolation evil.com Browser Process 2018 Renderer Process Renderer Process mail.com Spectre evil.com about:site-isolation Ad Video Article Without Site Isolation With Site Isolation Browser Process Renderer Process Renderer Process mail.com evil.com mail.com evil.com Example: Input events Operating System Browser Process Renderer Process A B Input events with out-of-process iframes Operating System Browser Process Renderer Process Renderer Process A B Updated browser features ● Accessibility ● Mixed content handling ● Screen Orientation API ● Developer tools ● Multiple monitor and ● Scroll bubbling ● Drag and drop device scale factor ● Session restore ● Extensions ● Password manager ● Spellcheck ● Find-in-page ● Pointer Lock API ● Tooltips ● Focus ● Printing ● Unresponsive renderer ● Form autofill ● Task manager detector and dialog ● Fullscreen ● Resource optimizations ● User gesture tracking ● IME ● Malware and phishing ● View source ● Input gestures detection ● Visibility APIs ● JavaScript dialogs ● Save page to disk ● Webdriver automation ● Zoom Browser Process Process Isolation FTW Renderer Process Renderer Process Not yet... mail.com evil.com Cross-Origin Read Blocking Must allow images, scripts, stylesheets foo.com Cross-site images, scripts Want to protect sensitive data (HTML, XML, JSON) Mislabeled Content-Types Cross-site <img src= data ● Custom sniffing "bar.com/image.jpg"> ● Must allow responses like: <img src= Content-Type: text/html "bar.com/secret.html"> <!-- This is JS.
    [Show full text]
  • X41 D-SEC Gmbh Dennewartstr
    Browser Security White PAPER Final PAPER 2017-09-19 Markus VERVIER, Michele Orrù, Berend-Jan WEVER, Eric Sesterhenn X41 D-SEC GmbH Dennewartstr. 25-27 D-52068 Aachen Amtsgericht Aachen: HRB19989 Browser Security White PAPER Revision History Revision Date Change Editor 1 2017-04-18 Initial Document E. Sesterhenn 2 2017-04-28 Phase 1 M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 3 2017-05-19 Phase 2 M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 4 2017-05-25 Phase 3 M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 5 2017-06-05 First DrAFT M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 6 2017-06-26 Second DrAFT M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 7 2017-07-24 Final DrAFT M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 8 2017-08-25 Final PAPER M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER 9 2017-09-19 Public Release M. VERVIER, M. Orrù, E. Sesterhenn, B.-J. WEVER X41 D-SEC GmbH PAGE 1 OF 196 Contents 1 ExECUTIVE Summary 7 2 Methodology 10 3 Introduction 12 3.1 Google Chrome . 13 3.2 Microsoft Edge . 14 3.3 Microsoft Internet Explorer (IE) . 16 4 Attack Surface 18 4.1 Supported Standards . 18 4.1.1 WEB TECHNOLOGIES . 18 5 Organizational Security Aspects 21 5.1 Bug Bounties . 21 5.1.1 Google Chrome . 21 5.1.2 Microsoft Edge . 22 5.1.3 Internet Explorer . 22 5.2 Exploit Pricing . 22 5.2.1 ZERODIUM . 23 5.2.2 Pwn2Own .
    [Show full text]