Fast and space-efficient defense against jump-oriented programming attacks

Although technical issues remain to be resolved, EUV lithography is now a serious contender for critical layer patterning of upcoming 2X node memory and 14nm Logic technologies in manufacturing. If improvements continue in defectivity, throughput and resolution, then EUV lithography appears that it will be the most extendable and the cost-effective manufacturing lithography solution for sub-78nm pitch complex patterns. EUV lithography will be able to provide a significant relaxation in lithographic K1 factor (and a corresponding simplification of process complexity) vs. existing 193nm lithography. The increased K1 factor will result in some complexity reduction for mask synthesis flow elements (including illumination source shape optimization, design pre-processing, RET, OPC and OPC verification). However, EUV does add well known additional complexities and issues to mask synthesis flows such as across-lens shadowing variation, across reticle flare variation, new proximity effects to be modeled, significant increase in pre-OPC and fracture file size, etc. In this paper, we investigate the expected EUV-specific issues and new requirements for a production tapeout mask synthesis flow. The production EUV issues and new requirements are in the categories of additional physical effects to be corrected for; additional automation or flow steps needed; and increase in file size at different parts in the flow. For example, OASIS file sizes after OPC of 250GigaBytes (GB) and files sizes after mask data prep of greater than three TeraBytes (TB) are expected to be common. These huge file sizes will place significant stress on post-processing methods, OPC verification, mask data fracture, file read-in/read-out, data transfer between sites (e.g., to the maskshop), etc. With current methods and procedures, it is clear that the hours/days needed to complete EUV mask synthesis mask data flows would significantly increase if steps are not taken to make efficiency improvements. Therefore, we also analyze different options for reducing or alleviating the EUV specific issues mentioned above and the expected cost/benefit tradeoffs associated with these options. The options include understanding the accuracy vs. run-time benefit of different rule-based and model-based approaches for several correction issues; predicting the implications and improvements expected with different flow automation options; and estimating possible productivity improvements with different flow parallelization choices and upcoming multi-core processors. Optimal combinations of options and accuracy/effort/runtime results can be seen to enable EUV lithography tapeout flows to achieve equal or better total time when compared to current 193nm optical lithography tapeout flow times.

Many applications written in garbage collected languages have large dynamic working sets and poor data locality. We present a new system for continuously improving program data locality at run time with low overhead. Our system proactively reorganizes the heap by leveraging the garbage collector and uses profile information collected through a low-overhead mechanism to guide the reorganization at run time. The key contributions include making a case that garbage collection should be viewed as a proactive technique for improving data locality by triggering garbage collection for locality optimization independently of normal garbage collection for space, combining page and cache locality optimization in the same system, and demonstrating that sampling provides sufficiently detailed data access information to guide both page and cache locality optimization with low runtime overhead. We present experimental results obtained by modifying a commercial, state-of-the-art garbage collector to support our claims. Independently triggering garbage collection for locality optimization significantly improved optimizations benefits. Combining page and cache locality optimizations in the same system provided larger average execution time improvements (17%) than either alone (page 8%, cache 7%). Finally, using sampling limited profiling overhead to less than 3%, on average.

Control-flow integrity (CFI) plays a very important role in defending against code reuse attacks by protecting the control flows of programs from being hijacked. However, previous CFI methods suffer from performance overheads, cost, or security issues. In this paper, we propose a new CFI based on a lightweight encryption architecture with advanced encryption standard (LEA-AES) to address the challenges above. The LEA exploits AES to encrypt and decrypt return addresses and instructions at indirect jump destinations, which protects function calls and indirect jumps from being reused by return-oriented programming (ROP) and jump-oriented programming (JOP) attacks. For ROP, the encryption and decryption of return addresses are performed when the call and ret instructions are executing; for JOP, the encryption of instructions are performed when programs are loading into memory and the decryption of instructions are performed right before they are executing. The LEA-AES does not need to revise instruction sets of CPU and its security is also guaranteed by the encryption mechanism in addition to its high performance. Experimental results showed that the run-time and loading time overheads of LEA-AES are both less than 4% and the memory overhead is 0.62%.

Software-defined networking offers a flexible and programmatically efficient network design. Security in today’s ad hoc mobile wireless network is paramount and incredibly challenging. Software-defined network is used to automatically and dynamically manage and control large network devices, network services, traffic paths, network topology, and packet management (quality of service). Recently different attackers are attacking our data when forwarding from one device to another. Therefore, software-defined networking and a Hybrid Rivest, Shamir, and Adelman (RSA)–Advanced Encryption Standard (AES) cryptography algorithm are needed to establish the concept of software-defined networking in mobile ad hoc networks to improve security and routing efficiency. The proposed Hybrid Cryptography Algorithm (HCA)-Based SDN mainly creates strong detection, prevention, and authentication mechanisms for MANET. The proposed secure data channel throughput increased by 0.4%, and the suggested system latency was 3.6% lower than the Normal MANET. It is already proved that the Hybrid cryptography algorithm also generates a key for security faster than RSA (Rivest, Shamir, and Adelman). The performance of the RSA–AES (hybrid) approach for encrypting and decrypting broad data significantly beats the RSA-Blowfish algorithm. In decrypting files, the hybrid approach (RSA–AES) outperforms the RSA-Blowfish method 11.2 times more efficiently when the file size is 32 kB; however, efficiency is increased by 77.1 times when the file size exceeds 4,096 kB. The experimental result shows that as the file size increases the hybrid RSA–AES solution outperforms RSA when the file is only 145 bytes; however, when the file is 6,460 bytes in size, the efficiency is multiplied by 61.3. As file size increases, RSA is less efficient than the hybrid encryption method. This is more preferred to be implemented for different parts of wireless networks like MANET.

