The rapid development of blockchain has spurred the emergence of programmable currency, finance, and society. However, blockchains are subject to severe privacy issues such as deanonymization, transaction linkability, and malicious contracts. Numerous studies in academia and industry have been dedicated to blockchain privacy protection. However, existing surveys tend to be limited in scope, often addressing only intra-chain privacy while neglecting cross-chain concerns and providing incomplete coverage of privacy protection methods. To facilitate interested researchers to comprehend the research field better, this paper presents a comprehensive survey about blockchain privacy protection utilizing a mapping study. We provide a detailed analysis of three types of privacy information, their corresponding privacy threats, four categories of privacy-preserving methods, and validation methods in intra-chain and cross-chain scenarios. We also summarize some typical applications of blockchain where privacy protection is crucial. Moreover, we highlight some deficiencies of the current study, and discuss challenges and future research directions in this field.

RISC-V is one of the latest Instruction Set Architectures (ISAs). It features an extremely modular and extensible design that makes it suitable for a variety of applications, from embedded systems to large computing systems. However, its inherent customizability and open nature also present challenges in terms of compliance and standardization. Traditionally, the validation relies on Spike as the reference simulator to generate compliance test oracles. Nevertheless, research has demonstrated that Spike may contain bugs, which may compromise the reliability of the generated test oracles. Therefore, developing new cross-validation methods has become increasingly important. To address this challenge, we propose TRAGIC, a method for generating compliance test oracles for RISC-V compliance testing based on Large Language Models (LLMs). Different from traditional software testing, ISA compliance testing demands a finer-grained multidimensional test oracle, including not only the program outputs but also the detailed program states, such as key registers and memory addresses. Furthermore, long instruction sequences frequently exceed the context limitations of LLMs, and direct reasoning under such conditions leads to a notable degradation in accuracy. Therefore, TRAGIC employs a hierarchical strategy with two key components. First, the Block Segmentation Component (BSC) decomposes complex test cases into manageable sub-tasks by analyzing the control flow and applying block slicing techniques. The segmentation both preserves the original program semantics and reduces the reasoning context, thereby enhancing inference accuracy. Second, the Graph of Inference Component (GIC) performs structured reasoning on these sub-tasks using explicitly designed Chain-of-Thought prompts. We utilize LLM to dynamically infer the output of each subtask and determine the next block to execute, continuing this iterative process until the entire task is completed. Meanwhile, key register and memory address tables are maintained and integrated into the final test oracle. By combining the BSC and the GIC, TRAGIC effectively mitigates the accuracy loss associated with long context information and enhances the accuracy of test oracle generation. TRAGIC passes evaluation on the official RISC-V compliance test suite with manually-written test cases. Furthermore, we also show that when integrated with automated test generation tools, our method found 6 bugs, 2 of which were previously unknown.

Blockchain technology improves supply chain management by ensuring the immutability of transaction records and facilitating process tracking. However, the transparency of blockchain raises significant privacy concerns, as sensitive information such as buyer and supplier qualifications, product specifications, and transaction amounts is often exposed. Compliance verification, which needs access to specific sensitive data for compliance checks, becomes challenging in blockchain-based privacy-preserving supply chains. This paper introduces ZKVeil, an innovative scheme utilizing zero-knowledge proof technology to maintain the confidentiality of sensitive information while ensuring compliance verification. Additionally, ZKVeil uses decentralized identifiers and verifiable credentials to ensure the authenticity of transaction data. A theoretical security analysis demonstrates the effectiveness of ZKVeil in safeguarding real sensitive data and ensuring compliance with regulations. To evaluate the performance of our scheme, we implement ZKVeil on a private blockchain of 100 nodes. Taking the shipbuilding supply chain transaction as an example, the experimental results demonstrate that ZKVeil incurs low gas consumption, execution time, and memory overhead.

