Forem: Stacy Roll

How to get the Ctrl + C event in rust? 🔭🔮

Stacy Roll — Tue, 23 Jan 2024 19:23:50 +0000

If you are on a linux distro and you want to obtain the Ctrl + C event before the process ends in your terminal, in this article I am going to show you how to do it!

Cargo.toml

[dependencies]
k_board = { version = "1.2.4", features = ["ctrl_lower_letter"] }

main.rs

use k_board::{keyboard::Keyboard, keys::Keys};

fn main() {
    for key in Keyboard::new() {
        match key {
            Keys::Ctrl('c') => {
                println!("Yeah, you press Ctrl + C and the console doest ends!!");
                break;
            },
            _ => (),
        }
    }
}

See you in the next article❣️🤗!!

How to get the keys without pressing enter in rust ⌨️

Stacy Roll — Wed, 27 Dec 2023 22:08:34 +0000

The standard rust library does not support getting keyboard events in raw mode to capture keys without pressing enter. So, if you are in linux: in this post I am going to show you how to obtain the events and keys using the lightweight crate k_board.

[dependencies]
k_board = { version = "1.2.1", features = ["standar", "f", "alt_lower_letter", "ctrl_lower_letter", "lower_letter"] }

use k_board::{keyboard::Keyboard, keys::Keys};

fn main() {
    for key in Keyboard::new() {
        match key {
            Keys::Char('q') => break,
            Keys::Up => println!("Up arrow press"),
            Keys::Ctrl('t') => println!("Ctrl + t press"),
            Keys::Alt('p') => println!("Alt + p press"),
            Keys::Char('+') => println!("+ press"),
            Keys::F(2) => println!("F2 press"),
            Keys::Char('7') => println!("7 press"),
            _ => (),
        }
    }
}

What do features do?

Considering that efficiency in code is vital for developing a high-performance program, you can choose which parts of the keyboard will be listened to during runtime. If you only want to use the arrow keys and enter for your program, you can simply add it to your repository without features. However, if you want to use letters, numbers, special combinations, then you'll have to add it as a feature.

See you in the next post!🥰

How cybercriminals steal your passwords by listening to your keyboard 🕵️‍♀️ 💁‍♀️

Stacy Roll — Sat, 02 Dec 2023 21:33:06 +0000

Cybercriminals often don't have our passwords or tokens after a brute force decryption, but rather simply listen to our keyboard...

In this article, I'll show you how the use of pirated software can steal your passwords with just 10 additional lines of code for GNU/Linux systems.

Let's take a look at this Rust code:

use std::io::BufRead;

fn main() {
    println!("Enter your token to validate your identity:");
    let mut password: String = String::new();
    //we can hidden the input for more privacy
    let stdin: std::io::Stdin = std::io::stdin();
    stdin.lock().read_line(&mut password).unwrap();
    //send password with HTTPS
}

It is a standard function that retrieves a password and then sends it via HTTPS to a server. Without any alteration, this code is 100% secure.

Now, let's assume the user didn't download or compile an authentic version but instead downloaded a version modified by a cybercriminal. We can observe that by using a low-level keyboard handler, not only can they obtain the user's password, but they can also eavesdrop on the entire session.

I will use k_board for this.

cargo add k_board

Objectives:

Obtain password: Listen to the keyboard until an Enter key is pressed.
Session: Send what is typed to an HTTP server every 10 keystrokes.

use k_board::{Keyboard, Keys};
use std::io::BufRead;

fn main() {
    println!("Enter your token to validate your identity:");
    let mut password: String = String::new();
    let stdin: std::io::Stdin = std::io::stdin();
    stdin.lock().read_line(&mut password).unwrap();
    // -> send password to the original server
    // -> send password to our server
    // -> Inside logic program: look to every key event
    get_keys_pressed_and_send_it();
}

fn get_keys_pressed_and_send_it() {
    let mut i: u8 = 0;
    loop {
        let key = Keyboard::new().read_key();
        if key != Keys::Null {
            i += 1;
        }
        if i == 10 {
            //send to our server
            i = 0;
        }
    }
}

