waashk/dblp huggingface dataset:
an interface specification language for automatically analyzing cryptographic protocols. this paper describes a simple interface specification language (isl) for cryptographic protocols and their desired properties, and an automatic authentication protocol analyzer (aapa) that automatically either proves-using an extension of the gong, needham, yahalom (1990) belief logic-that specified protocols have their desired properties, or identifies precisely where these proof attempts fail. the isl and the aapa make it easy for protocol designers to incorporate formal analysis into the protocol design process, where they clarify designs and reveals a large class of common errors. the isl and the aapa have already shown potential deficiencies in published protocols and been useful in designing new protocols.
efficient distribution of key chain commitments for broadcast authentication in distributed sensor networks. broadcast authentication is a fundamental security service in distributed sensor networks. a scheme named $\mu$tesla has been proposed for efficient broadcast authentication in such networks. however, $\mu$tesla requires initial distribution of certain information based on unicast between the base station and each sensor node before the actual authentication of broadcast messages. due to the limited bandwidth in wireless sensor networks, this initial unicast-based distribution severely limits the application of $\mu$tesla in large sensor networks. this paper presents a novel technique to replace the unicast-based initialization with a broadcast-based one. as a result, $\mu$tesla can be used in a sensor network with a large amount of sensors, as long as the message from the base station can reach these sensor nodes. this paper further explores several techniques that improve the performance, the robustness, as well as the security of the proposed method. the resulting protocol satisfies several nice properties, including low overhead, tolerance of message loss, scalability to large networks, and resistance to replay attacks as well as some known denial of service (dos) attacks.
bluebox: a policy-driven, host-based intrusion detection system. detecting attacks against systems has, in practice, largely been delegated to sensors, such as network intrustion detection systems. however, due to the inherent limitations of these systems and the increasing use of encryption in communication, intrusion detection and prevention have once again moved back to the host systems themselves. in this paper, we describe our experiences with building bluebox, a host-based intrusion detection system. our approach, based on the technique of system call introspection, can be viewed as creating an infrastructure for defining and enforcing very fine-grained process capabilities in the kernel. these capabilities are specified as a set of rules (policies) for regulating access to system resources on a per executable basis. the language for expressing the rules is intuitive and sufficiently expressive to effectively capture security boundaries.we have prototyped our approach on linux operating system kernel and have built rule templates for popular daemons such as apache and wu-ftpd. our design has been validated by testing against a comprehensive database of known attacks. our system has been designed to minimize the kernel changes and performance impact and thus can be ported easily to new kernels. we describe the motivation and rationale behind bluebox, its design, implementation on linux, and how it relates to prior work on detecting and preventing intrusions on host systems.
blocking java applets at the firewall. this paper explores the problem of protecting a site on the internet against hostile external java applets while allowing trusted internal applets to run. with careful implementation, a site can be made resistant to current java security weaknesses as well as those yet to be discovered. in addition, we describe a new attack on certain sophisticated firewalls that is most effectively realized as a java applet.
performance analysis of tls web servers. tls is the protocol of choice for securing today's e-commerce and online transactions but adding tls to a web server imposes a significant overhead relative to an insecure web server on the same platform. we perform a comprehensive study of the performance costs of tls. our methodology is to profile tls web servers with trace-driven workloads, replace individual components inside tls with no-ops, and measure the observed increase in server throughput. we estimate the relative costs of each tls processing stage, identifying the areas for which future optimizations would be worthwhile. our results show that while the rsa operations represent the largest performance cost in tls web servers, they do not solely account for tls overhead. rsa accelerators are effective for e-commerce site workloads since they experience low tls session reuse. accelerators appear to be less effective for sites where all the requests are handled by a tls server because they have a higher session reuse rate. in this case, investing in a faster cpu might provide a greater boost in performance. our experiments show that having a second cpu is at least as useful as an rsa accelerator. our results seem to suggest that, as cpus become faster, the cryptographic costs of tls will become dwarfed by the cpu costs of the nonsecurity aspects of a web server. optimizations aimed at general purpose web servers should continue to be a focus of research and would benefit secure web servers as well.
an algebraic approach to ip traceback. we present a new solution to the problem of determining the path a packet traversed over the internet (called the traceback problem) during a denial-of-service attack. this article reframes the traceback problem as a polynomial reconstruction problem and uses algebraic techniques from coding theory and learning theory to provide robust methods of transmission and reconstruction.
misplaced trust: kerberos 4 session keys. one of the commonly accepted principles of software design for security is that making the source code openly available leads to better security. the presumption is that the open publication of source code will lead others to review the code for errors, however this openness is no guarantee of correctness. one of the most widely published and used pieces of security software in recent memory is the mit implementation of the kerberos authentication protocol. in the design of the protocol, random session keys are the basis for establishing the authenticity of service requests. because of the way that the kerberos version 4 implementation selected its random keys, the secret keys could easily be guessed in a matter of seconds. this paper discusses the difficulty of generating good random numbers, the mistakes that were made in implementing kerberos version 4, and the breakdown of software engineering that allowed this flaw to remain unfixed for ten years. we discuss this as a particularly notable example of the need to examine security-critical code carefully, even when it is made publicly available.
continuous assessment of a unix configuration: integrating intrusion detection and configuration analysis. computer security is a topic of growing concern because, on the one hand, the power of computers continues to increase at exponential speed and all computers are virtually connected to each other and because, on the other hand, the lack of reliability of software systems may cause dramatic and unrecoverable damage to computer systems and hence to the newly emerging computerized society. among the possible approaches to improve the current situation, expert systems have been advocated to be an important one. typical tasks that such expert systems attempt to achieve include finding system vulnerabilities and detecting malicious behaviors of users.in this paper, we extend our intrusion detection system asax with a deductive subsystem that allows us to assess the security level of a software configuration on a real time basis. by coupling the two subsystems --- intrusion detection and configuration analysis --- we moreover achieve a better tuning of the intrusion detection since the system has only to enable intrusion detection rules that are specifically required by the current state of the configuration. we also report some preliminary performance measurements, which suggest that our approach can be practical in real life contexts.
authentication and integrity in outsourced databases. in the outsourced database (odb) model, entities outsource their data management needs to a third-party service provider. such a service provider offers mechanisms for its clients to create, store, update, and access (query) their databases. this work provides mechanisms to ensure data integrity and authenticity for outsourced databases. specifically, this article provides mechanisms that assure the querier that the query results have not been tampered with and are authentic (with respect to the actual data owner). it investigates both the security and efficiency aspects of the problem and constructs several secure and practical schemes that facilitate the integrity and authenticity of query replies while incurring low computational and communication costs.
experimental results of covert channel limitation in one-way communication systems. with the increasing growth of electronic communications, it is becoming important to provide a mechanism for enforcing various security policies on network communications. this paper discusses our implementation of several previously proposed protocols that enforce the bell-lapadula (1973) security model. we also introduce a new protocol called "quantized pump" that offers several advantages, and present experimental results to support our claims.
file system design with assured delete. this paper describes a system that supports high availability of data, until the data should be expunged, at which time the system makes it impossible to recover the data. this design supports two types of assured delete; where the expiration time is known at file creation, and on-demand delete of individual files. the design assures previous work has described how to do this when the expiration time of a file is known at file creation time, and was particularly suited to supporting many independent clients. this paper reviews that work, but also describes how to support on-demand deletion of individual files.
distributed authentication in kerberos using public key cryptography. in this work we describe a method for fully distributed authentication using public key cryptography within the kerberos ticket framework. by distributing most of the authentication workload away from the trusted intermediary and to the communicating parties, significant enhancements to security and scalability can be achieved as compared to kerberos v5. privacy of kerberos clients is also enhanced. a working implementation of this extended protocol has been developed, and a migration plan is proposed for a transition from traditional to public key based kerberos.
securing the nimrod routing architecture. this paper describes the work undertaken to secure nimrod, a complex and sophisticated routing system that unifies interior and exterior routing functions. the focus of this work is countering attacks that would degrade or deny service to network subscribers. the work began with an analysis of security requirements for nimrod, based on a hybrid approach that refines top-down requirements generation with an understanding of attack scenarios and the capabilities and limitations of countermeasures. the countermeasures selected for use here include several newly developed sequence integrity mechanisms, plus a protocol for shared secret establishment. a novel aspect of this work is the protection of subscriber traffic in support of the overall communication availability security goal.
trust models in ice-tel. public key certification provides mechanisms that can be used to build truly scaleable security services, such as allowing people who have never met to have assurance of each others identity. authentication involves syntactic verification of a certificate chain followed by a semantic look at the policies under which the certificates were issued. this results in a level of assurance that the identity of the person to be authenticated is an accurate description of the person involved, and requires verifiers to specify who they trust and what they trust them to do. two widely discussed mechanisms for specifying this trust, the pem and pgp trust models, approach the problem from fundamentally different directions. the ec funded ice-tel project, which is deploying a security infrastructure and application set for the european research community, has described a new trust model that attempts to be equally applicable to organization-centric pem users and user-centric pgp users.
teapot: language support for writing memory coherence protocols. recent shared-memory parallel computer systems offer the exciting possibility of customizing memory coherence protocols to fit an application's semantics and sharing patterns. custom protocols have been used to achieve message-passing performance---while retaining the convenient programming model of a global address space---and to implement high-level language constructs. unfortunately, coherence protocols written in a conventional language such as c are difficult to write, debug, understand, or modify. this paper describes teapot, a small, domain-specific language for writing coherence protocols. teapot uses continuations to help reduce the complexity of writing protocols. simple static analysis in the teapot compiler eliminates much of the overhead of continuations and results in protocols that run nearly as fast as hand-written c code. a teapot specification can be compiled both to an executable coherence protocol and to input for a model checking system, which permits the specification to be verified. we report our experiences coding and verifying several protocols written in teapot, along with measurements of the overhead incurred by writing a protocol in a higher-level language.
selective interpretation as a technique for debugging computationally intensive programs. as part of rice university's project to build a programming environment for scientific software, we have built a facility for program execution that solves some of the problems inherent in debugging large, computationally intensive programs. by their very nature such programs do not lend themselves to full-scale interpretation. in moderation however, interpretation can be extremely useful during the debugging process. in addition to discussing the particular benefits that we expect from interpretation, this paper addresses how interpretive techniques can be effectively used in conjunction with the execution of compiled code. the same implementation technique that permits interpretation to be incorporated as part of execution will also permit the execution facility to be used for debugging parallel programs running on a remote machine.
analysis of pointers and structures. compilers can make good use of knowledge about the shape of data structures and the values that pointers assume during execution. we present results which show how a compiler can automatically determine some of this information. we believe that practical analyses based on this work can be used in compilers for languages that provide linked data structures. the analysis we present obtains useful information about linked data structures. we summarize unbounded data structures by taking advantage of structure present in the original program. the worst-case time bounds for a naive algorithm are high-degree polynomial, but for the expected (sparse) case we have an efficient algorithm. previous work has addressed time bounds rarely, and efficient algorithms not at all. the quality of information obtained by this analysis appears to be (generally) an improvement on what is obtained by existing techniques. a simple extension obtains aliasing information for entire data structures that previously was obtained only through declarations. previous work has shown that this information, however obtained, allows worthwhile optimization.
partial dead code elimination using slicing transformations. we present an approach for optimizing programs that uncovers additional opportunities for optimization of a statement by predicating the statement. in this paper predication algorithms for achieving partial dead code elimination (pde) are presented. the process of predication embeds a statement in a control flow structure such that the statement is executed only if the execution follows a path along which the value computed by the statement is live. the control flow restructuring performed to achieve predication is expressed through slicing transformations. this approach achieves pde that is not realizable by existing algorithms. we prove that our algorithm never increases the operation count along any path, and that for acyclic code all partially dead statements are eliminated. the slicing transformation that achieves predication introduces into the program additional conditional branches. these branches are eliminated in a branch deletion step based upon code duplication. we also show how pde can be used by acyclic schedulers for vliw processors to reduce critical path lengths along frequently executed paths.
an experimental analysis of self-adjusting computation. dependence graphs and memoization can be used to efficiently update the output of a program as the input changes dynamically. recent work has studied techniques for combining these approaches to effectively dynamize a wide range of applications. toward this end various theoretical results were given. in this paper we describe the implementation of a library based on these ideas, and present experimental results on the efficiency of this library on a variety of applications. the results of the experiments indicate that the approach is effective in practice, often requiring orders of magnitude less time than recomputing the output from scratch. we believe this is the first experimental evidence that incremental computation of any type is effective in practice for a reasonably broad set of applications.
abcd: eliminating array bounds checks on demand. to guarantee typesafe execution, java and other strongly typed languages require bounds checking of array accesses. because array-bounds checks may raise exceptions, they block code motion of instructions with side effects, thus preventing many useful code optimizations, such as partial redundancy elimination or instruction scheduling of memory operations. furthermore, because it is not expressible at bytecode level, the elimination of bounds checks can only be performed at run time, after the bytecode program is loaded. using existing powerful bounds-check optimizers at run time is not feasible, however, because they are too heavyweight for the dynamic compilation setting. abcd is a light-weight algorithm for elimination of array bounds checks on demand. its design emphasizes simplicity and efficiency. in essence, abcd works by adding a few edges to the ssa value graph and performing a simple traversal of the graph. despite its simplicity, abcd is surprisingly powerful. on our benchmarks, abcd removes on average 45% of dynamic bound check instructions, sometimes achieving near-ideal optimization. the efficiency of abcd stems from two factors. first, abcd works on a sparse representation. as a result, it requires on average fewer than 10 simple analysis steps per bounds check. second, abcd is demand-driven. it can be applied to a set of frequently executed (hot) bounds checks, which makes it suitable for the dynamic-compilation setting, in which compile-time cost is constrained but hot statements are known.
first-class data-type representations in schemexerox. in most programming language implementations, the compiler has detailed knowledge of the representations of and operations on primitive data typed and data-type constructors. in schemexerox, this knowledge is almost entirely external to the compiler, in ordinary, procedural user code. the primitive representations and operations are embodied in first-class &ldquo;representation types&rdquo; that are constructed and implemented in an abstract and high-level fashion. despite this abstractness, a few generally-useful optimizing transformations are sufficient to allow the schemexerox compiler to generate efficient code for the primitive operations, essentially as good as could be achieved using more contorted, traditional techniques.
fast, effective code generation in a just-in-time java compiler. a "just-in-time" (jit) java compiler produces native code from java byte code instructions during program execution. as such, compilation speed is more important in a java jit compiler than in a traditional compiler, requiring optimization algorithms to be lightweight and effective. we present the structure of a java jit compiler for the intel architecture, describe the lightweight implementation of jit compiler optimizations (e.g., common subexpression elimination, register allocation, and elimination of array bounds checking), and evaluate the performance benefits and tradeoffs of the optimizations. this jit compiler has been shipped with version 2.5 of intel's vtune for java product.
branch prediction for free. many compilers rely on branch prediction to improve program performance by identifying frequently executed regions and by aiding in scheduling instructions.profile-based predictors require a time-consuming and inconvenient compile-profile-compile cycle in order to make predictions. we present a program-based branch predictor that performs well for a large and diverse set of programs written in c and fortran. in addition to using natural loop analysis to predict branches that control the iteration of loops, we focus on heuristics for predicting non-loop branches, which dominate the dynamic branch count of many programs. the heuristics are simple and require little program analysis, yet they are effective in terms of coverage and miss rate. although program-based prediction does not equal the accuracy of profile-based prediction, we believe it reaches a sufficiently high level to be useful. additional type and semantic information available to a compiler would enhance our heuristics.
unification-based pointer analysis with directional assignments. this paper describes a new algorithm for flow and context insensitive pointer analysis of c programs. our studies show that the most common use of pointers in c programs is in passing the addresses of composite objects or updateable values as arguments to procedures. therefore, we have designed a low-cost algorithm that handles this common case accurately. in terms of both precision and running time, this algorithm lies between steensgaard's algorithm, which treats assignments bi-directionally using unification, and andersen's algorithm, which treats assignments directionally using subtyping. our &ldquo;one level flow&rdquo; algorithm uses a restricted form of subtyping to avoid unification of symbols at the top levels of pointer chains in the points-to graph, while using unification elsewhere in the graph. the method scales easily to large programs. for instance, we are able to analyze a 1.4 mloc (million lines of code) program in two minutes, using less than 200mb of memory. at the same time, the precision of our algorithm is very close to that of andersen's algorithm. on all of the integer benchmark programs from spec95, the one level flow algorithm and andersen's algorithm produce either identical or essentially identical points-to information. therefore, we claim that our algorithm provides a method for obtaining precise flow-insensitive points-to information for large c programs.