A model‐based framework for inter‐app Vulnerability analysis of Android applications

Android enables an intra-and inter-app communication that can be misused thus resulting in various ICC (inter-component communication) vulnerabilities such as null pointer, Intent spoofing, Intent hijack, and data leak. This paper proposes a fuzzing framework called ICCFuzzer to uncover various types of ICC vulnerabilities, by combining path-insensitive ICFG analysis and generative data fuzzing. Firstly, the static analysis extracts Intent structure, string constants, and events relevant to ICC vulnerabilities for the fuzzer to penetrate deeper into app logic. Secondly, the fuzzer constructs and injects proper Intents and events according to the information collected by static analysis, and then records ICC vulnerabilities triggered. Experiments on DroidBench and real-world apps show the effectiveness of this method.

Android apps cooperate through message passing via intents. However, when apps have disparate sets of privileges inter-app communication (IAC) can accidentally or maliciously be misused, e.g., to leak sensitive information contrary to users’ expectations. Recent research has considered static program analysis to detect dangerous data leaks due to inter-component communication (ICC), but suffers from shortcomings for IAC with respect to precision, soundness, and scalability.

The Android operating system dominates the smartphone market. Thus, to service the market, the number of Android applications has risen dramatically. These applications are processing a great amount of sensitive data, which could result in various concerns including data leakage and privacy violations. For example, applications may misuse the sensitive data stored on Android devices and violate the privacy of the user. Therefore, it is essential to maintain user privacy and protect sensitive data from leakage. Static data flow analysis approaches are used for analyzing Android applications to uncover security and privacy issues. However, these approaches frequently generate false alarms, given the different challenges created by Android applications, such as inter-component communication (ICC), reflection, and implicit flow. This work presents the DroidRista approach for conducting static data flow analysis on Android applications to detect sensitive data leakage. DroidRista analyzes ICC, reflection, and implicit flow in Android applications. To evaluate the performance of DroidRista, it was tested on three data sets. The results demonstrate improved performance in terms of detecting data leakage compared to existing static data flow analysis approaches.

For GUI programs, like Android apps, the program functionalities are encapsulated in a set of basic components, each of which represents an independent function module. When interacting with an app, users are actually operating a set of components. The transitions among components, which are supported by the Android Inter-Component Communication (ICC) mechanism, can reflect the skeleton of an app. To effectively resolve the source and destination of an ICC message, both the correct entry-point identification and the precise data value tracking of ICC fields are required. However, with the wide usage of Android fragment components, the entry-point analysis usually terminates at an inner fragment but not its host component. Also, the simply tracked ICC field values may become inaccurate when data is transferred among multiple methods. In this paper, we design a practical ICC resolution tool ICCBot, which resolves the component transitions that are connected by fragments to help the entry-point identification. Besides, it performs context-sensitive inter-procedural analysis to precisely obtain the ICC-carried data values. Compared with the state-of-the-art tools, ICCBot achieves both a higher success rate and accuracy. ICCBot is open-sourced at https://github.com/hanada31/ICCBot. A video demonstration of it is at https://www.youtube.com/watch?v=7zcoMBtGiLY.

Problem statement: This study presents an in-depth analysis of the performance of Software Communications Architecture (SCA) component-based waveform applications in terms of inter-component communications. The main limitation with SCA, in the context of embedded systems, is the additional cost introduced by the use of Object Request Broker (ORB) middleware. The ORB middleware handles the interaction between components and objects in SCA distributed environment. This interaction should be highly efficient, due to the real time nature of SCA systems and transparent to the application programmer. Approach: We can achieve high efficiency in SCA systems by enhancing the Inter-Process Communications (IPC) mechanisms in Operating systems (OS) micro kernels, while we achieve transparency through Interface Definition Language (IDL). Different encoding mechanisms like “External Data Representation (XDR), Network Data Representation (NDR) and Common Data Representation (CDR) facilitate inter-component communication transparently and efficiently”. Marshalling procedures format data from the local machine representation to common network representations. A most common encoding mechanism for Common Object Request Broker Architecture (CORBA) systems is CDR representation. Measurements have been performed with ORBExpress DSP as a CORBA distribution and Open Source SCA Implementation Embedded (OSSIE) for SCA implementation. In order to perform these measurements we proposed two metrics for profiling the ORB that are invocation and marshalling. In addition, we propose three elements of data types to evaluate the performance of ORB middleware that are, Basic, Array and Sequence data types. Results: The CORBA bus is really the part, which brings an overhead to the SCA radio systems. This overhead is due to method invocations that have been carried out by ORB middleware. Conclusion: Performance benchmarks of ORBExpress DSP middleware show that, although using CORBA for inter-component communications introduces delays and overheads, the overall effect can be reduced by sending packets of data instead of basic data type elements.