I am a little scared of what cybercriminals can do to me if I use modified software. Advocating for free software is not just about having things "free" in the economic sense of the word, but it is to prevent these kinds of everyday threats.

See you in the next article❣️🤗!!

A counter that listen keyboard events 🕹️

Stacy Roll — Mon, 27 Nov 2023 17:58:10 +0000

How to make a dynamic number counter so that when you press the up arrow, a number is added and when you press the down arrow, a number is subtracted?

I asked myself that question and proceeded to try to solve that algorithm in my mind first and then in code, here is the result.

Let's add the keyboard handler k_board

cargo add k_board

Let's add the program logic:

use k_board::{Keyboard, Keys};

fn main() {
    let mut number: i8 = 0;
    print_number(&mut number, 0);
    for key in Keyboard::new() {
        match key {
            Keys::Up => print_number(&mut number, 1),
            Keys::Down => print_number(&mut number, -1),
            Keys::Enter => break,
            _ => {}
        }
    }
}

fn print_number(number: &mut i8, operation: i8) {
    std::process::Command::new("clear").status().unwrap();
    *number += operation;
    println!("{}", number);
}

See you soon love ❤️

Ping-Pong rust: a project for your first dev-job

Stacy Roll — Wed, 15 Nov 2023 11:31:16 +0000

If you're looking for your first job as a Rust developer and are considering a project for your professional portfolio, this option could be a great proposal.

Let's add the ping-pong repository created by Eduardo Moraes and analyze the code:

git clone https://github.com/EduLMoraes/ping-pong.git

cargo run --release

Project structure:

main.rs

mod prelude;
use crate::prelude::*;

fn main() {
    loop{
        let choice: String = menu();

        if choice == "A".to_string() || choice == "a".to_string(){
            let lines: i32 = 20; //var("LINES").expect("Erro ao coletar 'LINES'").trim().parse::<i32>().expect("Erro ao converter 'COLUMNS' pra inteiro");
            let columns: i32 = 70; //var("COLUMNS").expect("Erro ao coletar 'COLUMNS'").trim().parse::<i32>().expect("Erro ao converter 'COLUMNS' pra inteiro");
            let board: Vec<Vec<char>> = vec![vec![' '; columns as usize]; lines as usize];
            let player: Player = Player::new();
            let scoreboard: Scoreboard = Scoreboard::new();
            let ball: Ball = Ball::new(lines, columns);
            let mut machine: Player = Player::new();

            machine.x = columns-2;

            let is_player_win: bool = play(player, machine, ball, scoreboard, board);
            if is_player_win {
                winner();
            }
            else{
                loser();
            }
        }
        else if choice == "B".to_string() || choice == "b".to_string(){
            instruct();
        }
        else{
            break;
        }
    }
}

The code defines a main function where the program runs in an infinite loop. Inside the loop, it presents a menu to the user by calling the menu function. Based on the user's choice (A, B, or anything else), it takes different actions.

If the user chooses option A (or a), the program initializes variables for lines and columns, creates a game board represented by a vector of vectors of characters, and sets up instances of player, scoreboard, and ball. It also initializes a machine player. The game then proceeds by calling the play function, and based on the outcome, either the winner or loser function is called.

If the user chooses option B (or b), the instruct function is called.

If the user chooses any other option, the program breaks out of the loop, effectively ending the program.

position.rs

use crate::structs::{Player, Ball};

pub fn position_player(mut player: Player, mut board: Vec<Vec<char>>) -> (Player, Vec<Vec<char>>){
    if board.len() <= 0 {
        return (player, board);
    }

    let columns = board[0].len() as i32;
    let lines = board.len() as i32;

    player.x = player.x.max(0);
    player.y = player.y.max(0);

    if player.width == 1 && player.height == 1 {
        board[player.y as usize][player.x as usize] = '|';
    }
    else{
        let tmp_x = player.x;
        let tmp_y = player.y;

        for _i in 1..=player.width{

            if player.x >= columns || player.x >= player.width{
                player.x -= 1;
            }

            let y_init = player.y;

            for y in 0..lines{
                if y == player.y{
                    if y < player.height{
                        board[player.y as usize][player.x as usize] = '|';
                        player.y += 1;
                    } 
                }

                for x in 0..columns{
                    if x == player.x && y == player.y{
                        if y < player.height && x < player.width{
                            board[y as usize][player.x as usize] = '|';
                        }
                    }
                }
            }

            player.x += 1;
            if player.y >= lines || player.y >= player.height{
                player.y -= player.height;
            }
            if player.y != y_init{
                player.y = y_init;
            }

        }
        player.y = tmp_y;
        player.x = tmp_x;
    }

    (player, board)
}