Automated issue fixing is a critical task in software debugging and has recently garnered significant attention from academia and industry. However, existing fixing techniques predominantly focus on the repair phase, often overlooking the importance of improving the preceding bug localization phase. As a foundational step in issue fixing, bug localization plays a pivotal role in determining the overall effectiveness of the entire process.To enhance the precision of issue fixing by accurately identifying bug locations in large-scale projects, this paper presents BugCerberus, the first hierarchical bug localization framework powered by three customized large language models. First, BugCerberus analyzes intermediate representations of bug-related programs at file, function, and statement levels and extracts bug-related contextual information from the representations. Second, BugCerberus designs three customized LLMs at each level using bug reports and contexts to learn the patterns of bugs. Finally, BugCerberus hierarchically searches for bug-related code elements through well-tuned models to localize bugs at three levels. With BugCerberus, we further investigate the impact of bug localization on the issue fixing.We evaluate BugCerberus on the widely-used benchmark SWE-bench-lite. The experimental results demonstrate that BugCerberus outperforms all baselines. Specifically, at the fine-grained statement level, BugCerberus surpasses the state-of-the-art in Top-N (N=1, 3, 5, 10) by 16.5%, 5.4%, 10.2%, and 23.1%, respectively. Moreover, in the issue fixing experiments, BugCerberus improves the fix rate of the existing issue fixing approach Agentless by 17.4% compared to the best baseline, highlighting the significant impact of enhanced bug localization on automated issue fixing.

Hyperledger Fabric has experienced widespread adoption across various domains, concurrently revealing the gradual emergence of privacy-related concerns. Trusted Execution Environment (TEE) is a secure and isolated environment for sensitive computations. The current TEE-based privacy protection method for Fabric has been proposed, but the method suffers from scalability issues, limited compatibility, and security problems. We present TrustFabric, a novel privacy protection method for Fabric leveraging TEE. TrustFabric transfers contracts involving private data to the TEE cluster for execution. Sensitive data are transmitted in encrypted form to ensure data privacy. We implement TrustFabric based on Intel SGX and Fabric. We analyze the effectiveness and anti-attack ability of TrustFabric, and evaluate the performance by experiments. The results indicate that TrustFabric can effectively protect the privacy data involved in the contract and mitigate Denial-ofService attacks, side-channel attacks, and masquerade attacks. Furthermore, TrustFabric has better performance in highly concurrent application scenarios.

Software vulnerabilities seriously jeopardize software security. It would be highly beneficial if developers could receive severity reminders regarding vulnerabilities when developing software systems. Therefore, when handling numerous vulnerabilities, it's crucial to prioritize the most critical ones and assess their severity early for effective resolution. Vulnerability assessment needs to train multiple assessment tasks simultaneously. Previous works suffer from task-disharmonious issues when conducting vulnerability assessments because they fail to balance the magnitude of gradients across multiple tasks and the conflicts in gradient directions. Additionally, they use identical code embedding for all classifiers without extracting task-related features. In this study, we are the first to conduct vulnerability assessment in a task-harmonious way by harmonizing gradient direction and magnitude, and filtering out task-specific features for each classifier. In addition, we use finer-grained contextual information than existing works by program slicing to further boost the model performance. According to experiment results, our model has demonstrated state-of-the-art performance at both the commit and function levels. Specifically, in function-level tasks, our model achieves an average of 0.819 in F1-Score and 0.742 in MCC, outperforming all baseline models. For commitlevel, our model enhances the average performance of the best baseline model by 29.6 % and 64.7 % in F1-Score and MCC, respectively.

Change impact analysis (CIA) is an essential method in software maintenance and evolution. Its accuracy and usability play a crucial role in its application. However, most CIAs are coarse-grained and limited to class and method levels. Despite the fine-grained CIAs’ success in giving the statement-level impact set, they are still limited without the sub-statement level dependency analysis, leading to low precision. Additionally, their unstructured impact sets make it challenging for users to comprehend the impact content. This paper proposes Hierarchical Change Impact Analysis (HCIA), a Hierarchical CIA technique based on the sub-statement level dependence graph. HCIA can perform a forward hierarchy program slicing on the change set from five levels: sub-statement, statement, method, class, and package. Based on the program slices, HCIA calculates the impact factor of the impact sets at the five levels to generate the final impact set. In the experiment, we evaluate the relationship between the impact factor and the actual affected codes and assess the most appropriate size of HCIA impact sets. Furthermore, we evaluate HCIA on 10 open-source projects by comparing our approach with popular CIAs at the five levels. The experimental result shows that HCIA is more accurate than the popular CIAs.

