434 research outputs found
An Iterative and Toolchain-Based Approach to Automate Scanning and Mapping Computer Networks
As today's organizational computer networks are ever evolving and becoming
more and more complex, finding potential vulnerabilities and conducting
security audits has become a crucial element in securing these networks. The
first step in auditing a network is reconnaissance by mapping it to get a
comprehensive overview over its structure. The growing complexity, however,
makes this task increasingly effortful, even more as mapping (instead of plain
scanning), presently, still involves a lot of manual work. Therefore, the
concept proposed in this paper automates the scanning and mapping of unknown
and non-cooperative computer networks in order to find security weaknesses or
verify access controls. It further helps to conduct audits by allowing
comparing documented with actual networks and finding unauthorized network
devices, as well as evaluating access control methods by conducting delta
scans. It uses a novel approach of augmenting data from iteratively chained
existing scanning tools with context, using genuine analytics modules to allow
assessing a network's topology instead of just generating a list of scanned
devices. It further contains a visualization model that provides a clear, lucid
topology map and a special graph for comparative analysis. The goal is to
provide maximum insight with a minimum of a priori knowledge.Comment: 7 pages, 6 figure
Towards Understanding Third-party Library Dependency in C/C++ Ecosystem
Third-party libraries (TPLs) are frequently reused in software to reduce
development cost and the time to market. However, external library dependencies
may introduce vulnerabilities into host applications. The issue of library
dependency has received considerable critical attention. Many package managers,
such as Maven, Pip, and NPM, are proposed to manage TPLs. Moreover, a
significant amount of effort has been put into studying dependencies in
language ecosystems like Java, Python, and JavaScript except C/C++. Due to the
lack of a unified package manager for C/C++, existing research has only few
understanding of TPL dependencies in the C/C++ ecosystem, especially at large
scale.
Towards understanding TPL dependencies in the C/C++ecosystem, we collect
existing TPL databases, package management tools, and dependency detection
tools, summarize the dependency patterns of C/C++ projects, and construct a
comprehensive and precise C/C++ dependency detector. Using our detector, we
extract dependencies from a large-scale database containing 24K C/C++
repositories from GitHub. Based on the extracted dependencies, we provide the
results and findings of an empirical study, which aims at understanding the
characteristics of the TPL dependencies. We further discuss the implications to
manage dependency for C/C++ and the future research directions for software
engineering researchers and developers in fields of library development,
software composition analysis, and C/C++package manager.Comment: ASE 202
Developing IncidentUI -- A Ride Comfort and Disengagement Evaluation Application for Autonomous Vehicles
This report details the design, development, and implementation of
IncidentUI, an Android tablet application designed to measure user-experienced
ride comfort and record disengagement data for autonomous vehicles (AV) during
test drives. The goal of our project was to develop an Android application to
run on a peripheral tablet and communicate with the Drive Pegasus AGX, the AI
Computing Platform for Nvidia's AV Level 2 Autonomy Solution Architecture [1],
to detect AV disengagements and report ride comfort. We designed and developed
an Android XML-based intuitive user interface for IncidentUI. The development
of IncidentUI required a redesign of the system architecture by redeveloping
the system communications protocol in Java and implementing the Protocol
Buffers (Protobufs) in Java using the existing system Protobuf definitions. The
final iteration of IncidentUI yielded the desired functionality while testing
on an AV test drive. We also received positive feedback from Nvidia's AV
Platform Team during our final IncidentUI demonstration.Comment: Previously embargoed by Nvidia. Nvidia owns the right
Value Flow Graph Analysis with SATIrE
Partial redundancy elimination is a common program optimization that
attempts to improve execution time by removing superfluous computations from
a program. There are two well-known classes of such techniques: syntactic
and semantic methods. While semantic optimization is more powerful,
traditional algorithms based on SSA from are complicated, heuristic in
nature, and unable to perform certain useful optimizations. The value flow
graph is a syntactic program representation modeling semantic equivalences;
it allows the combination of simple syntactic partial redundancy elimination
with a powerful semantic analysis. This yields an optimization that is
computationally optimal and simpler than traditional semantic methods.
This talk discusses partial redundancy elimination using the value flow
graph. A source-to-source optimizer for C++ was implemented using the
SATIrE program analysis and transformation system. Two tools integrated in
SATIrE were used in the implementation: ROSE is a framework for arbitrary
analyses and source-to-source transformations of C++ programs, PAG is a tool
for generating data flow analyzers from functional specifications
Control-Flow Integrity for Real-Time Embedded Systems
Attacks on real-time embedded systems can endanger lives and critical infrastructure. Despite this, techniques for securing embedded systems software have not been widely studied. Many existing security techniques for general-purpose computers rely on assumptions that do not hold in the embedded case. This paper focuses on one such technique, control-flow integrity (CFI), that has been vetted as an effective countermeasure against control-flow hijacking attacks on general-purpose computing systems. Without the process isolation and fine-grained memory protections provided by a general-purpose computer with a rich operating system, CFI cannot provide any security guarantees. This work proposes RECFISH, a system for providing CFI guarantees on ARM Cortex-R devices running minimal real-time operating systems. We provide techniques for protecting runtime structures, isolating processes, and instrumenting compiled ARM binaries with CFI protection. We empirically evaluate RECFISH and its performance implications for real-time systems. Our results suggest RECFISH can be directly applied to binaries without compromising real-time performance; in a test of over six million realistic task systems running FreeRTOS, 85% were still schedulable after adding RECFISH
SensEH: From Simulation to Deployment of Energy Harvesting Wireless Sensor Networks
Energy autonomy and system lifetime are critical concerns in wireless sensor networks (WSNs), for which energy harvesting (EH) is emerging as a promising solution. Nevertheless,the tools supporting the design of EH-WSN are limited to a few simulators that require developers to re-implement the application with programming languages different from WSN ones. Further, simulators notoriously provide only a rough approximation of the reality of low-power wireless communication.
In this paper we present SENSEH, a software framework that allows developers to move back and forth between the power and speed of a simulated approach and the reality and accuracy of in-field experiments. SENSEH relies on COOJA for emulating the actual, deployment-ready code, and provides two modes of operation that allow the reuse of exactly the same code in realworld WSN deployments. We describe the toolchain and software architecture of SENSEH, and demonstrate its practical use and benefits in the context of a case study where we investigate how the lifetime of a WSN used for adaptive lighting in road tunnels can be extended using harvesters based on photovoltaic panels
- …