build: Migrate to Rust 2024 edition

Author: kkrypt0nn

Cargo.lock

@@ -5,7 +5,7 @@ keywords = ["authentication", "bruteforce", "wordlist"]
 version = "0.10.0"
 authors = ["Simone Margaritelli <evilsocket@gmail.com>"]
 license = "GPL-3.0"
-edition = "2021"
+edition = "2024"
 readme = "README.md"
 repository = "https://github.com/evilsocket/legba"
 homepage = "https://github.com/evilsocket/legba"
@@ -31,7 +31,7 @@ serde = { version = "1.0.188", features = ["serde_derive"] }
 serde_json = "1.0.107"
 tokio = { version = "1.36.0", features = ["full"] }
 itertools = "0.11.0"
-rand = "0.8.5"
+rand = "0.9.0"
 env_logger = "0.10.0"
 memory-stats = "1.1.0"
 human_bytes = "0.4.3"

Cargo.toml

@@ -398,6 +398,8 @@ pub(crate) fn encode<'a>(encoding_override: EncodingOverride<'_>, input: &'a str
 
 pub(crate) fn decode_utf8_lossy(input: Cow<'_, [u8]>) -> Cow<'_, str> {
     // Note: This function is duplicated in `percent_encoding/lib.rs`.
+
+    use core::ptr;
     match input {
         Cow::Borrowed(bytes) => String::from_utf8_lossy(bytes),
         Cow::Owned(bytes) => {
@@ -411,7 +413,7 @@ pub(crate) fn decode_utf8_lossy(input: Cow<'_, [u8]>) -> Cow<'_, str> {
 
                     // First we do a debug_assert to confirm our description above.
                     let raw_utf8: *const [u8] = utf8.as_bytes();
-                    debug_assert!(raw_utf8 == &*bytes as *const [u8]);
+                    debug_assert!(ptr::eq(raw_utf8, &*bytes as *const [u8]));
 
                     // Given we know the original input bytes are valid UTF-8,
                     // and we have ownership of those bytes, we re-use them and

crates/rust-url/form_urlencoded/src/lib.rs

@@ -450,6 +450,8 @@ impl<'a> PercentDecode<'a> {
 #[cfg(feature = "alloc")]
 fn decode_utf8_lossy(input: Cow<'_, [u8]>) -> Cow<'_, str> {
     // Note: This function is duplicated in `form_urlencoded/src/query_encoding.rs`.
+
+    use core::ptr;
     match input {
         Cow::Borrowed(bytes) => String::from_utf8_lossy(bytes),
         Cow::Owned(bytes) => {
@@ -463,7 +465,7 @@ fn decode_utf8_lossy(input: Cow<'_, [u8]>) -> Cow<'_, str> {
 
                     // First we do a debug_assert to confirm our description above.
                     let raw_utf8: *const [u8] = utf8.as_bytes();
-                    debug_assert!(raw_utf8 == &*bytes as *const [u8]);
+                    debug_assert!(ptr::eq(raw_utf8, &*bytes as *const [u8]));
 
                     // Given we know the original input bytes are valid UTF-8,
                     // and we have ownership of those bytes, we re-use them and

crates/rust-url/percent_encoding/src/lib.rs

@@ -1,18 +1,18 @@
 use std::collections::HashMap;
 use std::sync::LazyLock;
 
+use actix_web::HttpRequest;
+use actix_web::HttpResponse;
 use actix_web::get;
 use actix_web::post;
 use actix_web::web;
-use actix_web::HttpRequest;
-use actix_web::HttpResponse;
 use clap::CommandFactory;
 use clap::Parser;
 use serde::Serialize;
 
+use crate::Options;
 use crate::api::SharedState;
 use crate::plugins;
-use crate::Options;
 
 // nasty hack to check for plugin specific options
 static OPTIONS_MAP: LazyLock<HashMap<String, serde_json::Value>> = LazyLock::new(|| {

src/api/handlers.rs

@@ -1,16 +1,16 @@
 use std::sync::Arc;
 
 use actix_cors::Cors;
-use actix_web::web;
 use actix_web::App;
 use actix_web::HttpResponse;
 use actix_web::HttpServer;
 use actix_web::Result;
+use actix_web::web;
 use serde::Serialize;
 use tokio::sync::RwLock;
 
-use crate::session::Error;
 use crate::Options;
+use crate::session::Error;
 
 mod handlers;
 mod sessions;
@@ -50,7 +50,9 @@ pub(crate) async fn start(opts: Options) -> Result<(), Error> {
     log::info!("starting api on http://{} ...", &address);
 
     if !address.contains("localhost") && !address.contains("127.0.0.1") {
-        log::warn!("this server does not provide any authentication and you are binding it to an external address, use with caution!");
+        log::warn!(
+            "this server does not provide any authentication and you are binding it to an external address, use with caution!"
+        );
     }
 
     if opts.api_allowed_origin.to_lowercase() == "any" {

src/api/mod.rs

@@ -2,13 +2,13 @@ use std::{
     collections::HashMap,
     os::unix::process::ExitStatusExt,
     process::Stdio,
-    sync::{atomic::AtomicU64, Arc, Mutex},
+    sync::{Arc, Mutex, atomic::AtomicU64},
     time::{SystemTime, UNIX_EPOCH},
 };
 
 use actix_web::Result;
 use clap::Parser;
-use lazy_regex::{lazy_regex, Lazy};
+use lazy_regex::{Lazy, lazy_regex};
 use regex::Regex;
 use serde::Serialize;
 use tokio::{io::AsyncBufReadExt, sync::RwLock};
@@ -18,7 +18,7 @@ static STATS_PARSER: Lazy<Regex> = lazy_regex!(
 );
 static LOOT_PARSER: Lazy<Regex> = lazy_regex!(r"(?m)^.+\[(.+)\]\s\(([^)]+)\)(\s<(.+)>)?\s(.+)");
 
-use crate::{session::Error, utils::parse_multiple_targets, Options};
+use crate::{Options, session::Error, utils::parse_multiple_targets};
 
 pub(crate) type SharedState = Arc<RwLock<Sessions>>;
 
@@ -220,7 +220,10 @@ impl Session {
                         *child_completed.lock().unwrap() =
                             Some(Completion::with_status(code.code().unwrap_or(-1)));
                     } else {
-                        log::error!("[{id}] child process {process_id} completed with code {code} (signal {:?})", code.signal());
+                        log::error!(
+                            "[{id}] child process {process_id} completed with code {code} (signal {:?})",
+                            code.signal()
+                        );
                         *child_completed.lock().unwrap() = Some(Completion::with_error(
                             child_out
                                 .lock()

src/api/sessions.rs

@@ -5,7 +5,7 @@ use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    creds::{self, expression, iterator, Credentials},
+    creds::{self, Credentials, expression, iterator},
     options::Options,
     session::Error,
 };

src/creds/combinator.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 use std::path::Path;
 
-use lazy_regex::{lazy_regex, Lazy};
+use lazy_regex::{Lazy, lazy_regex};
 use regex::Regex;
 use serde::Serialize;
 
@@ -223,11 +223,11 @@ pub(crate) fn parse_expression(expr: Option<&String>) -> Expression {
 
 #[cfg(test)]
 mod tests {
-    use super::parse_expression;
-    use super::Expression;
     use super::DEFAULT_PERMUTATIONS_CHARSET;
     use super::DEFAULT_PERMUTATIONS_MAX_LEN;
     use super::DEFAULT_PERMUTATIONS_MIN_LEN;
+    use super::Expression;
+    use super::parse_expression;
 
     #[test]
     fn can_parse_none() {

src/creds/expression.rs

@@ -39,16 +39,16 @@ impl std::iter::Iterator for Constant {
 
 #[cfg(test)]
 mod tests {
-    use crate::creds::{iterator, Expression};
+    use crate::creds::{Expression, iterator};
 
     #[test]
     fn can_handle_constant() {
-        let gen = iterator::new(Expression::Constant {
+        let iter = iterator::new(Expression::Constant {
             value: "hi".to_owned(),
         })
         .unwrap();
-        let tot = gen.search_space_size();
-        let vec: Vec<String> = gen.collect();
+        let tot = iter.search_space_size();
+        let vec: Vec<String> = iter.collect();
 
         assert_eq!(tot, 1);
         assert_eq!(vec, vec!["hi".to_owned()]);