A timely software update is vital to combat the increasing security vulnerabilities. However, some software vendors may secretly patch their vulnerabilities without creating CVE entries or even describing the security issue in their change log. Thus, it is critical to identify these hidden security patches and defeat potential N-day attacks. Researchers have employed various machine learning techniques to identify security patches in open-source software, leveraging the syntax and semantic features of the software changes and commit messages. However, all these solutions cannot be directly applied to the binary code, whose instructions and program flow may dramatically vary due to different compilation configurations. In this paper, we propose BinGo, a new security patch detection system for binary code. The main idea is to present the binary code as code property graphs to enable a comprehensive understanding of program flow and perform a language model over each basic block of binary code to catch the instruction semantics. BinGo consists of four phases, namely, patch data pre-processing, graph extraction, embedding generation, and graph representation learning. Due to the lack of an existing binary security patch dataset, we construct such a dataset by compiling the pre-patch and post-patch source code of the Linux kernel. Our experimental results show BinGo can achieve up to 80.77% accuracy in identifying security patches between two neighboring versions of binary code. Moreover, BinGo can effectively reduce the false positives and false negatives caused by the different compilers and optimization levels.

Location-Based Social Networks (LBSNs) contain rich information that can be used to identify and annotate points of interest (POIs). Discovering these POIs and annotating them with this information is not only helpful for understanding the social behavior of users, but it also provides benefits for location recommendations. However, current methods still have some limitations, such as a long annotating time and a low annotating accuracy. In this study, we develop a hybrid method to annotate POIs with meaningful information from LBSNs. The method integrates three patterns: temporal, spatial, and text patterns. Firstly, we present an approach for preprocessing data based on temporal patterns. Secondly, we describe a way to discover POIs through spatial patterns. Thirdly, we build a keyword dictionary for discovering the categories of POIs to be annotated via mining the text patterns. Finally, we integrate these three patterns to label each POI. Taking New York and London as the target areas, we accomplish automatic POI annotation by using Precision, Recall, and F-values to evaluate the effectiveness. The results show that our F-value is 78%, which is superior to that of the baseline method (Falcone’s method) at 73% and this suggests that our method is effective in extracting POIs and assigning them categories.

Automated program repair (APR) techniques are effective in fixing inevitable defects in software, enhancing development efficiency and software robustness. However, due to the difficulty of generating precise specifications, existing APR methods face two main challenges: generating too many plausible patch candidates and overfitting them to partial test cases. To tackle these challenges, we introduce a new APR method named PathFix, which leverages path-sensitive constraints extracted from correct execution paths to generate patches for repairing buggy code. It is based on one observation: if a buggy program is repairable, at least one expected path is supposed to replace the fault path in the patched program. PathFix operates in four main steps. First, it traces fault paths reaching the fault output in the buggy program. Second, it derives expected paths by analyzing the desired correct output on the control flow graph, where an expected path defines how a feasible patch leads to the correct execution. Third, PathFix generates and evaluates patches by solving state constraints along the expected path. Fourth, we validate the correctness of the generated patch. To further enhance repair performance and mitigate scalability issues introduced by path-sensitive analysis, we integrate a large language model (LLM) into our framework. Experimental results show that PathFix outperforms existing solutions, particularly in handling complex program structures such as loops and recursion.