Chapter 8 - The Menu, MenuBar, and Tree Components

Steganography is a technique of securing secret messages in other messages that are not known. Simulation of the steganography method using the Least Significant Bit technique is used to change the last bit in one byte of data by using a text message as the container medium. This study aims to implement the security of text messages in images using the Least Significant Bit technique which is supported by the steganography method. Simulation techniques are used to conduct studies using Cryptool2 which can describe the concept of cryptography. The results obtained from this study regarding the security of text message insertion into an image in *.jpg and *.png format with 5 sampling trials are (1) the encrypted image cannot be distinguished directly through human eyes, (2) there is an increase in file size the image after being encrypted with an average for five trials is 0.31%, this increase depends on the length of the text message and a key to be inserted, the longer the insertion, the larger the resulting file size, (3) The higher the resolution of the image where the description encryption is inserted, the longer the process required, (4) The simulation time of steganographic decryption is faster than steganographic encryption. The decryption simulation process is the same as 50% of the encryption process.

To reason about programs, dynamic optimizers and analysis tools use sampling to collect a dynamic call graph (DCG). However, sampling has not achieved high accuracy with low runtime overhead. As object-oriented programmers compose increasingly complex programs, inaccurate call graphs will inhibit analysis and optimizations. This paper demonstrates how to use static and dynamic control flow graph (CFG) constraints to improve the accuracy of the DCG. We introduce the frequency dominator (FDOM), a novel CFG relation that extends the dominator relation to expose static relative execution frequencies of basic blocks. We combine conservation of flow and dynamic CFG basic block profiles to further improve the accuracy of the DCG. Together these approaches add minimal overhead (1%) and achieve 85% accuracy compared to a perfect call graph for SPEC JVM98 and DaCapo benchmarks. Compared to sampling alone, accuracy improves by 12 to 36%. These results demonstrate that static and dynamic control-flow information offer accurate information for efficiently improving the DCG.KeywordsBasic BlockCorrection AlgorithmControl Flow GraphCall GraphCall SiteThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Code-reuse attack is a growing threat to computing systems as it can circumvent existing security defenses. Fortunately, control flow integrity (CFI) is promising in defending such attack. However, former implementations generally suffer from two major drawbacks: 1) complex pre-processing to obtain control flow graph; 2) high overhead. In this paper, we propose a cross-layer approach that employs basic block information inside the binary code and read-only data to enforce fine-grained control-flow integrity. Our approach demonstrates high applicability and thorough attack detection coverage without static analysis or recompilation. Meanwhile, it can effectively protect even striped programs, while incurring negligible 0.13% performance overhead.

Writes via unchecked pointer dereferences rank high among vulnerabilities most often exploited by malicious code. The most common attacks use an unchecked string copy to cause a buffer overrun, thereby overwriting the return address in the function's activation record. Then, when the function "returns", control is actually transferred to the attacker's code. Other attacks may overwrite function pointers, setjmp buffers, system-call arguments, or simply corrupt data to cause a denial of service.A number of techniques have been proposed to address such attacks. Some are limited to protecting the return address only; others are more general, but have undesirable properties such as having a high runtime overhead, requiring manual changes to the source code, or forcing programmers to give up control of data representations and memory management.This paper describes the design and implementation of a security tool for C programs that addresses all these issues: it has a low runtime overhead, does not require source code modification by the programmer, does not report false positives, and provides protection against a wide range of attacks via bad pointer dereferences, including but not limited to buffer overruns and attempts to access previously freed memory. The tool uses static analysis to identify potentially dangerous pointer dereferences, and memory locations that are legitimate targets of these pointers. Dynamic checks are then inserted; if at runtime the target of an unsafe dereference is not in the legitimate set, a potential security violation is reported, and the program is halted.

This study aims to enhance the RC5 algorithm to improve encryption and decryption speeds in devices with limited power and memory resources. These resource-constrained applications, which range in size from wearables and smart cards to microscopic sensors, frequently function in settings where traditional cryptographic techniques because of their high computational overhead and memory requirements are impracticable. The Enhanced RC5 (ERC5) algorithm integrates the PKCS#7 padding method to effectively adapt to various data sizes. Empirical investigation reveals significant improvements in encryption speed with ERC5, ranging from 50.90% to 64.18% for audio files and 46.97% to 56.84% for image files, depending on file size. A substantial improvement of 59.90% is observed for data files sized at 1500000kb. Partitioning larger files notably reduces encryption time, while smaller files experience marginal benefits. Certain file types benefit from both strategies. Evaluation metrics include encryption execution time and throughput, consistently demonstrating ERC5's superiority over the original RC5. Moreover, ERC5 exhibits reduced power consumption and heightened throughput, highlighting its multifaceted benefits in resource-constrained environments. ERC5 is developed and tested on various file types and sizes to evaluate encryption speed, power consumption, and throughput. ERC5 significantly improves encryption speed across different file types and sizes, with notable gains for audio, image, and large data files. While partitioning smaller files only slightly improves encryption time, larger files partitioning yields faster results. Future research could explore ERC5 optimizations for different computing environments, its integration into real-time encryption scenarios, and its impact on other cryptographic operations and security protocols.