Hyperledger Fabric is an open-source project of Linux Foundation, it is a modular blockchain framework and has become an unofficial standard for enterprise blockchain platforms. In Hyperledger Fabric, smart contract is also known as chaincode, which are usually written using general-purpose languages, including Go, Java or Node.js etc. Although there are some vulnerability detection methods for Java and Node.js, there are very few vulnerability detection methods for Go, especially when it is used as a smart contract programming language in Hyperledger Fabric.In this article, we propose a knowledge graph based defect pattern matching method and develop a tool calledVulFinderto detect vulnerabilities in chaincode, i.e. the smart contracts written using Go language. Knowledge graph is used because it can fully retain the syntax and logic information of smart contracts. The method consists of two key steps: a knowledge graph is constructed fromGo language specificationand chaincode source code, including the definition of ontology layer and the construction of instance layer; the defect patterns are defined and SPARQL query statements are used to match and locate vulnerabilities on the knowledge graph. To evaluate the detection effectiveness and efficiency ofVulFinder, we construct two datasets through manual analysis and vulnerabilities injection due to the lack of public datasets. Experimental results show thatVulFindercan detect 22 kinds of typical vulnerabilities of chaincode effectively, and therecallis as high as 98.87%, while thefalse negative rateis as low as 1.13% .

Software projects are dependent on many third-party libraries, therefore high-risk vulnerabilities can propagate through the dependency chain to downstream projects. Owing to the subjective nature of patch management, software vendors commonly fix vulnerabilities silently. Silent vulnerability fixes cause downstream software to be unaware of urgent security issues in a timely manner, posing a security risk to the software. Presently, most of the existing works for vulnerability fix identification only consider the changed code as a sequential textual sequence, ignoring the structural information of the code.In this paper, we propose GRAPE, a GRAph-based Patch rEpresentation that aims to 1) provide a unified framework for getting vulnerability fix patches representation; and 2) enhance the understanding of the intent and potential impact of patches by extracting structural information of the code. GRAPE employs a novel joint graph structure (MCPG) to represent the syntactic and semantic information of silent fix patches and embeds both nodes and edges. Subsequently, a carefully designed graph convolutional neural network (NE-GCN) is utilized to fully learn structural features by leveraging the attributes of the nodes and edges. Moreover, we construct a dataset containing 2251 silent fixes. For the experimental section, we evaluated patch representation on three tasks, including vulnerability fix identification, vulnerability types classification, and vulnerability severity classification. Experimental results indicate that, in comparison to baseline methods, GRAPE can more effectively reduce false positives and omissions of vulnerability fixes identification and provide accurate vulnerability assessments.

Access control is a vital component of information system security, ensuring that resources are only accessible to authorized users with specific permissions. However, traditional testing methods still face challenges when solving complex access control scenarios, such as third-party login and authorization/authentication. To address these challenges, this paper presents a method for generating access control test cases based on UML activity diagrams. The method focuses on two key scenarios in access control: third-party login and authorization/authentication. For the third-party login scenario, the method incorporates the OAuth 2.0 protocol and conducts a detailed analysis of security issues associated with third-party login processes. For the authorization and authentication scenario, the method models the permission control workflow and performs a comprehensive parse and traversal of the activity diagram structure. Lastly, an empirical study utilizing seven distinct combinations of third-party login and two widely used authentication frameworks provides successful validation of the proposed method. This validation demonstrates the significant impact of the method in uncovering seven specific security issues. Furthermore, the method exhibits efficient problem identification capabilities for potential vulnerabilities within the authorization authentication system. It effectively exposes three types of security flaws that are commonly difficult to detect.

As software development technology becomes increasingly mature, the challenge to software testing efficiency is also increasing. Giving developers faster feedback on their code is essential for developing software. Test Case Prioritization (TCP) is one of the most popular techniques to optimize software testing. However, most TCP techniques rely on coverage information extracted from source code or execution history obtained from past executions and cannot be applied to preliminary software testing. What’s more, offline TCP technology cannot provide timely feedback to testers, affecting testing efficiency. To address the problem, this paper proposes a novel online TCP technique based on Incremental Support Vector Machine, which is called OTCP-ISVM. OTCP-ISVM dynamically reprioritizes the test cases when new failures are detected by using support vectors from previous training round and adapting the segmentation hyperplane. We have evaluated OTCP-ISVM on a large-scale project. The experimental results showed that OTCP-ISVM can achieve dynamic prioritization of the test cases. Compared with SVM algorithm and random algorithm, the fault detection speed of OTCP-ISVM algorithm is improved by 22% and 14% respectively.

