Gang Shi

Gang Shi

Auto-generated profile, based on publicly available information

Gang Shi

Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China

Research Focus & Metrics

Academic Career Length

7Years (2020-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
6 March 2024 in IEEE Transactions on Information Forensics and Security
Verified
Journal Article
Closed access
TWTongshuai Wu
Tongshuai Wu
LCLiwei Chen
Liwei Chen
GDGewangzi Du
Gewangzi Du
DMDan Meng
Dan Meng
GSGang Shi
Gang Shi
Detecting vulnerabilities in source code using deep learning models is emerging as a valuable research area. The key issue in using deep learning to detect vulnerabilities is the accurate representation. Current approaches for detecting vulnerabilities in C/C++ programs use functions or lines of code as the unit and only consider the basic syntactic structure of vulnerabilities. Unfortunately, functions and lines of code still have vulnerability-unrelated information, which is redundant for vulnerability features and is not conducive to deep learning models to learn accurate vulnerability patterns. This paper deeply analyzes the essential features of vulnerabilities and attacks. Then, we propose a novel variable-based deep learning vulnerability detection method for C/C++ that is more granular than existing function- or line of code-based vulnerability detection methods. Based on the triggering mechanism of vulnerabilities and typical memory attacks, we propose the concepts of key variables and insecure operations; these are used to propose new rules for determining the center point of code slices with more accurate vulnerability features. We propose the first ultra-fine-grained variable-based code slicing (UltraVCS) method by the new center point, which focuses on the vulnerability-related variable. This method removes as much vulnerability-unrelated information as possible to achieve more accurate vulnerability feature extraction. Experiments show that our approach can generate more code slices, achieve more precise vulnerability representation, and perform better vulnerability detection in open-source projects compared to state-of-the-art methods. Furthermore, we have discovered four zero-day vulnerabilities in real-world application scenarios in open-source projects.

24 July 2020 in IEEE Transactions on Computers
Verified
Journal Article
Closed access
DMDan Meng
Dan Meng
RHRui Hou
Rui Hou
GSGang Shi
Gang Shi
BTBibo Tu
Bibo Tu
AYAimin Yu
Aimin Yu
YYYun Yang
Yun Yang
Continually disclosed vulnerabilities reveal that traditional computer architecture lacks the consideration of security. This paper proposes a security-first architecture, with the Active Security Processor (ASP) integrated to the conventional computer architectures. To reduce the attack surface of ASP and improve the security of the whole system, the ASP is physically isolated from the CPUs with an asymmetric address space. Both the ASP and CPU can run their own operating system and applications independently on their own memory space. Furthermore, the ASP has the highest privilege (Super Root) of the whole system with two features. Firstly, the ASP can access all CPU resources and collect multi-dimensional information efficiently to monitor and analyze malicious behaviors. However, the CPU cannot access the ASP resources in anyway. Secondly, instead of being scheduled by CPUs, the ASP can actively manage the security mechanisms employed in either CPUs or the ASP. Based on the security-first architecture, we introduce several typical security tasks running on ASP. With considerations of complexity and performance, we discuss four typical system-level implementation for integrating the ASP to the security-first architecture. We implemented an off-chip ASP as our first-generation security computer system design solution to evaluate the security and performance in real hardware.

17 November 2022
Verified
Book Chapter
Closed access
PDF file
CZChenguang Zhu
Chenguang Zhu
GDGewangzi Du
Gewangzi Du
TWTongshuai Wu
Tongshuai Wu
NCNingning Cui
Ningning Cui
LCLiwei Chen
Liwei Chen
GSGang Shi
Gang Shi

11 September 2024
Verified
Conference Paper
Open access
ZZZhijie Zhang
Zhijie Zhang
LCLiwei Chen
Liwei Chen
HWHaolai Wei
Haolai Wei
GSGang Shi
Gang Shi
DMDan Meng
Dan Meng
Directed grey-box fuzzing (DGF) is an advanced technique in security testing, specifically designed to guide fuzzing tools toward predefined target sites within a software program. To improve its scalability on multiple targets, recent DGFs prioritize seeds that close to targets based on a more precise distance metric, and dynamically discard well-explored targets, thus steering toward all targets simultaneously. However, not all targets hold equal importance, particularly when facing large-scale target sets. Therefore, current works that blindly tracking all targets diverts computing resources from critical targets, thereby reducing the overall efficiency of triggering targets. In this paper, we present Prospector, a novel DGF approach that can handle large-scale target sets scenarios. Prospector employs an iterative process to focus on a select group of ”focused targets”. To dynamically maintain these targets, Prospector present a more fine-grained strategy that considers the vulnerable patterns and test adequacy of targets. Subsequently, Prospector further sharpens its fuzzing approach toward ”focused targets” by refining strategies in explore-exploit scheduling, seed selection, and byte scheduling. We evaluate Prospector on 24 programs by setting all sanitizer labels as targets. The experimental results show that Prospector exposed bugs faster than AFL++, WindRanger, ParmeSan, and FishFuzz by 125, 141, 84, and 100 cases, respectively. Among 38 unique bugs in the program group with the largest target sets, Prospector reproduces 18 (47.37%) existing bugs faster than other fuzzers. Prospector also discovered 6 new bugs in 4 real-world programs with 5 CVE IDs assigned.

2 October 2020 in IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
Verified
Journal Article
Closed access
JLJinfeng Li
Jinfeng Li
QXQizhen Xu
Qizhen Xu
YLYongyue Li
Yongyue Li
LCLiwei Chen
Liwei Chen
GSGang Shi
Gang Shi
DMDan Meng
Dan Meng
Return-oriented programming(ROP) is a prevalent code reuse technique that hijacks a program’s control flow by modifying its return addresses on the stack. Researchers have proposed some return address verification methods by using the message authentication code(MAC). But these approaches suffer from high performance overhead. In this paper, we first propose Dislocated Stack, a new kind of stack layout in which a previous return address would be pushed onto the current stack frame and the current return address would be stored into a hardware buffer on function calls. Based on Dislocated Stack, we design two new verification approaches, Lazy Verification and Batch Verification. Lazy Verification does not verify a return address popped from stack until it is going to be used for return. Batch Verification verifies a couple of return addresses at one time. We implemented these two designs on RISC-V architecture and quantitatively analysed their effect on QEMU. Our experiments show that Lazy Verification reduces over 99% verifications on function returns and incurs only 1.23% performance overhead; while in Batch Verification, the overhead is merely 0.78%. The result demonstrates that these two approaches are highly efficient for return address verification.

11 September 2024
Verified
Conference Paper
Open access
HWHaolai Wei
Haolai Wei
LCLiwei Chen
Liwei Chen
ZZZhijie Zhang
Zhijie Zhang
GSGang Shi
Gang Shi
DMDan Meng
Dan Meng
A proof of concept (PoC) is essential for pinpointing a bug within software. However, relying on it alone for the timely and complete repair of bugs is insufficient due to underestimating the bug impacts. The bug impact reflects that a bug may be triggered at multiple positions following from the root cause, resulting in different bug types (e.g., use-after-free, heap-buffer-overflow). Current techniques discover bug impacts using fuzzing with a specific coverage-guided strategy: assigning more energy to seeds that cover the buggy code regions. This method can utilize a single PoC to generate multiple PoCs that contain different bug impacts in a short time. Unfortunately, we observe existing techniques are still unreliable, primarily due to their failure in balancing the time between in-depth and breadth exploration: (i) in-depth exploration for bug impacts behind crash regions and (ii) breadth exploration for bug impacts alongside unreached regions. Current techniques only focus on one exploration or conduct two explorations in separate stages leading to low accuracy and efficiency. Considering the aforementioned problem, we propose Sleuth, an approach for automatically investigating bug impacts following a known single PoC to enhance bug fixing. We design Sleuth on two novel concepts: (i) a dual-mode exploration mechanism built on a fuzzer designed for efficient in-depth and breadth exploration. (ii) a dynamic switchable strategy connecting with the dual-mode exploration that facilitates the reliability of bug impact investigation. We evaluate Sleuth using 50 known CVEs, and the result of experiment shows that Sleuth can efficiently discover new bug impacts in 86% CVEs and find 1.5x more bug impacts than state-of-art tools. Furthermore, Sleuth successfully identifies 13 incomplete fixes using the generated new PoCs.