Abstract:High-dimensional approximate nearest neighbor search (ANNS) is one of the fundamental and core components of vector databases. With the advancement of artificial intelligence, vector databases have played an increasingly critical role and have gained widespread attention. ANNS methods are essential for optimizing the performance of vector databases. Over decades of development, ANNS has achieved a series of milestones. Rapid advancements in this field in recent years have led to a surge of novel methods and findings, necessitating systematic organization. In this study, the basic concepts of ANNS are first introduced. Next, building upon existing survey frameworks, current approaches are further categorized into five groups based on vector data organization methods: graph-based, hierarchical, quantization-based, hashing-based, and hybrid data organization. Representative works and the latest research advances in the field are systematically discussed. Then, from the perspective of vector search optimization methods, recent advancements are reviewed and categorized into eight types. These categories include hardware acceleration oriented, learning enhanced, distance comparison operation oriented, disk-memory hybrid oriented, data access optimization oriented, distributed oriented, hybrid query oriented, and theoretical analysis. Finally, based on current research achievements and trends, potential future research directions are outlined.

Abstract:In high-dimensional data processing, the K-nearest neighbor (KNN) graph is a critical data structure widely used in tasks such as clustering, graph neural networks, and recommendation systems. However, with the increasing use of pretrained embedding models in unstructured data modeling and retrieval, embedding model fine-tuning has become a key step in enhancing the semantic representation capability of embeddings. Such fine-tuning often leads to systematic changes in the vector representations of all data points, which invalidates the original neighborhood relationships in the KNN graph. Existing research primarily focuses on building KNN graphs for static data, lacking efficient solutions for adapting to updated embeddings after fine-tuning. To address this gap, this study proposes FastAdjust, an efficient KNN graph update method tailored for embedding model fine-tuning scenarios. Leveraging the observation that fine-tuning usually causes only minor changes to individual embeddings, incremental adjustments to the original KNN graph are performed by FastAdjust through a local update strategy, significantly improving update efficiency while maintaining graph quality. Specifically, FastAdjust first employs a clustering structure based on product quantization to efficiently and accurately locate a subset of candidate neighbors for each data point, thus narrowing the search space. Secondly, based on data density and the magnitude of embedding variation, FastAdjust leverages their correlation with changes in the KNNs to adaptively allocate update resources according to the degree of neighbor relationship changes, thus improving overall update efficiency. Experimental results on real-world datasets demonstrate that FastAdjust efficiently and accurately adapts KNN graphs to embedding updates with significantly reduced computational cost, showing strong practical value and scalability.

Abstract:Graph-based indexes for high-dimensional vectors have become the mainstream solution for large-scale approximate nearest neighbor search (ANNS) due to their high efficiency. The search process over graph-based indexes typically consists of two stages: the first stage rapidly navigates from an entry point to a region near the query vector, while the second stage searches for the k nearest vectors within the localized region. However, due to the need to store a large number of adjacency relationships, graph-based indexes often incur high memory overhead. In practice, this leads to storing the index in external memory, where vector and graph data are loaded on demand during ANNS. This results in frequent I/O operations, which have become the primary bottleneck, accounting for over 90% of total query time. Existing systems exploit the fact that entry points and their nearby neighbors are frequently accessed, and adopt static caching strategies that preload these points and their multi-hop neighbors into memory to reduce I/O during the first stage. However, this study finds that the second stage contributes the majority of I/O cost, as it involves accessing a large number of graph vertices related to the query vector to ensure high recall. Since the accessed vertices in this stage vary dynamically with each query, static caching strategies fail to capture them effectively and thus become nearly ineffective. To address this issue, a hybrid caching strategy termed GoVector is proposed, which integrates both static and dynamic components. Specifically, (1) the static cache preloads the entry point and its frequently accessed neighbors, while (2) the dynamic cache adaptively stores high-locality vertices encountered during the second stage of the search. Furthermore, to align with the similarity-driven search behavior of the second stage, a vector-similarity-aware disk layout strategy is proposed, which reorganizes the storage order of vertices to cluster similar vectors into the same or adjacent disk pages, thus enhancing data locality. This dual-optimization approach significantly improves cache hit rates and effectively reduces overall I/O overhead. Experimental results on multiple public datasets demonstrate that, under 90% recall, GoVector achieves an average of 46% fewer I/O operations, 1.73× higher query throughput, and 42% lower latency compared to state-of-the-art disk-based graph indexing ANNS systems.