Advancements of CMOS technology lead to reduction of the transistor size and operating voltage levels that cause transistors to become more sensitive to cosmic rays. Therefore CMOS devices like memory (i.e., RAMs) are more likely to be hit by transient faults. Up to 77% of the transient faults cause Control Flow Errors (CFEs). One type of CFEs is wrong-successor CFE which is caused by faults in data variables resident in RAM. Previous control flow checking techniques neither detect nor correct this type of errors. A technique with the ability of masking wrong-successor CFEs is proposed in this paper. Since occurrence of these errors is induced by faults in data variables which affect the program execution flow (control variables), in the proposed technique, the control variables are being distinguished from other variables. This step is being followed by a traditional fault masking technique that is applied on the control variables. To evaluate the proposed technique, it was applied on five various benchmarks of the MiBench package. The experimental results demonstrated that the proposed technique is able to mask all 50,000 injected faults in control variables; while it had almost 21% performance overhead with 6% memory overhead. It is reasonable and feasible to apply this technique on the former control flow checking techniques due to its perfect wrong-successor CFE correction coverage and low overheads.

Even parts of a program that are sequential or just inherently difficult to parallelize can be optimized for ILP. For instance, eliminating loop overheads and potential pipeline stalls from control flow can alleviate performance bottle-necks. Unfortunately, static compilation is limited in the extent to which it can identify opportunities to apply such optimizations. Generating code dynamically at run time, however, create much more efficient applications by usin information not available at compile time. We demonstrate our approach on a sparse-matrix PET scan code by aggressive unrolling loops and specializing code via dynamic code generation. We leverage task-level parallelism by having an auxiliary processor core concurrently generate code and feed it to the core executing the application. Our approach to fast code generation leverages patching and concatenating prepared code skeletons.

The in-memory key-value store provides a persistence method to ensure data durability. The currently provided methods are either to create a snapshot file of a current dataset or to write the log of the performed command in the log file. However, the snapshot method has a risk of data loss and append only logging method cause a system failure due to an increase in log file size. To prevent excessive AOF file size growth, the in-memory key-value store provides a reconstruction method, but also a performance degradation and excessive memory usage occur. In this paper, we propose a new persistence method for effective memory usage and throughput. The new approach is called Logging Exploiting SnapShot (LESS). LESS is a method that combines the advantages of a snapshot using low memory usage and the benefits of an append only logging method that guarantees data persistence. We implemented LESS on Redis and conducted experiments. A benchmark test demonstrated that the proposed approach reduces the maximum memory usage by 57% and it is 2.7 times faster than the original approach. Overall, the experimental results showed that LESS is effective for Redis.

This study explores the relationship between Earnings Management and Impression Management in the context of some European listed companies. The analysis focuses on the readability of annual reports, measured by the file size. Earnings management is assessed using the modified Jones model. The sample consists of 2,953 listed companies from 17 industries of 24 European countries between 2012 and 2018 resulting in 13,020 firm-year observations. It has been found that one standard deviation increase in financial reports file size increases discretionary accruals in around 4%. These results are robust across different sample specifications in terms of firms’ size, industry and country. The findings show that increased intensity in the use of discretionary accruals is obfuscated by the disclosure of less readable annual reports, implying that Earnings Management and Impression Management are used complementarily. The conclusions have impact both for investment management and for policy, preventing inefficient allocation of capital budgeting and providing additional information that improves regulation on financial reporting transparency. AcknowledgmentThe authors are grateful to financial support from FCT – Fundação para a Ciência e Tecnologia (Portugal), national funding through research grant (UID/SOC/04521/2020).

Today, security is a requirement for smartphone operating systems that are used to store and handle sensitive information. However, smartphone users usually download third-party applications that can leak personal data without user authorization. For this reason, the dynamic taint analysis mechanism is used to control the manipulation of private data by third-party apps [9]. But this technique does not detect control flows. In particular, untrusted applications can circumvent Android system and get privacy sensitive information through control flows. In this paper, we propose a hybrid approach that combines static and dynamic analysis to propagate taint along control dependencies in Android system. To evaluate the effectiveness of our approach, we analyse 27 free Android applications. We found that 14 of these applications use control flows to transfer sensitive data. We successfully detect that 8 of them leaked private information. Our approach creates 19 % performance overhead that is due to the propagation of taint in the control flow. By using our approach, it becomes possible to detect leakage of personal data through control flows.