In software engineering, code review is an important process when a project is to be upgraded. Reviewers need to assess the validity of a commit, even if they are not familiar with the files in the commit. In a typical commit, one or more mainly modified classes referred to as salient classes, may cause modifications in other classes. Salient Class Identification is such a method that can help reviewers review commits more effectively. In this way, after identifying salient classes, reviewers can allocate most of their efforts to analyzing the salient class, comprehending the commit, and providing reasoned assessments. The existing Salient Class Identification model is based on the static features of the code and does not analyze the internal logical information, such as the relationships between statements. We thoroughly consider both internal and external code information in commits, using a detailed Code-Change Dependency Graph (CCDG) to depict the code structure. CCDG includes various node and edge types, supporting complex syntax scenarios, which can capture fine-grained dependencies. Finally, based on a heterogeneous graph neural network, we extract nuanced features embedding from CCDG, which can further boost the performance of our model. The experiment result shows that our model outperforms existing models in Salient Class Identification, achieving an overall $88 \%$ accuracy.

Commit Classification, an automated process of classifying Diff-Code based on their purpose, plays a crucial role in enhancing comprehension and the quality of software. Some previous studies only used commit messages or code metrics to represent diff-code but lacked code context structure characterization. Alternatively, other studies have used Abstract Syntax Trees (ASTs) tokens to represent diff-code but did not consider contextual information like data dependency and control dependency. In this paper, we propose a new commit classification model called Diff-Code GCN (Graph Convolutional Network). Specifically, we firstly build a more detailed system dependency graph (SDG) of the commit, and secondly use program slicing to search the impact scope of diff-code. Thirdly, we extract the scope as a Change Impact Graph (CIG). We utilize GCN to extract contextual information from CIG and combine it with syntactic changed information of ASTs to represent the commit. Finally, we classify the commit into three maintenance categories (corrective, perfective, and adaptive). We evaluate our model based on commonly used datasets and compare our model with popular commit classification approaches. The experiment result well shows that both in within-project and cross-project prediction tasks, our model performs better than baseline models.

With the emergence of mixed source software, the existing quality models are not able to better assess the community quality and autonomy controllability of mixed source software. To fill this gap, we propose a hierarchical model in this paper for quality assessment of mixed source software. In our model, the new attributes are proposed to meet the quality requirements of mixed source software based on the ISO/IEC 25010 standards, and a set of metrics are designed for the new attributes. The model evaluates the quality of mixed source software through quality attributes that have been quantified by the metrics. Applying our quality model to some mixed source software and comparing the model results with the actual situation, we verify whether our proposed two quality attributes, community intensity and autonomy controllability, can effectively assess the quality of mixed source software. The results of the experiments show that our model is indeed effective in assessing the quality of mixed source software. An important feature of our model is that the model has good flexibility, and the set of quality attributes and metrics can be adjusted freely, which provides a flexible and feasible way for various software quality assessment requirements.

Comments are beneficial for developers to understand and maintain the code in software development life cycle. Well-commented code can generally help developers to resolve issues efficiently. Due to the complexity of code implementation, code comments may be generated to represent different types of information. And it is hard to keep all the code well-commented in real-world projects. In this case, it is meaningful to investigate how the different types of comments impact the resolution of issues. Then we can maintain the code comments purposefully, and we can also provide some suggestions for the comment generation techniques. To analyze the efforts of different comments on issue resolution, we classify code comments into two categories, i.e., functionality-aspect and non-functionality-aspect comments. In this paper, we analyze the effects of 53k pieces of code comments on the issues from 10 open-source projects within a period of 24 months. The results show that the majority of code comments are used to represent the functionality, e.g., the summary and purpose of code. Nevertheless, the other non-functionality-aspect comments have much stronger correlation with the resolution of software issues. For the resolved patches, the non-functionality-aspect comments are more frequently to be updated or added than the functionality-aspect comments. These findings confirm the important role of non-functionality-aspect comments during issue resolution, although their proportion is far less than that of functionality-aspect comments.