Abstract:Clustering serves as one of the critical technologies for large-scale, high-dimensional vector data analysis. Recently, a density-based clustering algorithm DBSCAN (density-based spatial clustering of applications with noise) has been widely adopted in data analysis due to their advantages of not requiring pre-specified cluster numbers, discovering complex cluster structures, and identifying noise points. However, existing density-based clustering algorithms suffer from high computational costs when processing high-dimensional vectors. Meanwhile, these methods also face challenges like the “curse of dimensionality”, restricting their practical applications. With the rapid growth of high-dimensional vector data in the era of information technology, CPU-based clustering approaches encounter increasing challenges in time efficiency and scalability. To address these issues, this study proposes a GPU-accelerated clustering algorithm for high-dimensional vector data, introducing the K-nearest neighbor (KNN) graph index to accelerate DBSCAN. First, a GPU-accelerated parallel KNN graph construction algorithm is developed, significantly reducing the index construction overhead. Furthermore, to enhance the pipeline of DBSCAN and achieve highly concurrent vector clustering, a K-means tree partitioning algorithm with inter-layer parallelism and a parallel clustering algorithm based on breadth-first search and a core KNN graph are designed. Finally, extensive experiments are conducted on real-world datasets, and the proposed method is compared against existing approaches. Experimental results show that the proposed algorithm improves the efficiency of large-scale vector clustering by 5.7–2822.5 times while maintaining clustering accuracy.

Abstract:In the era of large models, the widespread use of vector databases has led to a rapid expansion in the scale of vector indexes. How to efficiently support large-scale vector updates in disk-based vector indexes while maintaining high query performance has become an important research problem in recent years. FreshDiskANN, as a leading algorithm, suffers from query throughput bottlenecks and high tail latency under mixed query-update workloads. Inspired by the successful application of log-structured merge (LSM) in secondary indexes, LSMDiskANN is proposed as an update-friendly disk-resident vector index framework based on the LSM paradigm. Building on the FreshDiskANN architecture, a three-level structure including a disk intermediate level is designed and implemented. In addition, a dynamic parameter selection mechanism for disk component search and a re-layout strategy for the deletion phase of compaction are introduced to further reduce query latency and I/O overhead during merges. Experimental results show that on multiple large-scale, high-dimensional datasets, query throughput is improved by up to 35.5%, update throughput by up to 14.24%, and tail query latency is reduced by up to 73.45%. The proposed framework and strategies effectively enhance overall performance and stability under mixed workloads.

Abstract:Approximate nearest neighbor search (ANNS) is a foundational technology supporting applications such as vector databases, recommendation systems, and large language models (LLMs). Among these, the hierarchical navigable small world (HNSW) graph indexing technique constructs a hierarchical structure to quickly locate results within the target region, thus achieving high retrieval recall at low computational cost. However, existing HNSW algorithms are primarily designed for static data retrieval scenarios and fail to account for the impact of data updates on retrieval performance. Through research on real-world datasets, it is found that data in vector databases is typically updated in batches, and their similar characteristics weaken the effectiveness of heuristic pruning in HNSW algorithms and lead to sparsification issues in the connections among similar vectors, collectively causing a significant decline in retrieval recall. To address these issues, this study proposes an adaptive fine-grained pruning strategy based on local adjustments to the graph structure and constructs a comprehensive optimization scheme that integrates an identification and repair mechanism. First, in the identification phase, the regional neighbor distance is calculated to quantify local topological density, thereby precisely locating the dense regions requiring intervention. Second, in the repair phase, for hub nodes in dense regions, a dual pruning neighbor selection strategy is adopted: native and modified heuristic pruning rules are applied synergistically, and the results of both rules are merged to enhance neighbor connection diversity while maintaining retrieval accuracy, effectively alleviating over-pruning and connection sparsification issues. Experimental results on multiple public datasets show that the proposed method demonstrates good adaptability in scenarios with frequent data updates, achieving a 1%–4% improvement in recall while maintaining stable query latency and throughput.

