waashk/dblp huggingface dataset:
tamper evident microprocessors. most security mechanisms proposed to date unquestioningly place trust in microprocessor hardware. this trust, however, is misplaced and dangerous because microprocessors are vulnerable to insider attacks that can catastrophically compromise security, integrity and privacy of computer systems. in this paper, we describe several methods to strengthen the fundamental assumption about trust in microprocessors. by employing practical, lightweight attack detectors within a microprocessor, we show that it is possible to protect against malicious logic embedded in microprocessor hardware. we propose and evaluate two area-efficient hardware methods - trustnet and datawatch - that detect attacks on microprocessor hardware by knowledgeable, malicious insiders. our mechanisms leverage the fact that multiple components within a microprocessor (e.g., fetch, decode pipeline stage etc.) must necessarily coordinate and communicate to execute even simple instructions, and that any attack on a microprocessor must cause erroneous communications between micro architectural subcomponents used to build a processor. a key aspect of our solution is that trustnet and datawatch are themselves highly resilient to corruption. we demonstrate that under realistic assumptions, our solutions can protect pipelines and on-chip cache hierarchies at negligible area cost and with no performance impact. combining trustnet and datawatch with prior work on fault detection has the potential to provide complete coverage against a large class of microprocessor attacks.
crossing the "valley of death": transitioning research into commercial products - a personal perspective. many researchers with innovative ideas just never seem to be able to bring those ideas to market. one of the biggest problems with the cyber security research community is transitioning technology into commercial product. this paper discusses these technology transition activities from the view of a program manager and offers several examples of successful transition for consideration.
scifi - a system for secure face identification. we introduce scifi, a system for secure computation of face identification. the system performs face identification which compares faces of subjects with a database of registered faces. the identification is done in a secure way which protects both the privacy of the subjects and the confidentiality of the database. a specific application of scifi is reducing the privacy impact of camera based surveillance. in that scenario, scifi would be used in a setting which contains a server which has a set of faces of suspects, and client machines which might be cameras acquiring images in public places. the system runs a secure computation of a face recognition algorithm, which identifies if an image acquired by a client matches one of the suspects, but otherwise reveals no information to neither of the parties. our work includes multiple contributions in different areas: a new face identification algorithm which is unique in having been specifically designed for usage in secure computation. nonetheless, the algorithm has face recognition performance comparable to that of state of the art algorithms. we ran experiments which show the algorithm to be robust to different viewing conditions, such as illumination, occlusions, and changes in appearance (like wearing glasses). a secure protocol for computing the new face recognition algorithm. in addition, since our goal is to run an actual system, considerable effort was made to optimize the protocol and minimize its online latency. a system - scifi, which implements a secure computation of the face identification protocol. experiments which show that the entire system can run in near real-time: the secure computation protocol performs a preprocessing of all public-key cryptographic operations. its online performance therefore mainly depends on the speed of data communication, and our experiments show it to be extremely efficient.
noninterference through secure multi-execution. a program is defined to be noninterferent if its outputs cannot be influenced by inputs at a higher security level than their own. various researchers have demonstrated how this property (or closely related properties) can be achieved through information flow analysis, using either a static analysis (with a type system or otherwise), or using a dynamic monitoring system. we propose an alternative approach, based on a technique we call secure multi-execution. the main idea is to execute a program multiple times, once for each security level, using special rules for i/o operations. outputs are only produced in the execution linked to their security level. inputs are replaced by default inputs except in executions linked to their security level or higher. input side effects are supported by making higher-security-level executions reuse inputs obtained in lower-security-level threads. we show that this approach is interesting from both a theoretical and practical viewpoint. theoretically, we prove for a simple deterministic language with i/o operations, that this approach guarantees complete soundness (even for the timing and termination covert channels), as well as good precision (identical i/o for terminating runs of termination-sensitively noninterferent programs). on the practical side, we present an experiment implementing secure multi-execution in the mainstream spider-monkey javascript engine, exploiting parallelism on a current multi-core computer. benchmark results of execution time and memory for the google chrome v8 benchmark suite show that the approach is practical for a mainstream browser setting. certain programs are even executed faster under secure multi-execution than under the standard execution. we discuss challenges and propose possible solutions for implementing the technique in a real browser, in particular handling the dom tree and browser callback functions. finally, we discuss how secure multi-execution can be extended to handle language features like exceptions, concurrency or no determinism.
a symbolic execution framework for javascript. as ajax applications gain popularity, client-side javascript code is becoming increasingly complex. however, few automated vulnerability analysis tools for javascript exist. in this paper, we describe the first system for exploring the execution space of javascript code using symbolic execution. to handle javascript code’s complex use of string operations, we design a new language of string constraints and implement a solver for it. we build an automatic end-to-end tool, kudzu, and apply it to the problem of finding client-side code injection vulnerabilities. in experiments on 18 live web applications, kudzu automatically discovers 2 previously unknown vulnerabilities and 9 more that were previously found only with a manually-constructed test suite. the acm portal is published by the association for computing machinery. copyright © 2010 acm, inc. terms of usage privacy policy code of ethics contact us useful downloads: adobe acrobat quicktime windows media player real player
history of us government investments in cybersecurity research: a personal perspective. this paper traces the history of cyber security research funding by the u.s. government. difficulties in accurately measuring the level of u.s. government research funding for cyber security are first described. some of the legislative and bureaucratic mechanisms involved in funding and reporting such research today are reviewed. a qualitative, personal perspective on the ups and downs of us cyber security research funding from the late 1960s to 2010 is then provided. the essay is written for the thirtieth anniversary meeting of the ieee symposium on security and privacy, held in may 2010.
side-channel leaks in web applications: a reality today, a challenge tomorrow. with software-as-a-service becoming mainstream, more and more applications are delivered to the client through the web. unlike a desktop application, a web application is split into browser-side and server-side components. a subset of the application’s internal information flows are inevitably exposed on the network. we show that despite encryption, such a side-channel information leak is a realistic and serious threat to user privacy. specifically, we found that surprisingly detailed sensitive information is being leaked out from a number of high-profile, top-of-the-line web applications in healthcare, taxation, investment and web search: an eavesdropper can infer the illnesses/medications/surgeries of the user, her family income and investment secrets, despite https protection; a stranger on the street can glean enterprise employees' web search queries, despite wpa/wpa2 wi-fi encryption. more importantly, the root causes of the problem are some fundamental characteristics of web applications: stateful communication, low entropy input for better interaction, and significant traffic distinctions. as a result, the scope of the problem seems industry-wide. we further present a concrete analysis to demonstrate the challenges of mitigating such a threat, which points to the necessity of a disciplined engineering practice for side-channel mitigations in future web application developments.
state of the art: automated black-box web application vulnerability testing. black-box web application vulnerability scanners are automated tools that probe web applications for security vulnerabilities. in order to assess the current state of the art, we obtained access to eight leading tools and carried out a study of: (i) the class of vulnerabilities tested by these scanners, (ii) their effectiveness against target vulnerabilities, and (iii) the relevance of the target vulnerabilities to vulnerabilities found in the wild. to conduct our study we used a custom web application vulnerable to known and projected vulnerabilities, and previous versions of widely used web applications containing known vulnerabilities. our results show the promise and effectiveness of automated tools, as a group, and also some limitations. in particular, "stored" forms of cross site scripting (xss) and sql injection (sqli) vulnerabilities are not currently found by many tools. because our goal is to assess the potential of future research, not to evaluate specific vendors, we do not report comparative data or make any recommendations about purchase of specific tools. the acm portal is published by the association for computing machinery. copyright © 2010 acm, inc. terms of usage privacy policy code of ethics contact us useful downloads: adobe acrobat quicktime windows media player real player
towards static flow-based declassification for legacy and untrusted programs. simple non-interference is too restrictive for specifying and enforcing information flow policies in most programs. exceptions to non-interference are provided using declassification policies. several approaches for enforcing declassification have been proposed in the literature. in most of these approaches, the declassification policies are embedded in the program itself or heavily tied to the variables in the program being analyzed, thereby providing little separation between the code and the policy. consequently, the previous approaches essentially require that the code be trusted, since to trust that the correct policy is being enforced, we need to trust the source code. in this paper, we propose a novel framework in which declassification policies are related to the source code being analyzed via its i/o channels. the framework supports many of the of declassification policies identified in the literature. based on flow-based static analysis, it represents a first step towards a new approach that can be applied to untrusted and legacy source code to automatically verify that the analyzed program complies with the specified declassification policies. the analysis works by constructing a conservative approximation of expressions over input channel values that could be output by the program, and by determining whether all such expressions satisfy the declassification requirements stated in the policy. we introduce a representation of such expressions that resembles tree automata. we prove that if a program is considered safe according to our analysis then it satisfies a property we call policy controlled release, which formalizes information-flow correctness according to our notion of declassification policy. we demonstrate, through examples, that our approach works for several interesting and useful declassification policies, including one involving declassification of the average of several confidential values. the acm portal is published by the association for computing machinery. copyright © 2010 acm, inc. terms of usage privacy policy code of ethics contact us useful downloads: adobe acrobat quicktime windows media player real player
scalable parametric verification of secure systems: how to verify reference monitors without worrying about data structure size. the security of systems such as operating systems, hypervisors, and web browsers depend critically on reference monitors to correctly enforce their desired security policy in the presence of adversaries. recent progress in developing reference monitors with small code size and narrow interfaces has made automated formal verification of reference monitors a more tractable goal. however, a significant remaining factor for the complexity of automated verification is the size of the data structures (e.g., access control matrices) over which the programs operate. this paper develops a parametric verification technique that scales even when reference monitors and adversaries operate over unbounded, but finite data structures. specifically, we develop a parametric guarded command language for modeling reference monitors and adversaries. we also present a parametric temporal specification logic for expressing security policies that the monitor is expected to enforce. the central technical results of the paper are a set of small model theorems. these theorems state that in order to verify that a policy is enforced by a reference monitor with an arbitrarily large data structure, it is sufficient to model check the monitor with just one entry in its data structure. we apply our methodology to verify the designs of two hypervisors, secvisor and the shype mandatory-access-control extension to xen. our approach is able to prove that shype and a variant of the original secvisor design correctly enforces the expected security properties in the presence of powerful adversaries.
trustvisor: efficient tcb reduction and attestation. an important security challenge is to protect the execution of security-sensitive code on legacy systems from malware that may infect the os, applications, or system devices. prior work experienced a tradeoff between the level of security achieved and efficiency. in this work, we leverage the features of modern processors from amd and intel to overcome the tradeoff to simultaneously achieve a high level of security and high performance. we present trustvisor, a special-purpose hypervisor that provides code integrity as well as data integrity and secrecy for selected portions of an application. trustvisor achieves a high level of security, first because it can protect sensitive code at a very fine granularity, and second because it has a very small code base (only around 6k lines of code) that makes verification feasible. trustvisor can also attest the existence of isolated execution to an external entity. we have implemented trustvisor to protect security-sensitive code blocks while imposing less than 7% overhead on the legacy os and its applications in the common case.
outside the closed world: on using machine learning for network intrusion detection. in network intrusion detection research, one popular strategy for finding attacks is monitoring a network's activity for anomalies: deviations from profiles of normality previously learned from benign traffic, typically identified using tools borrowed from the machine learning community. however, despite extensive academic research one finds a striking gap in terms of actual deployments of such systems: compared with other intrusion detection approaches, machine learning is rarely employed in operational "real world" settings. we examine the differences between the network intrusion detection problem and other areas where machine learning regularly finds much more success. our main claim is that the task of finding attacks is fundamentally different from these other applications, making it significantly harder for the intrusion detection community to employ machine learning effectively. we support this claim by identifying challenges particular to network intrusion detection, and provide a set of guidelines meant to strengthen future research on anomaly detection.
a proof-carrying file system. we present the design and implementation of pcfs, a file system that adapts proof-carrying authorization to provide direct, rigorous, and efficient enforcement of dynamic access policies. the keystones of pcfs are a new authorization logic bl that supports policies whose consequences may change with both time and system state, and a rigorous enforcement mechanism that combines proof verification with conditional capabilities. we prove that our enforcement using capabilities is correct, and evaluate our design through performance measurements and a case study.
revocation systems with very small private keys. in this work, we design a method for creating public key broadcast encryption systems. our main technical innovation is based on a new "two equation" technique for revoking users. this technique results in two key contributions: first, our new scheme has ciphertext size overhead $o(r)$, where $r$ is the number of revoked users, and the size of public and private keys is only a \emph{constant} number of group elements from an elliptic-curve group of prime order. in addition, the public key allows us to encrypt to an unbounded number of users. our system is the first to achieve such parameters. we give two versions of our scheme: a simpler version which we prove to be selectively secure in the standard model under a new, but non-interactive assumption, and another version that employs the new dual system encryption technique of waters to obtain adaptive security under the d-bdh and decisional linear assumptions. second, we show that our techniques can be used to realize attribute-based encryption (abe) systems with non-monotonic access formulas, where our key storage is significantly more efficient than previous solutions. this result is also proven selectively secure in the standard model under our new non-interactive assumption. the acm portal is published by the association for computing machinery. copyright © 2010 acm, inc. terms of usage privacy policy code of ethics contact us useful downloads: adobe acrobat quicktime windows media player real player
synthesizing near-optimal malware specifications from suspicious behaviors. fueled by an emerging underground economy, malware authors are exploiting vulnerabilities at an alarming rate. to make matters worse, obfuscation tools are commonly available, and much of the malware is open source, leading to a huge number of variants. behavior-based detection techniques are a promising solution to this growing problem. however, these detectors require precise specifications of malicious behavior that do not result in an excessive number of false alarms. in this paper, we present an automatic technique for extracting optimally discriminative specifications, which uniquely identify a class of programs. such a discriminative specification can be used by a behavior-based malware detector. our technique, based on graph mining and concept analysis, scales to large classes of programs due to probabilistic sampling of the specification space. our implementation, called holmes, can synthesize discriminative specifications that accurately distinguish between programs, sustaining an 86% detection rate on new, unknown malware, with 0 false positives, in contrast with 55% for commercial signature-based antivirus (av) and 62-64% for behavior-based av (commercial or research).
tensor-rank and lower bounds for arithmetic formulas. we show that any explicit example for a tensor a:[n]r -> f with tensor-rank ≥ nr ⋅ (1- o(1)), (where r ≤ log n / log log n), implies an explicit super-polynomial lower bound for the size of general arithmetic formulas over f. this shows that strong enough lower bounds for the size of arithmetic formulas of depth 3 imply super-polynomial lower bounds for the size of general arithmetic formulas. one component of our proof is a new approach for homogenization and multilinearization of arithmetic formulas, that gives the following results: we show that for any n-variate homogenous polynomial f of degree r, if there exists a (fanin-2) formula of size s and depth d for f then there exists a homogenous formula of size o ( d+r+1/r ⋅ s) for f. in particular, for any r ≤ log n / log log n, r ≤ log n, if there exists a polynomial size formula for f then there exists a polynomial size homogenous formula for f. this refutes a conjecture of nisan and wigderson [10] and shows that super-polynomial lower bounds for homogenous formulas for polynomials of small degree imply super-polynomial lower bounds for general formulas. we show that for any n-variate set-multilinear polynomial f of degree r, if there exists a (fanin-2) formula of size s and depth d for f then there exists a set-multilinear formula of size o ( (d+2)r ⋅ s ) for f. in particular, for any r ≤ log n / log log n, if there exists a polynomial size formula for f then there exists a polynomial size set-multilinear formula for f. this shows that super-polynomial lower bounds for set-multilinear formulas for polynomials of small degree imply super-polynomial lower bounds for general formulas.
near-optimal extractors against quantum storage. we show that trevisan's extractor and its variants [22,19] are secure against bounded quantum storage adversaries. one instantiation gives the first such extractor to achieve an output length θ(k-b), where k is the source's entropy and b the adversary's storage, together with a poly-logarithmic seed length. another instantiation achieves a logarithmic key length, with a slightly smaller output length θ((k-b)/kγ) for any γ>0. in contrast, the previous best construction [21] could only extract (k/b)1/15 bits. some of our constructions have the additional advantage that every bit of the output is a function of only a polylogarithmic number of bits from the source, which is crucial for some cryptographic applications. our argument is based on bounds for a generalization of quantum random access codes, which we call quantum functional access codes. this is crucial as it lets us avoid the local list-decoding algorithm central to the approach in [21], which was the source of the multiplicative overhead.