pub fn move_ball(mut ball: Ball, mut board: Vec<Vec<char>>) -> (Ball, Vec<Vec<char>>){
    if board.len() <= 0 {
        return (ball, board);
    }

    ball.x = ball.x.max(0);
    ball.y = ball.y.max(0);

    board[ball.y as usize][ball.x as usize] = '@';

    (ball, board)
}

`position_player` function:

The function checks if the board has a length less than or equal to 0, and if so, it returns the original player and board.
It calculates the number of columns and lines in the board.
Adjusts the player's coordinates to ensure they are not negative.
Depending on the player's dimensions (width and height), it updates the board to represent the player's position using the character '|'.
The function handles cases where the player has a width or height greater than 1, adjusting the player's position on the board accordingly.

`move_ball` function:

Similar to position_player, it checks if the board has a length less than or equal to 0 and returns the original ball and board if true.
Adjusts the ball's coordinates to ensure they are not negative.
Updates the board to represent the ball's position using the character '@'.

It's your time

In the competitive landscape of the tech industry, a well-crafted professional portfolio serves as a powerful asset for individuals seeking employment in the field of software development. In this case make your own ping-pong system is a greater challenge for new developers!

How to get Ctrl + S, Ctrl + C in my rust app

Stacy Roll — Mon, 13 Nov 2023 22:59:01 +0000

If you are on a GNU/Linux operating system, regardless of its distribution, and you are also developing a Rust-based application that requires handling user keyboard input in raw mode (without the need to press Enter), then this article can help you address that:

We add k_board to the project.

cargo add k_board

We implement the logic:

use k_board::{Keyboard, Keys};

fn main() {
    for key in Keyboard::new() {
        match key {
            Keys::Ctrl('s') => //paste,
            Keys::Ctrl('c') => //copy,
            Keys::Enter => break,
            _ => {}
        }
    }
}

Queues in rust: enqueue and dequeue 👉

Stacy Roll — Wed, 01 Nov 2023 16:37:19 +0000

In C, queues are elements that we can easily handle with pointers. In Rust, we have VecDeque included in the standard library, which allows us to manage queues of elements in a simple and easy way. Here's an example:

cargo add k_board

use k_board::{Keyboard, Keys};
use std::collections::VecDeque;

fn main() {
    let mut queue: VecDeque<i32> = VecDeque::new();
    loop {
        let mut option = menu(0);
        for key in Keyboard::new() {
            match key {
                Keys::Up => option = menu(0), // add to queue
                Keys::Down => option = menu(1), // clear queue
                Keys::Enter => break,
                _ => {}
            }
        }
        match option {
            0 => add_to_queue(&mut queue),
            1 => clear_queue(&mut queue),
            _ => {}
        }
    }
}

fn menu(operation: u8) -> u8 {
    std::process::Command::new("clear").status().unwrap();
    let mut op: Vec<char> = vec!['*', ' '];
    if operation == 1 {
        op[0] = ' ';
        op[1] = '*';
    }
    println!(
        "{} Add a number to the queue\n{} Free all queue memory",
        op[0], op[1]
    );
    operation
}

fn add_to_queue(queue: &mut VecDeque<i32>) {
    queue.push_back(get_number());
    println!("Elements in the queue: {:?}", queue);
    look_output();
}

fn get_number() -> i32 {
    println!("Enter a number to the queue");
    let mut input: String = String::new();
    std::io::stdin().read_line(&mut input).expect("Error");
    let number: i32 = match input.trim().parse() {
        Ok(number) => number,
        Err(_) => get_number(),
    };
    number
}