Based on the statistics, advertisements (ads) generate more than 80% of companies' revenues. However, the complexity of the ads ecosystem blurs the boundaries of responsibility between companies. It can not analyze privacy and security issues in such an ecosystem. For example, collecting user information without user consent for data analysis and displaying ads will cause privacy leakage. But we can not explain which types of the company need to take measures to protect privacy. In our paper, to clarify the responsibility of companies in the advertisement ecosystem, we divide them into six types of entities according to their needs and functions. Then, we design a lightweight simulation platform to illustrate the advertisement ecosystem and support security and privacy analysis. Finally, we take personal ads recommendations based on federated learning as an example to verify the feasibility for privacy and security analysis in this platform.

Inter-component communication (ICC) among Android apps is shown to be the source of many security vulnerabilities. Prior research has developed compositional analyses to detect the existence of ICC vulnerabilities in a set of installed apps. However, they all lack the ability to efficiently respond to incremental system changes—such as adding/removing apps. Every time the system changes, the entire analysis has to be repeated, making them too expensive for practical use, given the frequency with which apps are updated, installed, and removed on a typical Android device. This paper presents a novel technique, dubbed FLAIR, for efficient, yet formally precise, security analysis of Android apps in response to incremental system changes. Leveraging the fact that the changes are likely to impact only a small fraction of the prior analysis results, FLAIR recomputes the analysis only where required, thereby greatly improving analysis performance without sacrificing the soundness and completeness thereof. Our experimental results using numerous collections of real-world apps corroborate that FLAIR can provide an order of magnitude speedup over prior techniques.

Binary lifters convert executables into an intermediate representation (IR) of a compiler framework. The recovered IR code is generally deemed “analysis friendly,” bridging low-level code analysis with well-established compiler infrastructures. With years of development, binary lifters are becoming increasingly popular for use in various security, systems, and software (re)-engineering applications. Recent studies have also reported highly promising results that suggest binary lifters can generate LLVM IR code with correct functionality, even for complex cases.This paper conducts an in-depth study of binary lifters from an orthogonal and highly demanding perspective. We demystify the “expressiveness” of binary lifters, and reveal how well the lifted LLVM IR code can support critical downstream applications in security analysis scenarios. To do so, we generate two pieces of LLVM IR code by compiling C/C++ programs or by lifting the corresponding executables. We then feed these two pieces of LLVM IR code to three keystone downstream applications (pointer analysis, discriminability analysis, and decompilation) and determine whether inconsistent analysis results are generated. We study four popular static and dynamic LLVM IR lifters that were developed by the industry or academia from a total of 252,063 executables generated by various compilers and optimizations and on different architectures. Our findings show that modern binary lifters afford IR code that is highly suitable for discriminability analysis and decompilation, and suggest that such binary lifters can be applied in common similarity- or code comprehension-based security analysis (e.g., binary diffing). However, the lifted IR code appears unsuited to rigorous static analysis (e.g., pointer analysis). To obtain a more comprehensive view of the utility of binary lifters, we also compare the performance of lifter-enabled approaches with that of binary-only tools in three security tasks, i.e., sanitization, binary diffing, and C decompilation. We summarize our findings and make suggestions for the correct use and further enhancement of binary lifters. We also explored practical ways to enhance the accuracy of pointer analysis using lifted IR code, by using and augmenting Debin, a tool for predicting debug information.

In this paper, we describe a visual environment, SoftBean Composer, for component assembly. Key ideas of this visual environment include explicit representation of component boundary elements based on a component model and explicit separation of core component functionality from inter-component communication mechanisms and strategies. Component boundary elements are abstracted into Ports dealing with communications between component internal parts and the outside world. Inter-component communications are abstracted into Links dealing with communications in local or distributed fashions. Component boundary information is discovered using introspection at component assembly time and assistance is provided to users in component assembly.

Wireless Sensor Networks (WSN) offer a significant potential for ubiquitous monitoring and control in future internet-connected pervasive systems architectures. This can be achieved through seamless integration along existing networking devices and systems, while taking account the data-driven nature and security constraints imposed upon such low power, efficient embedded networked platforms. We argue that only through a combined security and communication approach can the relevant goals be achieved, by considering security issues as an integral part of high level layers of the protocol stack. This paper presents an analysis of security and communication constraints of IPv6-based wireless sensor networks at the network and transport layer. Leveraging the Contiki operating system for resource constrained devices along with the ContikiSec security layer and RPL, IPv6 Protocol for Low Power and Lossy Networks, helpful insight is achieved for evaluation and deployment. The results of the analysis are discussed and functions of its modules are explained. This opens up the path towards robust implementation in real world applications following comparative experimental work on simulated and emulated mote platforms.