Abstract:With the widespread application of multi-source, heterogeneous, and multi-modal data in scenarios such as large models and data lakes, there has been a significant growth in vector-based data retrieval and storage management. By mapping heterogeneous data into high-dimensional vector representations and leveraging vector indices, vector databases facilitate the unified management of diverse data types and enable high-quality similarity search, establishing them as a crucial foundation for applications like generative retrieval and AI-native databases. However, existing vector databases face significant bottlenecks in terms of storage and indexing efficiency, index construction complexity, and retrieval accuracy. Specifically, massive high-dimensional vectors lead to increased storage overhead and maintenance costs for indices. Furthermore, vector index structures are often bloated, resulting in substantial memory consumption. Moreover, the degradation of retrieval accuracy caused by distortion from compression techniques remains an unresolved challenge. This study proposes a framework based on weight residual vector quantization (WRVQ). This method achieves efficient compression and storage with very low distortion by decoupling the quantization direction from the residual magnitude. It stores the residual direction as a unit vector and appends a weight marker. For indexing, a three-layer inverted index structure tailored to the characteristics of WRVQ is designed, comprising an exact match layer, a fuzzy match layer, and a search layer. This structure organically integrates asymmetric distance computation (ADC) with nearest neighbor search techniques to realize approximate nearest neighbor (ANN) search that balances both high accuracy and high efficiency. Experimental results on large-scale datasets demonstrate that, compared to traditional low-dimensional embedding models and existing quantization methods, WRVQ achieves significant improvements across key metrics, including quantization loss, storage compression ratio, and retrieval recall. Furthermore, it exhibits considerable advantages in both index construction and query performance.

Abstract:Text2SQL has evolved into a significant tool for data analysis and database management by reducing the technical barriers for non-expert users to interact with relational databases. The introduction of large language model (LLM), represented by GPT, further improves the performance of Text2SQL systems. However, existing Text2SQL techniques are difficult to apply directly to the spatial database domain because spatial data involves complex geometric relationships, diverse query types, and the demand for high-precision semantic understanding. To address these issues and lower the threshold for interaction between non-experts and spatial databases, a natural language query (NLQ) transformation method for spatial databases is proposed. The method consists of two core phases: (1) natural language understanding; (2) executable language generation. In phase (1), an entity information extraction algorithm is employed to extract key query entities, and a spatial data query corpus is constructed based on large language models to determine the query type. In phase (2), a structured language model (SLM) is selected according to the query type, and the entities are then mapped into the structured language model to generate the final executable language for spatial databases. Experimental results on multiple real-world datasets demonstrate that the proposed method enables efficient transformation from natural language queries to executable languages of spatial databases.

Abstract:Multi-objective optimization problem (MaOP) is widely encountered in scientific research and engineering applications. Due to the exponential increase in the number of non-dominated solutions caused by objective conflicts, traditional multi-objective evolutionary algorithms face challenges such as increased computational complexity and degraded solution quality when solving MaOPs. To address these issues, this study proposes an improved two-archive high-dimensional multi-objective evolutionary algorithm based on information sharing, Two-Arch/IS, for the efficient solution of MaOP. The proposed algorithm leverages the inherent advantages of the two-archive framework, including low computational complexity and independent optimization of convergence and diversity. Distinct from traditional algorithms, archive maintenance in Two-Arch/IS is achieved through a subpopulation reflection and update strategy based on space partitioning, which enhances population diversity. Furthermore, an archive truncation strategy based on angle selection and shift-based density estimation is adopted to eliminate redundant solutions from the archive, thus maintaining selection pressure during the evolutionary process. Finally, a boundary-solution-driven information compensation mechanism is introduced to facilitate information exchange between the convergence and diversity archives, enabling effective complementarity among individuals in the population. In this study, Two-Arch/IS is benchmarked against several representative algorithms on 69 widely used test instances and real-world problems with 2 to 20 objectives. Experimental results demonstrate that the proposed algorithm effectively addresses the conflict between convergence and diversity in high-dimensional many-objective optimization and exhibits superior performance across multiple evaluation metrics.