fn clear_queue(queue: &mut VecDeque<i32>) {
    queue.clear();
    println!("Queue after clear: {:?}", queue);
    look_output();
}

fn look_output() {
    let mut look_output: String = String::new();
    std::io::stdin().read_line(&mut look_output).expect("Error");
}

How to get the F1, F2, F3 ... keys in Rust ? 💬

Stacy Roll — Tue, 31 Oct 2023 14:14:42 +0000

If you're using a GNU/Linux operating system and want to develop a system that requires the F1, F2, F3, and so on keys as inputs, I recommend reading this short article on how to do it!

First of all, let's add the library that will allow us to interact with keyboard events at a low level. I'm talking about k_board.

cargo add k_board

Let's add the program's logic:

use k_board::{Keyboard, Keys};

fn main() {
    for key in Keyboard::new() {
        match key {
            Keys::F(1) => /*run some function*/,
            Keys::F(5) => /*update screen*/,
            Keys::F(11) => /*full screen*/,
            Keys::Enter => break,
            _ => {}
        }
    }
}

k_board has matched from F1 to F12, here is the source code.

Logic of a menu greater than 2 options in rust 🧠

Stacy Roll — Mon, 30 Oct 2023 13:03:09 +0000

Making a menu and matching functions is easy logic. Now when we have several options to match we need another logic to handle that event. In this article I am going to show you with k_board how to manage the logic for your program.

cargo add k_board

use k_board::{Keyboard, Keys};

fn main() {
    let mut number: i8 = 0;
    menu(&mut number, 0);
    for key in Keyboard::new() {
        match key {
            Keys::Up => menu(&mut number, -1),
            Keys::Down => menu(&mut number, 1),
            Keys::Enter => break,
            _ => {}
        }
    }
    //then match output
}

fn menu(operation: &mut i8, selection: i8) {
    std::process::Command::new("clear").status().unwrap();
    if *operation >= 0 && *operation <= 3 {
        *operation += selection;
        if *operation == -1 {
            *operation += 1;
        }
        if *operation == 4 {
            *operation -= 1;
        }
    }
    let mut op: Vec<char> = vec![' ', ' ', ' ', ' '];
    for i in 0..4 {
        if i == *operation {
            op[i as usize] = '*';
        }
    }
    println!("{} a\n{} b\n{} c\n{} d", op[0], op[1], op[2], op[3]);
}

Let's build a Dynamic Calculator! 📟

Stacy Roll — Sun, 29 Oct 2023 13:04:25 +0000

Add a keyboard mannager for users inputs:

cargo add k_board

Add calculator logic inside the program:

use k_board::{Keyboard, Keys};
use std::io;

fn main() {
    let mut result: f64 = 0.0;
    let first: f64 = get_number("first");
    let second: f64 = get_number("second");
    let operation: i8 = get_operation();
    match operation {
        0 => result = first + second,
        1 => result = first - second,
        2 => result = first * second,
        3 => {
            if second != 0.0 {
                result = first / second
            }
        }
        _ => {}
    }
    println!("The result is: {}", result);
}

fn get_number(position: &str) -> f64 {
    let mut input: String = String::new();
    println!("Enter the {} number: ", position);
    io::stdin().read_line(&mut input).expect("Error");
    let number: f64 = match input.trim().parse() {
        Ok(number) => number,
        Err(_) => get_number(position),
    };
    number
}

fn get_operation() -> i8 {
    let mut operation: i8 = 0;
    menu(&mut operation, 0);
    for key in Keyboard::new() {
        match key {
            Keys::Up => menu(&mut operation, -1),
            Keys::Down => menu(&mut operation, 1),
            Keys::Enter => break,
            _ => {}
        }
    }
    operation
}

fn menu(operation: &mut i8, selection: i8) {
    std::process::Command::new("clear").status().unwrap();
    if *operation > 0 || *operation < 3 {
        *operation += selection;
    }
    let mut op = vec![' ', ' ', ' ', ' '];
    for i in 0..4 {
        if i == *operation {
            op[i as usize] = '*';
        }
    }
    println!(
        "{} Add\n{} Subtract\n{} Multiply\n{} Divide",
        op[0], op[1], op[2], op[3]
    );
}

