Home   >   CSC-OpenAccess Library   >    Manuscript Information
A Study on the Use of Unsafe Mode in Rust Programming Language
Abbas Alshuraymi, Jia Song
Pages - 15 - 29     |    Revised - 30-06-2024     |    Published - 31-07-2024
Volume - 18   Issue - 2    |    Publication Date - July 2024  Table of Contents
MORE INFORMATION
KEYWORDS
Unsafe Rust, Rust Safety, Compiler Check, Rust Programming Language, Unsafe Block.
ABSTRACT
Rust is a modern systems programming language that prioritizes safety and performance. Its key innovation, the ownership and borrowing system, ensures memory safety by preventing common errors such as dangling pointers, data races, and use-after-free bugs. Rust's type system further enhances reliability by catching logic errors at compile time. The Rust compiler enforces memory safety through its ownership and borrowing system, performing a set of strict checks to guarantee the security and safety of the program. However, specific scenarios necessitate the use of Unsafe Rust, which bypasses some of the safety checks. This is particularly relevant for performance optimizations, interfacing with other languages, and implementing complex data structures. In this paper, we have conducted a literature review on the use of Unsafe Rust, exploring why and how programmers are utilizing it. The result indicates that while unsafe Rust is widely used, it is often encapsulated to minimize risks. However, there are still many vulnerabilities in Rust that are caused by using unsafe Rust. So, this paper also suggests some future research directions to help with the safer use of unsafe Rust.
Anderson, B., Bergstrom, L., Goregaokar, M., Matthews, J., McAllister, K., Moffitt, J., & Sapin, S. (2016). Engineering the servo web browser engine using Rust. In Proceedings of the 38th International Conference on Software Engineering Companion (pp. 81-89).
Astrauskas, V., Matheja, C., Poli, F., Müller, P., & Summers, A. J. (2020). How do programmers use unsafe Rust? Proceedings of the ACM on Programming Languages, OOPSLA, 1-27.
Balasubramanian, A., Baranowski, M. S., Burtsev, A., Panda, A., Rakamarić, Z., & Ryzhyk, L. (2017). System programming in Rust: Beyond safety. In Proceedings of the 16th Workshop on Hot Topics in Operating Systems (pp. 156-161).
Blanco-Cuaresma, S., & Bolmont, E. (2016). What can the programming language Rust do for astrophysics? Proceedings of the International Astronomical Union, 12(S325), 341-344.
Data Source13. (2021). Mozilla welcomes the Rust Foundation. Retrieved from https://blog.mozilla.org/en/mozilla/mozilla-welcomes-the-rust-foundation/
Data Source14. (2020). Laying the foundation for Rust's future. Retrieved from https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.html
Data Source15. (2023). Rust: World's fastest-growing programming language. Retrieved from https://www.technologyreview.com/2023/02/14/1067869/rust-worlds-fastest-growing-programming-language/
Data Source16. (2022). Sustainability with Rust. Retrieved from https://aws.amazon.com/blogs/opensource/sustainability-with-rust/
Data Source17. (2023). Understand unsafe Rust. Retrieved from https://rustmagazine.org/issue-3/understand-unsafe-rust/
Evans, A. N., Campbell, B., & Soffa, M. L. (2020). Is Rust used safely by software developers? Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (pp. 246-257).
Ho, S., & Protzenko, J. (2022). Aeneas: Rust verification by functional translation. Proceedings of the ACM on Programming Languages, ICFP, 711-741.
Jespersen, T. B. L., Munksgaard, P., & Larsen, K. F. (2015). Session types for Rust. Proceedings of the 11th ACM SIGPLAN Workshop on Generic Programming (pp. 13-22).
Klabnik, S., & Nichols, C. (2023). The Rust programming language. No Starch Press.
Liu, P., Zhao, G., & Huang, J. (2020). Securing unsafe Rust programs with XRust. Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (pp. 234-245).
Matsakis, N. D., & Klock, F. S. (2014). The Rust language. ACM SIGAda Ada Letters, 34(3), 103-104.
Qin, B., Chen, Y., Yu, Z., Song, L., & Zhang, Y. (2020). Understanding memory and thread safety practices and issues in real-world Rust programs. Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (pp. 763-779).
Sam, G., Cameron, N., & Potanin, A. (2017). Automated refactoring of Rust programs. In Proceedings of the Australasian Computer Science Week Multiconference (pp. 1-9).
Zhang, Y., Kundu, A., Portokalidis, G., & Xu, J. (2023). On the dual nature of necessity in use of Rust unsafe code. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (pp. 2032-2037).
Mr. Abbas Alshuraymi
Computer Science Department, University of Idaho, Moscow, Idaho, 83844 - United States of America
Dr. Jia Song
Computer Science Department, University of Idaho, Moscow, Idaho, 83844 - United States of America


CREATE AUTHOR ACCOUNT
 
LAUNCH YOUR SPECIAL ISSUE
View all special issues >>
 
PUBLICATION VIDEOS