The current evaluation of API recommendation systems mainly focuses on correctness, which is calculated through matching results with ground-truth APIs. However, this measurement may be affected if there exist more than one APIs in a result. In practice, some APIs are used to implement basic functionalities (e.g., print and log generation). These APIs can be invoked everywhere, and they may contribute less than functionally related APIs to the given requirements in recommendation. To study the impacts of correct-but-useless APIs, we use utility to measure them. Our study is conducted on more than 5,000 matched results generated by two specification-based API recommendation techniques. The results show that the matched APIs are heavily overlapped, 10% APIs compose more than 80% matched results. The selected 10% APIs are all correct, but few of them are used to implement the required functionality. We further propose a heuristic approach to measure the utility and conduct an online evaluation with 15 developers. Their reports confirm that the matched results with higher utility score usually have more efforts on programming than the lower ones.

Context-aware API recommendation techniques aim to generate a ranked list of candidate APIs on an editing position during development. The basic context used in traditional API recommendation mainly focuses on the APIs from third-party libraries, limit or even ignore the usage of project-specific code. The limited usage of project-specific code may result in the lack of context information, and degrade the effectiveness of API recommendation. To address this problem, we introduce a novel type of context, i.e., hierarchical context, which can leverage the hidden information of project-specific code by analyzing the call graph. In hierarchical context, a project-specific API is presented as a sequence of low-leveled APIs from third-party libraries. We propose an approach, i.e., HiRec, which builds on the basis of hierarchical context. HiRec is evaluated on 108 projects and the results show that HiRec can obtain much more accurate results than all the other selected approaches in terms of top-5 and top-10 accuracy due to the strong ability of context representation. And HiRec performs closely to the outstanding tools in terms of top-1 accuracy. The average time of recommending execution is less than 1 seconds in most cases, which is acceptable for interaction in an IDE. Unlike current approaches, the effectiveness of HiRec is not impacted much by editing positions. And we can obtain more accurate results from HiRec with larger sizes of training data and hierarchical context.

MVC architectural pattern is widely used in software architecture design.It helps decouple the processing and the visualization of system data.Identified MVC architectural pattern helps understand how the software is actually implemented based on MVC architectural pattern, and further improve the consistency between design and source code.This paper proposes an ontology-based MVC architectural pattern identification method.Firstly, we use the combination of design patterns to describe the structure of MVC architectural pattern, so as to construct the MVC ontology of concept layer.Then we construct a program dependency graph by extracting the dependencies between entities in the target system, and build the ontology of instance layer.Finally, the MVC architectural pattern ontology of the specific target system is inferred by ontology reasoner in order to obtained MVC architectural pattern and the pattern elements included in each component.We use open source projects as the benchmark, and the experimental results show that our method effectively identify the MVC architectural pattern and the pattern elements in software system.

Blackboard pattern identification is significant for the programmer to maintain the software system. Whether and how the system uses the blackboard pattern could help the programmers unfamiliar with the target system. This paper proposes a blackboard-instance identification approach based on ontology, which not only judges whether the target system uses the blackboard pattern but also provides the blackboard pattern implementation of the target system. The target system is described by ontology and input into the ABox of the knowledge base, the blackboard pattern is described by ontology and input into the TBox of the knowledge base. And the inference engine will reason out the raw pattern instance. Finally, the final pattern instance will be outputted by iterative refinement. To study the accuracy of our approach, sixty-eight projects have been tested and two of them have been analyzed the components' identification accuracy.

Path profiling records the frequency of each path in an executed routine. To accomplish profiling, probes are instrumented in a program and executed as the program runs. So the number of probes has important influences on the efficiency of a profiling technique. To profile only a subset of paths, existing techniques try to improve the profiling efficiency by reducing probes, optimizing path encoding, and so on. However, they mainly lack accuracy, waste time on running uninterested paths, and only deal with acyclic paths. In this paper, a novel technique called PSP (Profiling Selective Paths) has been introduced to profile selective paths, which can handle selection for both acyclic and cyclic paths, and increase the execution efficiency by early termination on uninterested paths. PSP is implemented in two ways, PSP1 and PSP2. Theoretical comparison and experimental evaluation indicate that PSP1 and PSP2 perform differently but both effectively.

A common problem in object-oriented software integration testing is to determine the order in which classes are integrated and tested. This paper proposes an effective approach to automatically generate a (near) optimal test order from Java source code. This approach includes three aspects: constructing an extended test dependency graph to represent classes and inter-class dependencies, measuring inter-class coupling information to estimate stub complexity, and providing a fast heuristic algorithm to break cycles.