A counter that listen keyboard

Stacy Roll — Sat, 28 Oct 2023 11:37:22 +0000

How to make a dynamic number counter so that when you press the up arrow, a number is added and when you press the down arrow, a number is subtracted?

I asked myself that question and proceeded to try to solve that algorithm in my mind first and then in code, here is the result.

Let's add the keyboard handler k_board

cargo add k_board

Let's add the program logic:

use k_board::{Keyboard, Keys};

fn main() {
    let mut number: i8 = 0;
    print_number(&mut number, 0);
    for key in Keyboard::new() {
        match key {
            Keys::Up => print_number(&mut number, 1),
            Keys::Down => print_number(&mut number, -1),
            Keys::Enter => break,
            _ => {}
        }
    }
}

fn print_number(number: &mut i8, operation: i8) {
    std::process::Command::new("clear").status().unwrap();
    *number += operation;
    println!("{}", number);
}

Dynamic HTTP API for web & OS dev 🧢

Stacy Roll — Fri, 27 Oct 2023 11:42:28 +0000

Today we'll be writing a working web API using an extremely simple HTTP library controlable from the console of your computer. Let gonna se the implementation

First, crate a new folder and add k_board & snowboard.

cargo new http-api && cd http-api && cargo add k_board && cargo add snowboard

use k_board::{Keyboard, Keys};
use snowboard::{response, Server};

fn main() {
    for key in Keyboard::new() {
        match key {
            Keys::Enter => router("localhost:3000"),
            Keys::Letter('q') => break,
            _ => {}
        }
    }
}

fn router(localhost: &str) {
    println!("Running in localhost:3000 - `curl localhost:3000`");
    Server::new(localhost).run(|req| {
        println!("Request: {:?}", req);
        response!(ok, "You are in localhost 3000!\n")
    });
}

If you press enter you active the server listening all call, then when you make a curl localhost:300 you will receive the answer of the server.

mateo@debian:~/http-api$ curl localhost:3000
You are in localhost 3000!

That a simple example in which it just take the enter key as an activator of the server, if your looking for an specific handling of the keys for server activation , you can look at Keys struct of k_board.

pub enum Keys {
    Up,
    Down,
    Left,
    Right,
    Enter,
    Space,
    Delete,
    Escape,
    Plus,
    Minus,
    Equal,
    Power,                 ^
    Slash,                 /
    Backslash,             \
    Asterisk,              *
    Point,
    Comma,
    Hashtag,
    Pipe,                  |
    Percent,               %
    Ampersand,
    Currency,              $
    TwoPoints,             :
    Semicolon,             ;
    OpenSquareBracket,     [
    CloseSquareBracket,    ]
    OpenCurlyBrace,        {
    CloseCurlyBrace,       }
    OpenQuestionMark,      ¿
    CloseQuestionMark,     ?
    OpenParenthesis,       (
    CloseParenthesis,      )
    LessThan,              <
    GreaterThan,           >
    Apostrophe,            ' 
    At,                    @
    Home,
    End,
    Tab,
    Backtab,
    Insert,
    Letter(char),
    Number(u8),
    F(u8),
    Ctrl(char),
    Alt(char),
    Null,
}

Forem: Stacy Roll

How to get the Ctrl + C event in rust? 🔭🔮

Cargo.toml

main.rs

How to get the keys without pressing enter in rust ⌨️

What do features do?

How cybercriminals steal your passwords by listening to your keyboard 🕵️‍♀️ 💁‍♀️

A counter that listen keyboard events 🕹️

Ping-Pong rust: a project for your first dev-job

main.rs

position.rs

position_player function:

move_ball function:

It's your time

How to get Ctrl + S, Ctrl + C in my rust app

Queues in rust: enqueue and dequeue 👉

How to get the F1, F2, F3 ... keys in Rust ? 💬

Logic of a menu greater than 2 options in rust 🧠

Let's build a Dynamic Calculator! 📟

A counter that listen keyboard

Dynamic HTTP API for web & OS dev 🧢

`position_player` function:

`move_ball` function: