waashk/dblp huggingface dataset:
locating hidden servers. hidden services were deployed on the tor anonymous communication network in 2004. announced properties include server resistance to distributed dos. both the eff and reporters without borders have issued guides that describe using hidden services via tor to protect the safety of dissidents as well as to resist censorship. we present fast and cheap attacks that reveal the location of a hidden server. using a single hostile tor node we have located deployed hidden servers in a matter of minutes. although we examine hidden services over tor, our results apply to any client using a variety of anonymity networks. in fact, these are the first actual intersection attacks on any deployed public network: thus confirming general expectations from prior theory and simulation. we recommend changes to route selection design and implementation for tor. these changes require no operational increase in network overhead and are simple to make; but they prevent the attacks we have demonstrated. they have been implemented.
efficient multicast packet authentication using signature amortization. we describe a novel method for authenticating multicast packetsthat is robust against packet loss. our main focus is to minimize the sizeof the communication overhead required to authenticate the packets. ourapproach is to encode the hash values and the signatures with rabin'sinformation dispersal algorithm (ida) to construct an authenticationscheme that amortizes a single signature operation over multiple packets.this strategy is especially efficient in terms of space overhead, becausejust the essential elements needed for authentication (i.e., one hash perpacket and one signature per group of packets) are used in conjunctionwith an erasure code that is space optimal. to evaluate the performance ofour scheme, we compare our technique with four other previously proposedschemes using analytical and empirical results. two different bursty lossmodels are considered in the analyses.
distributed detection of node replication attacks in sensor networks. the low-cost, off-the-shelf hardware components in unshielded sensor-network nodes leave them vulnerable to compromise. with little effort, an adversary may capture nodes, analyze and replicate them, and surreptitiously insert these replicas at strategic locations within the network. such attacks may have severe consequences; they may allow the adversary to corrupt network data or even disconnect significant parts of the network. previous node replication detection schemes depend primarily on centralized mechanisms with single points of failure, or on neighborhood voting protocols that fail to detect distributed replications. to address these fundamental limitations, we propose two new algorithms based on emergent properties, i.e., properties that arise only through the collective action of multiple nodes. randomized multicast distributes node location information to randomly-selected witnesses, exploiting the birthday paradox to detect replicated nodes, while line-selected multicast uses the topology of the network to detect replication. both algorithms provide globally-aware, distributed node-replica detection, and line-selected multicast displays particularly strong performance characteristics. we show that emergent algorithms represent a promising new approach to sensor network security; moreover, our results naturally extend to other classes of networks in which nodes can be captured, replicated and re-inserted by an adversary.
number theoretic attacks on secure password schemes. abstract: encrypted key exchange (eke) (s. bellovin and m. merritt, 1992; 1993) allows two parties sharing a password to exchange authenticated information over an insecure network by using a combination of public and secret key cryptography. eke promises security against active attacks and dictionary attacks. other secure protocols have been proposed based on the use of randomized confounders (l. gong et al., 1993). we use some basic results from number theory to present password guessing attacks on all versions of eke discussed in the paper (s. bellovin and m. merritt, 1992) and we also offer countermeasures to the attacks. however for the rsa version of eke, we show that simple modifications are not enough to rescue the protocol. attacks are also presented on half encrypted versions of eke. we also show how randomized confounders cannot protect direct authentication protocol and secret public key protocol versions of a secure password scheme from attacks. we discuss why these attacks are possible against seemingly secure protocols and what is necessary to make secure protocols.
on the secrecy of timing-based active watermarking trace-back techniques. timing-based active watermarking schemes are developed to trace back attackers through stepping stone connections or anonymizing networks. by slightly changing packet timing, these schemes achieve robust correlation for encrypted network connections under timing perturbation. however, the manipulation on packet timing makes the schemes themselves a potential target of intelligent attackers. in this paper, we analyze the secrecy of the timingbased active watermarking techniques for tracing through stepping stones, and propose an attack scheme based on analyzing the packet delays between adjacent stepping stones. we develop attack techniques to infer important watermark parameters, and to recover and duplicate embedded watermarks. the resulting techniques enable an attacker to defeat the tracing systems in certain cases by removing watermarks from the stepping stone connections, or replicating watermarks in non-stepping stone connections. we also develop techniques to determine in real-time whether a stepping stone connection is being watermarked for trace-back purposes. we have performed substantial experiments using real-world data to evaluate these techniques. the experimental results demonstrate that for the watermark scheme being attacked (1) embedded watermarks can be successfully recovered and duplicated when the watermark parameters are not chosen carefully, and (2) the existence of watermarks in a network flow can always be quickly detected.
limitations on design principles for public key protocols. recent papers have taken a new look at cryptographic protocols from the perspective of proposing design principles. for years the main approach to cryptographic protocols has been logical, and a number of papers have examined the limitations of those logics. this paper takes a similar cautionary look at the design principal approach. limitations and exceptions are offered on some of the previously given basic design principals. the focus is primarily on public key protocols, especially on the order of signature and encryption. but, other principles are discussed as well. apparently secure protocols that fail to meet principles are presented. also presented are new attacks on protocols as well as previously claimed attacks which are not.
anonymous connections and onion routing. onion routing provides anonymous connections that are strongly resistant to both eavesdropping and traffic analysis. unmodified internet applications can use these anonymous connections by means of proxies. the proxies may also make communication anonymous by removing identifying information from the data stream. onion routing has been implemented on sun solaris 2.x with proxies for web browsing, remote logins, and e-mail. this paper's contribution is a detailed specification of the implemented onion routing system, a vulnerability analysis based on this specification, and performance results.
elk, a new protocol for efficient large-group key distribution. abstract: secure media broadcast over the internet poses unique security challenges. one problem access control to a large number of subscribers in a public broadcast. a common solution is to encrypt the broadcast data and to disclose the decryption key to legitimate receivers only. however, how do we securely and efficiently establish a shared secret among the legitimate receivers? and most importantly, how can we efficiently update the group key securely if receivers join or leave? how can we provide reliability for key update messages in a way that scales up to large groups? recent research makes substantial progress to address these challenges. current schemes feature efficient key update mechanisms assuming that the key updates are communicated reliably to the receivers. in practice, however, the principal impediment to achieve a scalable system is to distribute the key updates reliably to all receivers. we have designed and implemented elk, a novel key distribution protocol, to address these challenges with the following features:elk features perfectly reliable, super-efficient member joins.elk uses smaller key update messages than previous protocols.elk features a mechanism that allows short hint messages to be used for key recovery allowing a tradeoff of communication overhead with member computation.elk proposes to append a small amount of key update information to data packets, such that the majority of receivers can recover from lost key update messages.elk allows to trade off security with communication overhead.
hardening functions for large scale distributed computations. the past few years have seen the development of distributedcomputing platforms designed to utilize the spareprocessor cycles of a large number of personal computersattached to the internet in an effort to generate levelsof computing power normally achieved only with expensivesupercomputers. such large scale distributed computationsrunning in untrusted environments raise a numberof security concerns, including the potential for intentionalor unintentional corruption of computations, and for participantsto claim credit for computing that has not beencompleted. this paper presents two strategies for hardeningselected applications that utilize such distributed computations.specifically, we show that carefully seeding certaintasks with precomputed data can significantly increaseresistance to cheating (claiming credit for work not computed)and incorrect results. similar results are obtainedfor sequential tasks through a strategy of sharing the computationof n tasks among k > n nodes. in each case, theassociated cost is significantly less than the cost of assigningtasks redundantly.
the design and implementation of a multilevel secure log manager. abstract: this paper discusses the security issues involved in log management for a multilevel secure database system and presents a design and implementation of a prototype multilevel secure log manager. the main goal of a log manager is to provide high bandwidth and low flush latency. we examine the performance of our design, by observing the flush latency and log bandwidth. we also informally evaluate the security of our approach.
"why 6?" defining the operational limits of stide, an anomaly-based intrusion detector. anomaly-detection techniques have considerable promise for twodifficult and critical problems in information security and intrusiondetection: detecting novel attacks, and detecting masqueraders.oneof the best-known anomaly detectors used in intrusion detection isstide.developed at the university of new mexico, stide aims todetect attacks that exploit processes that run with root privileges.the original work on stide presented empirical results indicatingthat data sequences of length six and above were required foreffective intrusion detection.this observation has given rise tothe long-standing question, "why six?" accompanied by relatedquestions regarding the conditions under which six may or may not beappropriate.this paper addresses the "why six" issue by presenting anevaluation framework that maps out stide's effective operating space,and identifies the conditions that contribute to detectioncapability, particularly detection blindness.a theoreticaljustification explains the effectiveness of sequence lengths of sixand above, as well as the consequences of using other values.inaddition, results of an investigation are presented, comparingstide's anomaly-detection capabilities with those of a competingdetector.
a model for asynchronous reactive systems and its application to secure message transmission. abstract: we present a rigorous model for secure reactive systems in asynchronous networks with a sound cryptographic semantics, supporting abstract specifications and the composition of secure systems. this enables modular proofs of security, which is essential in bridging the gap between the rigorous proof techniques of cryptography and tool-supported formal proof techniques. the model follows the general simulatability approach of modern cryptography. a variety of network structures and trust models can be described, such as static and adaptive adversaries; some examples of this are given. as an example of our specification methodology we provide an abstract and complete specification for secure message transmission, improving on recent results by lynch, and verify one concrete implementation. our proof is based on a general theorem on the security of encryption in a reactive multi-user setting, generalizing a recent result by bellare et.al.
garbage collector memory accounting in language-based systems. language run-time systems are often called upon tosafely execute mutually distrustful tasks within the sameruntime, protecting them from other tasks' bugs or otherwisehostile behavior. well-studied access controls exist insystems such as java to prevent unauthorized reading orwriting of data, but techniques to measure and control resourceusage are less prevalent. in particular, most languagerun-time systems include no facility to account forand regulate heap memory usage on a per-task basis. thisoversight can be exploited by a misbehaving task, whichmight allocate and hold live enough memory to cause adenial-of-service attack, crashing or slowing down othertasks. in addition, tasks can legitimately share referencesto the same objects, and traditional approaches that chargememory to its allocator fail to properly account for thissharing. we present a method for modifying the garbagecollector, already present in most modern language run-timesystems, to measure the amount of live memory reachablefrom each task as it performs its regular duties. oursystem naturally distinguishes memory shared across tasksfrom memory reachable from only a single task without requiringincompatible changes to the semantics of the programminglanguage. our prototype implementation imposesnegligible performance overheads in a variety ofbenchmarks, yet provides enough information for the expressionof rich policies to express the limits on a task'smemory usage.
view-based access control with high assurance. view-based access control enables content-based and context-based security, as opposed to container-based security provided in operating systems. however, view-based access control in multilevel secure (mls) databases suffers from two problems: safety and assurance. we investigate view-based access control in mls relational databases for a large class of views expressible as project-select-join queries. we develop a polynomial-time label compilation algorithm that transforms view-level labeling to tuple-level labeling in such a way that guarantees safety and high assurance. we identify two problems related to optimal label compilation, and show that they are both np-complete even for totally ordered security lattices of size two.
run-time principals in information-flow type systems. information-flow type systems are a promising approach for enforcing strong end-to-end confidentiality and integrity policies. such policies, however, are usually specified in terms of static information&mdash;data is labeled high or low security at compile time. in practice, the confidentiality of data may depend on information available only while the system is running. this article studies language support for run-time principals, a mechanism for specifying security policies that depend on which principals interact with the system. we establish the basic property of noninterference for programs written in such language, and use run-time principals for specifying run-time authority in downgrading mechanisms such as declassification. in addition to allowing more expressive security policies, run-time principals enable the integration of language-based security mechanisms with other existing approaches such as java stack inspection and public key infrastructures. we sketch an implementation of run-time principals via public keys such that principal delegation is verified by certificate chains.
partitioning attacks: or how to rapidly clone some gsm cards. in this paper, we introduce a new class of side--channel attackscalled partitioning attacks. we have successfully launched a versionof the attack on several implementations of comp128, the popular gsmauthentication algorithm that has been deployed by different serviceproviders in several types of sim cards, to retrieve the 128 bit keyusing as few as 8 chosen plaintexts. we show how partitioning attackscan be used effectively to attack implementations that have beenequipped with ad hoc and inadequate countermeasures againstside--channel attacks. such ad hoc countermeasures are systemic inimplementations of cryptographic algorithms, such as comp128, whichrequire the use of large tables since there has been a mistaken beliefthat sound countermeasures require more resources than areavailable. to address this problem, we describe a newresource--efficient countermeasure for protecting table lookups incryptographic implementations and justify its correctness rigorously.
practical data-swapping: the first steps. the problem of statistical database confidentiality in releasing microdata is addressed through the use of approximate data-swapping. here, a portion of the microdata is replaced with a database that has been selected with approximately the same statistics. the result guarantees the confidentiality of the original data, while providing microdata with accurate statistics. methods for achieving such transformations are considered and analyzed through simulation.
toward acceptable metrics of authentication. abstract: authentication using a path of trusted intermediaries, each able to authenticate the next one in the path, is a well-known technique for authenticating entities in a large-scale system. recent work has extended this technique to include multiple paths in an effort to bolster authentication, but the success of this approach may be unclear in the face of intersecting paths, ambiguities in the meaning of certificates, and interdependencies in the use of different keys. several authors have thus proposed metrics to evaluate the confidence afforded by a set of paths. in this paper, we develop a set of guiding principles for the design of such metrics. we motivate our principles by showing how previous approaches fail with respect to them and what the consequences to authentication might be. we then propose a direction for constructing metrics that come closer to meeting our principles and thus, we believe, to being satisfactory metrics for authentication.
cobra: fine-grained malware analysis using stealth localized-executions. fine-grained code analysis in the context of malware is a complex and challenging task that provides insight into malware code-layers (polymorphic/metamorphic), its data encryption/ decryption engine, its memory layout etc., important pieces of information that can be used to detect and counter the malware and its variants. current research in fine-grained code analysis can be categorized into static and dynamic approaches. static approaches have been tailored towards malware and allow exhaustive fine-grained malicious code analysis, but lack support for self-modifying code, have limitations related to code-obfuscations and face the undecidability problem. given that most if not all malware employ self-modifying code and code-obfuscations, poses the need to analyze them at runtime using dynamic approaches. however, current dynamic approaches for fine-grained code analysis are not tailored specifically towards malware and lack support for multithreading, self-modifying/self-checking code and are easily detected and countered by ever-evolving anti-analysis tricks employed by malware. to address this problem we propose a powerful dynamic fine-grained malicious code analysis framework, codenamed cobra, to combat malware that are becoming increasingly hard to analyze. our goal is to provide a stealth, efficient, portable and easy-to-use framework supporting multithreading, self-modifying/self-checking code and any form of code obfuscation in both user- and kernel-mode on commodity operating systems. cobra cannot be detected or countered and can be dynamically and selectively deployed on malware specific code-streams while allowing other code-streams to execute as is. we also illustrate the framework utility by describing our experience with a tool employing cobra to analyze a real-world malware.
fingerprinting. this paper presents a generaldiscussion of the use of fingerprints, especiallyfingerprinted data, fingerprinting is classifiedin four orthogonal ways, and some illustrativeexamples are given. the basis for a statisticalanalysis of altered fingerprints is presented,along with an example simulation. the possibilityof more subtle fingerprints is discussed.
using model checking to analyze network vulnerabilities. even well administered networks are vulnerable to attacks due to the security ramifications of offering a variety of combined services. that is, services that are secure when offered in isolation nonetheless provide an attacker with a vulnerability to exploit when offered simultaneously. many current tools address vulnerabilities in the context of a single host. in this paper, we address vulnerabilities due to the configuration of various hosts in a network. in a different line of research, formal methods are often useful for generating test cases, and model checkers are particularly adept at this task due to their ability to generate counterexamples. in this paper, we address the network vulnerability problem with test cases, which amount to attack scenarios, generated by a model checker. we encode the vulnerabilities in a state machine description suitable for a model checker and then assert that an attacker cannot acquire a given privilege on a given host. the model checker either offers assurance that the assertion is true on the actual network or provides a counterexample detailing each step of a successful attack.
a communication agreement framework for access/action control. we introduce a framework for access/action control which shifts the emphasis from the participants to their relationships. the framework is based on a communication model in which participants negotiate the mutually agreed-upon boundary conditions of their relationships, and create social reference points by encapsulating them in compact "communication pacts," called "commpacts." commpacts are designed to provide a language enabling a social mechanism of coordinated expectation. we argue that in networked environments characterized by multiple authorities and "trusted proxies," this model can deal with the complexities of general (user- and content-dependent) distributed access/action control and provides a clear user-conceptual metaphor. the frame work embeds naturally into the existing legal and institutional infrastructure; it generalizes work in electronic contracting. commpacts can be seen as a third fundamental type next to access-control lists (acls) and capabilities.