Emerging device-to-device (D2D) communication in 5th generation (5G) mobile communication networks and internet of things (loTs) provides many benefits in improving network capabilities such as energy consumption, communication delay and spectrum efficiency. D2D group communication has the potential for improving group-based services including group games and group discussions. Providing security in D2D group communication is the main challenge to make their wide usage possible. Nevertheless, the issue of security and privacy of D2D group communication has been less addressed in recent research work. In this paper, we propose an authentication and key agreement tree group-based (AKATGB) protocol to realize a secure and anonymous D2D group communication. In our protocol, a group of D2D users are first organized in a tree structure, authenticating each other without disclosing their identities and without any privacy violation. Then, D2D users negotiate to set a common group key for establishing a secure communication among themselves. Security analysis and performance evaluation of the proposed protocol show that it is effective and secure.

Human error has been statistically proven to be the primary cause of road accidents. This undoubtedly is a contributory cause of the rising popularity of autonomous vehicles as they are presumably able to maneuver appropriately/optimally on the roads while diminishing the likelihood of human error and its repercussion. However, autonomous vehicles are not ready for widespread adoption because their safety and security issues are yet to be thoroughly investigated/addressed. Little literature could be found on collaborative analysis of safety and security of autonomous vehicles. This paper proposes a framework for analyzing both safety and security issues, which includes an integrated safety and security method (S&S) with international vehicle safety and security standards ISO 26262 and SAE J3061. The applicability of the proposed framework is demonstrated using an example of typical autonomous vehicle model. Using this framework, one can clearly understand the vehicle functions, structure, the associated failures and attacks, and also see the vulnerabilities that are not yet addressed by countermeasures, which helps to improve the in-vehicle safety and security from researching and engineering perspectives.

With the advent of fog computing, various e-governance services get influenced as fog provides new service delivery models and new ways to interact with the citizens. Uttarakhand, as a state of 86% hilly region and 65% of forest area, got geographical conditions that are not so favored for cloud-enabled technologies, because cloud needs regular and high bandwidth Internet connectivity. Fog computing can be a key player, in terms of providing e-Governance service. E-Health is the major service provided under the e-governance platform. With the application of Internet-enabled and IoT-based e-Healthcare systems in the state like Uttarakhand, there can be a drastic improvement in health services. E-Health services require real-time processing, low latency, high consistency, and high data rate, and these all parameters are fulfilled by fog computing. There are many kinds of research that describe how fog can be used in e-Healthcare systems. In this research paper, we discuss fog computing in the context of Uttarakhand. Our main concerns are security issues and challenges faced by fog computing while using the E-Healthcare system in hilly areas of Uttarakhand. In studying those challenges and security issues, the technologies related to fog computing are also discussed.

Android applications are exposed to reverse engineering attacks. In particular, the applications written in Java are more prone to reverse engineering in comparison to the applications written in native-code languages such as C or C++ on the Android platform. This is because Java applications are distributed as byte codes, while applications written in native-code languages are distributed as low-level binary codes. In this paper, we propose a new technique to protect Android applications against reverse engineering. Three key characteristics of the proposed approach are as follows. First, we write the main parts of the application in native-code using Android NDK. This not only makes reverse engineering more difficult, but it is also more effective in terms of code reuse. Second, we introduce obfuscation, which hides the intent of the native codes and obscures theirs structure, at the intermediate representation (IR) level. Finally, we integrate an integrity verification scheme which detects whether the critical module of the application has been modified prior to execution of the application. Based on the results of experimentation on five known Android applications, we show that the proposed techniques can be applied without a significant effect on performance.

Virtual private LAN service (VPLS) is a Layer 2 virtual private network technique that has gained enormous popularity in industrial networks. However, the deployment of legacy VPLS architectures in large-scale networks is challenging due to unresolved security and scalability issues. In this paper, we propose a novel hierarchical VPLS architecture based on host identity protocol. The proposed architecture tackles both security and scalability issues in legacy VPLS architectures. It secures the VPLS network by delivering vital security features such as authentication, confidentiality, integrity, availability, and secured control protocol. The security analysis and simulation results confirm that the proposed architecture is protected from various IP-based attacks as well. Theoretical analysis and simulation results have also verified that the proposed architecture provides scalability in control, forwarding, and security planes. Finally, the data plane performance of the proposed architecture is measured in a real-world testbed implementation.