Abstract:In recent years, pre-trained models that take code as input have achieved significant performance gains in various critical code-based tasks. However, these models remain susceptible to adversarial attacks implemented through semantic-preserving code transformations, which can severely compromise model robustness and pose serious security issues. Although adversarial training, leveraging adversarial examples as augmented data, has been employed to enhance robustness, its effectiveness and efficiency often fall short when facing unseen attacks with varying granularities and strategies. To address these limitations, a novel adversarial defense technique based on code normalization, named CoDefense, is proposed. This method integrates a multi-granularity code normalization approach as a preprocessing module, which normalizes both the original training data during training and the inputcode during inference. By doing so, the proposed method mitigates the impact of potential adversarial examples and effectively defends against attacks of diverse types and granularities. To evaluate the effectiveness and efficiency of CoDefense, a comprehensive experimental study is constructed, encompassing 27 scenarios across three representative adversarial attack methods, three widely-used pre-trained code models, and three code-based classification and generation tasks. Experimental results demonstrate that CoDefense significantly outperforms state-of-the-art adversarial training methods in both robustness and efficiency. Specifically, it achieves an average defense success rate of 95.33% against adversarial attacks and improves time efficiency by an average of 85.86%.

Abstract:The Go programming language (Golang), as an emerging programming language, achieves efficient automatic memory management through compile-time escape analysis and runtime garbage collection. It also provides built-in data types such as interface, slice, and map, which significantly enhance development efficiency and program performance. However, these features also introduce memory performance and safety challenges that differ from those in traditional languages like C/C++. This study uses static code analysis to empirically study memory performance and safety problems in Go programs. The framework PatStat, designed based on CodeQL, is employed to analyze open-source repositories on GitHub. This framework uses the declarative language QL to examine code patterns related to memory performance in open-source repositories, facilitating both manual summarization and automatic detection of memory safety problems. The research covers memory access characteristics and patterns of memory safety problems. An analysis of 996 Go open-source projects, updated within the past year, reveals that field accesses and dereference operations account for significant portions of memory access in Go programs, at 25.44% and 17.63%, respectively. This indicates the importance of field sensitivity and points-to analysis in Go program analysis and optimization. Moreover, implicit memory allocation resulting from Go’s unique interface type conversions is another key area for optimization. Through manual analysis of 130 Issues involving memory leaks, invalid memory addresses or null pointer dereferences, and dangling pointers, the study identifies 10 Issue patterns, noting that dangling pointer problems are rare in Go. These Issues typically require around 30 days for resolution but often demand only a few dozen lines of code changes. The findings offer insights for optimizing Go programs and mitigating memory safety concerns. Furthermore, a linter is developed to detect the Issue pattern, which involves the assignment of a slice expression that may lead to memory leaks. This tool identifies 6 Issues in real-world projects, one of which receives positive feedback.

Abstract:Database systems serve as the foundational infrastructure for data storage and processing, with their performance playing a critical role in the efficiency of modern society. With the advancement of memory technologies and the widespread adoption of SSDs (solid state drives), the performance bottleneck in disk-based databases has shifted towards optimizing CPU utilization and memory management. However, current database query execution often relies on interpreted methods, leading to numerous virtual function calls, context switches, and cache misses. This limits the ability of modern CPUs to fully utilize their pipelines and cache mechanisms, resulting in inefficient query execution, particularly in scenarios involving large datasets and complex queries. To address these issues, this study proposes several just-in-time (JIT) compilation optimization strategies for traditional interpreted database execution, validated through experiments on MySQL. First, an approach is presented wherein the LLVM (low level virtual machine) compiler is used to convert SQL predicates into machine code at runtime, replacing the interpretation method to reduce the overhead of virtual function calls and context switching. Next, a hybrid compilation and interpretation approach is introduced to extend the applicability of JIT execution. Finally, a query pushdown strategy is designed for pluggable database system architectures, enabling the transfer of JIT-compiled machine code to the storage engine layer to reduce unnecessary data transfer and computational overhead. Experimental results show that enabling JIT compilation significantly enhances MySQL’s query performance. Notably, for complex queries and large datasets, the JIT-compiled system reduces CPU load and memory usage, leading to substantial improvements in system response speed and throughput. In TPC-H-like tests, compared to the native MySQL version, the optimized system shows performance gains of up to 148%.

Abstract:Software intellectual property (IP) is a reusable software knowledge entity with intellectual property, serving as the basis for intelligent software synthesis. In view of the key features of the embedded systems, this study proposes a general model of software IP for the systems, including the knowledge model, formal model, and implementation, and discusses the consistency between the three. Compared with the current mainstream models, the proposed method fully considers the key features of embedded systems, assumptions made by the system about the environment and platform, representation and utilization of the immediate knowledge of software, correctness of model assembly, and relations between model and implementation. Therefore, this method has remarkable advantages. The proposed general model reveals the essential nature of software construction to some extent. Software is not merely a set of codes, but should be a combination of knowledge, specification, and codes. Additionally, for simplifying the utilization, this study shows software IP in different views according to the utilization purposes (focuses). Finally, this study puts forward an approach of extracting software IP from existing embedded software assets and validates the effectiveness of this extraction method through practical cases.

Abstract:The intelligent autonomy and stable on-orbit operation capabilities of spacecraft are crucial to enhancing the success rate of space missions. Software self-adaptive evolution technology is an essential approach to achieving this goal and has become a research hotspot in the field of software engineering. This study first provides an overview of the research status and existing issues in the self-adaptive evolution of spacecraft control software. Then, in response to the openness of the spacecraft on-orbit operating environment, the limited computing resources of the host, and the high real-time response requirements of flight missions, an on-orbit self-adaptive and trustworthy evolution framework for spacecraft control software, termed MAPE-KV (monitor-analyze-plan-execute over knowledge and verification), is proposed. In addition, under the guidance of this framework, the application logic, self-adaptive control logic, trustworthiness assurance logic, and supporting knowledge base for spacecraft software are designed. Finally, the effectiveness of the proposed framework is validated through two typical scenarios: unexpected failures and service changes. Simulation results demonstrate that the proposed method can effectively address the challenges posed by unexpected events during the operation of spaceborne software.

Abstract:The rapid development of intelligent driving technology has made human-machine collaborative co-driving a key paradigm for balancing automation capabilities with human driving rights and responsibilities. Driving authority takeover technology, which ensures the safe, smooth, and efficient transfer of control between humans and machines, has become one of the core challenges and technical bottlenecks in this field. By systematically reviewing relevant research on theoretical frameworks, technical challenges, and interaction mechanisms, the limitations of driving authority takeover technology in real-time decision-making and personalized adaptation are highlighted. This enables a thorough analysis of current progress and clarifies future research directions. First, from a multidisciplinary perspective, this study elaborates on the theoretical foundation of driving authority takeover, proposes a classification framework based on scenario characteristics, and analyzes the roles of factors such as environmental complexity and driver state. In addition, the wake-up strategies and control algorithms are systematically compared, highlighting the shortcomings of current technology in adapting to complex scenarios and personalized designs. Second, the influence of human-machine trust on driving authority takeover is innovatively explored. From the two dimensions of trust dynamic modeling and multimodal interaction, a trust calibration-based optimization method for takeover strategies is proposed. Finally, the trend toward integrating large models with cross-modal cognitive technology is envisioned, providing research directions for seamless human-machine collaborative driving in the future.

Abstract:Retrieval-augmented generation (RAG) significantly enhances the performance of downstream software engineering tasks such as code generation, code completion, and program repair by combining information retrieval with language generation models. As RAG develops rapidly in software engineering, it is difficult for researchers to comprehensively grasp its current achievements, challenges, and future potential opportunities. This study presents the first systematic review of the application of RAG in software engineering from 2021 to 2024, summarizing and deeply analyzing 108 relevant high-quality studies from the perspectives of RAG’s core architecture and its applications in software engineering. Firstly, the key architectural components of RAG in the field of software engineering are discussed, and a detailed summary of common types of retrievers and generators is provided, with the integration methods of both summarized. Secondly, the application of RAG in various downstream software engineering tasks is mainly analyzed, such as code generation, code completion, and program repair. Additionally, a systematic review is provided for RAG’s practical methods and technical trends under different task scenarios. Finally, the challenges that the current RAG application faces are discussed, covering three stages of knowledge base construction, retrieval, and generation, with the future research directions and potential development paths pointed out. Generally, this study provides a comprehensive review of RAG research for the software engineering community, aiming to help researchers have a systematic understanding of the current achievements and an insight into key problems, and promote the further development of this field.

Abstract:In the field of time series data analysis, cross-domain data distribution shifts significantly weaken model generalization performance. To address this, an end-to-end time series domain adaptation framework, called TPN, is developed. This framework creatively integrates a temporal pattern activation module (TPAM) with a Transformer encoder. TPAM captures spatial and temporal dependencies of sequence features through dual-layer spatio-temporal convolution operations, combines Sigmoid and Tanh activation functions for the non-linear fusion of extracted features, and restores the original channel dimensions via linear projection, thus enhancing the model’s ability to extract temporal features. TPN also introduces an enhanced adversarial paradigm (EAP), which strengthens generator-discriminator-based collaborative adversarial learning through domain classification loss and operation order prediction loss. This effectively reduces data distribution discrepancies between source and target domains, improving the model’s domain adaptability. Empirical results on three public human activity recognition datasets (Opportunity, WISDM, and HHAR) demonstrate that TPN improves accuracy and F1 by up to 6% compared to existing methods, with fewer parameters and shorter runtime. In-depth ablation and visualization experiments further validate the effectiveness of TPAM and EAP, showing TPN’s strong performance in feature extraction and domain alignment.

Abstract:Federated learning (FL) is a distributed model training framework that allows multiple clients to collaboratively train a global model in an edge computing (EC) environment while preserving the privacy of clients’ local data. However, federated learning in edge networks often faces challenges such as resource constraints and data heterogeneity, also known as non-independent and identically distributed (non-IID) data, which significantly degrade model training performance. To address these challenges, this study proposes an efficient federated learning framework—FedAlt, aiming to enhance model training performance (e.g., test accuracy) in edge networks while reducing resource consumption. FedAlt builds upon the classic federated learning algorithm FedAvg by incorporating block-wise multi-output and self-knowledge distillation techniques. These enhancements enable clients to more effectively absorb information from the model’s representational layers during local training, mitigating the negative impact of non-IID data on model training. Specifically, the model is divided into multiple consecutive blocks, and at the start of each global training round, the server sends only the initial blocks of the global model to the clients, reducing communication overhead. Clients then combine the global model with their local models and use self-knowledge distillation techniques to absorb information from the model’s representational layers, addressing data heterogeneity challenges. Moreover, considering that communication overhead increases with the number of transmitted model blocks, adaptive algorithms are designed for both the server and client sides: the model block distribution algorithm and the block-wise multi-output regularization algorithm. These algorithms dynamically adjust the number of distributed model blocks based on the client’s data distribution, computational capacity, and communication capabilities. Extensive experimental results show that, compared to existing methods, FedAlt improves average test accuracy by approximately 2.64% under limited communication bandwidth conditions.

Abstract:Drug recommendation aims to formulate the most suitable medication treatment plan based on patients’ clinical consultation information. However, existing drug recommendation methods usually lack effective exploration of longitudinal and structured features in patient consultation sequences. To address this issue, this study proposes an end-to-end drug recommendation method based on structured sequence modelling with multi-source information. Specifically, this method first constructs an efficient compression encoder to depict fine-grained EHR-encoded information. Then, a recurrent attention network is designed, which captures the global dependencies in the consultation sequence through a masked attention mechanism on the temporal dimension, allowing the network to dynamically adjust the weight of historical visits during learning. This enhances the accuracy of capturing longitudinal dependencies in consultation sequences. Moreover, by introducing a graph contrastive learning strategy and a knowledge-enhanced retrieval module, the model’s capability for structured representation is improved, facilitating the understanding of the structural relationships among drugs and reducing the risk of DDI. Experimental results on real-world datasets (i.e., MIMIC-III and MIMIC-IV) demonstrate that the proposed method outperforms comparative methods across multiple performance metrics.

Abstract:Attribute-based searchable encryption (ABSE) enables secure and fine-grained sharing of encrypted data in multi-user environments. However, it typically encounters challenges such as high computational overhead for encryption and decryption, limited query efficiency, and the inability to update indexes dynamically. To address these limitations, this study proposes an efficient searchable scheme based on ABSE that supports dynamic index updates. The reuse of identical access policies minimizes redundant computation during encryption. Most decryption operations are securely outsourced to the cloud, thus reducing the local device’s computational load. An inverted index structure supporting multi-keyword Boolean retrieval is constructed by integrating hash tables with skip lists. BLS short signature technology is employed to verify the permissions for index updates, ensuring data owners can manage the retrieval of encrypted data. Formal security analysis confirms that the proposed scheme effectively defends against collusion attacks, chosen plaintext attacks, forged update tokens, and decryption key forgery. Experimental results demonstrate high efficiency in both retrieval and index update operations, along with a significant reduction in encryption overhead when access policy reuse occurs.

Abstract:The widespread deployment of smart contracts on Ethereum has injected vitality into the blockchain ecosystem, while the irreversibility and anonymity of smart contracts have posed great challenges to supervision. Criminals take the opportunity to deploy Ponzi schemes on Ethereum, causing serious security risks and economic losses. Therefore, it is essential to detect Ponzi scheme smart contracts quickly and efficiently. The main challenges of the current Ponzi scheme detection method include the neglect of the behavior characteristics of smart contract opcodes, incomplete feature extraction, unstable performance, and low accuracy of the detection method when the method is subjected to anti-interference. To overcome these shortcomings, this study proposes an Ethereum Ponzi scheme detection method that combines TextCNN and adversarial training. This method extracts the behavioral characteristics of smart contracts by the static analysis of smart contracts, and combines the Word2Vec model to retain the semantic information of smart contracts to ensure the integrity of the opcode features. Meanwhile, the improved dynamic step projection gradient descent algorithm is adopted to train the TextCNN model to enhance the robustness of the detection model and improve the detection accuracy. Experiments carried out on the XBlock dataset show that the proposed method achieves a Recall of 98.36% and F1-score of 98.31% while ensuring precision and robustness. The method focuses on smart contract opcodes without relying on transaction features, and can quickly and efficiently detect Ponzi scheme smart contracts at the time of smart contract deployment.

Abstract:With the widespread application of container technology, the security and isolation of containers have attracted significant attention. Currently, a large number of container escape vulnerabilities persist in various container tools, with the security vulnerabilities due to inadequate container file system isolation becoming a type of security threat that occupies a significant proportion. This kind of vulnerability allows attackers to manipulate file path resolution processes within containers or steal file descriptors from the host machine during interactions between containers and the host machine. Although multiple fix methods have been practiced by various container tool communities, these vulnerabilities cannot be thoroughly eliminated, and even new similar vulnerabilities are introduced due to the incomplete fix. It is necessary to improve container file system isolation mechanisms at the kernel level to thoroughly eliminate these vulnerabilities. Therefore, this study proposes a fine-grained isolation enhancement mechanism for container file systems, which extends container file system isolation from merely isolating file system mount points to the inode level. This mechanism involves marking the inode of files within containers to distinguish the file objects of containers and the host machine, followed by designing and implementing access control between containers and the host machine based on these markings to enhance file system isolation between containers and the host machine. Experimental results demonstrate that this mechanism can effectively prevent all file system-related container escape vulnerabilities, and the introduced average overhead is less than 2%, significantly lower than the overhead introduced by vulnerability patches provided by container tools.