Forem: Bogdan Galin

Introducing dirb_rust: A High-Performance URL and Port Scanner

Bogdan Galin — Sat, 18 May 2024 02:53:25 +0000

Introducing `dirb_rust`: A High-Performance URL and Port Scanner

Introduction

I am excited to introduce dirb_rust, a powerful tool designed to check the availability of URLs, scan open ports, and search for API requests on a specified site. Written in Rust, dirb_rust can process up to half a million lines in just three minutes, making it exceptionally efficient for handling large URL lists. This post will walk you through the capabilities of dirb_rust, how to set it up, and how to use it.

Features

Merge Wordlists: Combines all text files in the wordlists directory into a single file, removing duplicates.
Asynchronous URL Checking: Efficiently checks the availability of URLs using asynchronous operations.
Port Scanning: Checks common ports on the specified site to determine if they are open.
API Request Detection: Searches for common API requests (fetch, axios, XMLHttpRequest) on the given site.
User-Friendly Output: Displays results using a progress bar and terminal interface, providing real-time feedback.

Installation

Before getting started, ensure you have Rust installed on your system. If Rust is not installed, follow the instructions on the website to install it.

Next, clone the dirb_rust repository from GitHub:

git clone https://github.com/Nopass0/dirb_rust.git
cd dirb_rust

Usage

To use dirb_rust, follow these steps:

Prepare Your Wordlists: Place your .txt format dictionaries in the wordlists directory. Each dictionary should contain lines with paths to be checked.
Run the Program: Execute the following command to start the program:

cargo run --release

Enter the Target URL: The program will prompt you to enter the URL of the site you want to scan (e.g., http://example.com).

The program will then merge all dictionaries into a single wordlist.txt file, removing duplicate lines, and start scanning for URL availability, open ports, and API requests.

Results

The results of the scan are saved in a file named output_{base_domain}_{current_date}.txt, where base_domain is the base domain of the site being checked, and current_date is the current date. The results file contains:

Available URLs: A list of URLs that are accessible.
Open Ports: A list of open ports with their descriptions.
API Requests: A list of detected API requests.
Example Output

Working links:
http://example.com/path1
http://example.com/path2
...

Open ports:
Port 80: HTTP - open
Port 443: HTTPS - open
...

API requests:
fetch('http://example.com/api')
axios.get('http://example.com/api')
...

System Requirements

Rust 1.50 or Higher: Ensure you have an up-to-date Rust installation.
Operating System: dirb_rust works on Windows, Linux, and macOS.

Conclusion

dirb_rust is a robust and efficient tool for anyone needing to scan large lists of URLs, check for open ports, and detect API requests. Its ability to process large datasets quickly makes it ideal for cybersecurity professionals, developers, and researchers.

Give dirb_rust a try and experience its high performance and ease of use. You can find the project on GitHub at https://github.com/Nopass0/dirb_rust.

Feel free to leave any feedback or suggestions in the comments below. Happy scanning!

All you should know about numbers in TypeScript. Tutorial

Bogdan Galin — Mon, 04 Sep 2023 10:41:15 +0000

Numbers are a fundamental data type in TypeScript, allowing you to work with numeric values in your programs. Understanding how to declare, manipulate, and format numbers is crucial for writing effective and accurate TypeScript code. Additionally, TypeScript's type system helps catch type-related errors during development, making your code more robust and reliable.

1. Numbers

let age : number = 30;
let price : number = 19.9;

2. Common Operations

Arithmetic Operations

let x: number = 10;
let y: number = 5;

let sum: number = x + y; // 15
let difference: number = x - y; // 5
let product: number = x * y; // 50
let quotient: number = x / y; // 2

Increment and Decrement

You can use the increment (++) and decrement (--) operators to modify number variables:

let count: number = 0;

count++; // Increment by 1 (count is now 1)
count--; // Decrement by 1 (count is back to 0)

3. Number Methods

toFixed(digits: number)

The toFixed method allows you to format a number with a fixed number of decimal places and returns it as a string:

let num: number = 42.123456;
let formattedNum: string = num.toFixed(2); // "42.12"

toExponential(fractionDigits?: number): string

The toExponential method returns a string representation of a number in exponential notation. The fractionDigits parameter, which is optional, specifies the number of digits to include after the decimal point.

let num: number = 12345.6789;
let exponentialNum: string = num.toExponential(2);
console.log(exponentialNum); // Output: "1.23e+4"

toPrecision(precision: number): string

The toPrecision method returns a string representation of a number using the specified precision. The precision parameter determines the total number of significant digits in the result.

let num: number = 123.456789;
let precisionNum: string = num.toPrecision(4);
console.log(precisionNum); // Output: "123.5"

toString(radix?: number): string

The toString method converts a number to its string representation. The radix parameter, which is optional, specifies the base for representing the number. By default, it's base 10.

let num: number = 42;
let binaryNum: string = num.toString(2); // Binary representation
console.log(binaryNum); // Output: "101010"

isNaN(): boolean

The isNaN method checks if a number is "Not-a-Number" (NaN). It returns true if the value is NaN, and false otherwise.

let value: number = NaN;
console.log(isNaN(value)); // Output: true

isFinite(): boolean

The isFinite method checks if a number is finite (i.e., not NaN, Infinity, or -Infinity). It returns true for finite numbers and false for NaN or infinity values.

let finiteNum: number = 42;
console.log(isFinite(finiteNum)); // Output: true

let infinityNum: number = Infinity;
console.log(isFinite(infinityNum)); // Output: false

parseFloat(string: string): number

The parseFloat function parses a string and returns a floating-point number. It stops parsing as soon as it encounters an invalid character.

let numStr: string = "3.14";
let parsedNum: number = parseFloat(numStr);
console.log(parsedNum); // Output: 3.14

parseInt(string: string, radix?: number): number

The parseInt function parses a string and returns an integer. The optional radix parameter specifies the base for parsing. If omitted, it assumes base 10.

let numStr: string = "42";
let parsedInt: number = parseInt(numStr);
console.log(parsedInt); // Output: 42

let binaryStr: string = "1010";
let parsedBinary: number = parseInt(binaryStr, 2); // Parse as binary
console.log(parsedBinary); // Output: 10

These methods and properties associated with number values in TypeScript allow you to perform various operations and format numbers as needed in your applications. Understanding these functions is crucial for working with numeric data effectively.

Lots of useful knowledge on types: How to calculate the 10,000th number in less than a second, How to make a server on the Express framework, Analysis of problems with Codewars\Leetcode. You can get here

Master Mind-Bending Challenges with Step-by-Step Insights! [Codewars]

Bogdan Galin — Sun, 03 Sep 2023 19:41:44 +0000

Playing with digits

Solve:

Explain:

This line converts the input number n into a string using String(n) and then converts it into an array of its digits using Array.from
For example, if n is 695, this line would produce an array [6, 9, 5]

This line initializes a variable total to store the sum of powered digits.
It uses the reduce method to iterate through the digits array (the digits of n) and calculates the sum of each digit raised to the power of p incremented by its position in the number.
acc accumulates the sum, digit represents each digit, and index is the position of the digit in the array.
Math.pow(digit, p + index) calculates the digit raised to the power of p + index.
The 0 at the end of reduce initializes the accumulator (acc) to zero.

This line checks if the total sum is divisible by n.
If total is divisible by n, it means there exists a positive integer k such that k * n equals the sum of powered digits.

If the condition in the if statement is true (i.e., total is divisible by n), the function returns total / n, which is the value of k.

In summary, this JavaScript function takes an integer n and an integer p, converts n into its digits, calculates the sum of powered digits, checks if this sum is divisible by n, and returns either the value of k (if it exists) or -1 (if it doesn't).

🚀 Feel free to subscribe to my Boosty! There, you'll discover a treasure trove of helpful tutorials and in-depth problem breakdowns. You can subscribe for free and gain access to a wealth of valuable information. And if you'd like, you can also show your support with a small donation and unlock extra content. ✨ Join Boosty here

Supercharge Your Productivity with the Copy&Paste Browser Extension! ✨

Bogdan Galin — Mon, 28 Aug 2023 22:56:59 +0000

Introduction

In today's information-rich world, efficiently managing online content can be a game-changer. 🌐 The Copy&Paste browser extension offers a creative solution to optimize your copy and paste activities, turbocharging your productivity while keeping your data secure. This remarkable extension not only simplifies content management but also comes completely free of charge and devoid of any annoying advertisements. Its impressive credentials even include a nod of approval from none other than Google.

The Copy&Paste Extension: Making Life Easier 📋

The Copy&Paste browser extension reimagines how we interact with copied content across various websites. 📄 Once you've installed this extension, any snippet of content you copy gets safely stowed away within the extension's clipboard. This content remains at your fingertips until you choose to clear it out, providing an immensely convenient way to access and reuse information whenever you need it.

The extension boasts a user-friendly interface, granting you access to your copied content via a dedicated window. 🪟 This window showcases a chronological history of your copied items, allowing you to effortlessly revisit and recopy them whenever the situation calls for it. Whether it's coding snippets, paragraphs from articles, or links to essential resources, everything is neatly organized within the extension.

Benefits for Your Productivity 🚀

Seamless Workflow: Say goodbye to the hassle of switching between tabs or applications to retrieve copied content. The extension ensures smooth sailing, helping you maintain your workflow's rhythm.

Effortless Content Reuse: The power to swiftly access and reuse previously copied content is a game-changer. This proves especially handy for tasks involving repeated pasting, like coding or crafting content.

Taming Information Overload: Instead of crowding your clipboard with an assortment of items, the extension provides a designated hub for managing copied content. This prevents mix-ups and accidental overwrites, promoting a clutter-free workspace.

Security and Privacy First! 🔒

One standout feature of the Copy&Paste extension is its unwavering commitment to safeguarding your data and privacy. 🛡️ All copied content is stored exclusively on your device, mitigating the risks tied to cloud-based storage solutions. Your sensitive information remains under your control, never being transmitted or stored on external servers.

Google Gives a Nod of Approval 👍

The Copy&Paste extension has earned accolades from Google, a solid testament to its prowess and quality. Google's endorsement underscores the extension's performance, security measures, and adherence to industry best practices.

Conclusion

The Copy&Paste browser extension is a game-changer, revolutionizing how we handle and reuse copied online content. Its user-friendly interface, productivity-boosting features, robust data security, and Google's stamp of approval make it a compelling addition to your browsing toolkit. By adopting this extension, you're not just streamlining your workflow but also ensuring privacy and steering clear of unnecessary costs.

In a digital realm where optimizing workflows reigns supreme, the Copy&Paste extension emerges as an invaluable asset for professionals, students, and anyone who values efficient information management.

Ready to take the plunge? Elevate your productivity, simplify your browsing, and seize control of your copied content like never before. Get started with the Copy&Paste browser extension today! 🚀📋

Computing the 10,000th Fibonacci number in less than a second. Unveiling the Secrets of Giant Numbers: Building Your Own BigInt

Bogdan Galin — Mon, 28 Aug 2023 22:12:00 +0000

In this exciting journey, we explore the evolution of Fibonacci calculations, from the inefficiency of traditional recursion to the powerful domain of matrix multiplication and optimized algorithms. Ready for an exciting exploration of big numbers and exciting code? Let's dive in!

Part 0: The Recursive Dilemma – Traditional Fibonacci Computation

Before we delve into the realm of optimized algorithms and matrix magic, let's embark on a journey that traces back to the traditional method of calculating Fibonacci numbers through recursion. While this approach seems intuitive and simple, it quickly reveals its inefficiency as the numbers grow larger.

Traditional Recursive Approach

The Fibonacci sequence is often defined recursively, where each number is the sum of the two preceding ones: F(n) = F(n-1) + F(n-2). Let's implement this definition using a recursive function in Rust:

fn fibonacci_recursive(n: u32) -> u32 {
    if n == 0 {
        return 0;
    } else if n == 1 || n == 2 {
        return 1;
    } else {
        return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
    }
}

Time Complexity Analysis

The time complexity of the recursive Fibonacci algorithm is approximately O(2^n), where n is the input number. This means that the computation time grows exponentially with the input size. As a result, even relatively small values of n can lead to considerable computation times.

Part 1: BigInt – Building Blocks for Big Numbers

Our journey then takes us to the creation of a robust data structure, aptly named BigInt, that empowers us to manipulate colossal numbers with finesse. Here's a glimpse into the code:

// Import necessary libraries
use std::cmp::max;
use std::fmt;
use std::ops::{Add, Mul};

// Define the BigInt structure
#[derive(Debug, Clone)]
struct BigInt {
    data: Vec<u32>,
}

impl BigInt {
    // Constructor for creating a BigInt from a single value
    fn new(value: u32) -> Self {
        BigInt {
            data: vec![value], // Initialize the data vector with the provided value.
        }
    }

    // Constructor for creating a BigInt from a vector of digits
    fn from_vec(data: Vec<u32>) -> Self {
        BigInt {
            data, // Initialize the data vector with the provided digits.
        }
    }

    // Convert the BigInt to a string
    fn to_string(&self) -> String {
        self.data.iter().rev().map(|digit| digit.to_string()).collect() // Convert each digit to a string and concatenate.
    }
}

// Implement addition for BigInt
impl Add<&BigInt> for &BigInt {
    type Output = BigInt;

    fn add(self, other: &BigInt) -> BigInt {
        // ... (Addition logic)
        // Perform digit-wise addition, considering carry values.
        // Return a new BigInt instance representing the sum.
    }
}

// Implement multiplication for BigInt
impl Mul<&BigInt> for &BigInt {
    type Output = BigInt;

    fn mul(self, other: &BigInt) -> BigInt {
        // ... (Multiplication logic)
        // Implement binary multiplication algorithm to efficiently compute the product.
        // Return a new BigInt instance representing the product.
    }
}

// ... (Other operations, methods, and traits for BigInt)

In this section, we introduce the BigInt structure, which stores the digits of a large number in a vector. Methods like new, from_vec, and to_string facilitate creation, conversion, and visualization of these gigantic numbers. The overloading of addition and multiplication operators enables seamless arithmetic operations on BigInt instances.

Part 2: Matrix Magic – Cracking Fibonacci's Code

Matrix formula for Fibonacci numbers

But then, denoting

we get:

Thus, to find the nth Fibonacci number, you need to raise the matrix P to the power of n.

Remembering that raising a matrix to the n'th power can be done in O(log n) (see Binary exponentiation), it turns out that the nth Fibonacci number can be easily computed in O(log n) using only integer arithmetic.

Part 3: Binary Exponentiation: Unleashing the Power of Efficient Exponentiation

Exponentiation, a fundamental mathematical operation, becomes significantly more powerful when combined with binary manipulation. Binary exponentiation, also known as binary powering, is a technique that empowers us to compute the result of raising a number to a certain power in a remarkably efficient manner. In this section, we'll explore the binary exponentiation algorithm, understand its mechanics, and delve into its implementation.

The Binary Exponentiation Algorithm: A Glimpse into Efficiency

Binary exponentiation is a technique that allows us to compute a^n with only O(log n) multiplications, a substantial improvement over the naive approach of performing n multiplications. What's more, this technique can be applied not only to exponentiation but to any associative operation, making it versatile and applicable to a wide range of scenarios.

The Essence of Associativity: A Brief Recap

An operation is associative if, for any values a, b, and c, the following holds true:

(a * b) * c = a * (b * c)

This associativity property forms the foundation of binary exponentiation, extending its application to various operations, including modular arithmetic and matrix multiplication.

The Algorithm Unveiled: Binary Exponentiation Steps

The beauty of binary exponentiation lies in its simplicity and elegance. Let's break down the algorithm into steps and unveil its magic:

Observe that for any number a and even power n, the following identity holds true (derived from the associativity of multiplication):

a^n = (a^(n/2))^2 = a^(n/2) * a^(n/2)

This identity forms the crux of the binary exponentiation algorithm. When n is even, we've shown how to reduce the problem to computing the power of a^(n/2) using only one multiplication.

Now, let's consider the case when n is odd. In this scenario, we can convert the problem to computing the power of a^(n-1), which is even:

a^n = a^(n-1) * a

The algorithm essentially recurses by splitting the exponent n into two parts: one part that is halved (n/2 or n-1) and another part that is always squared (n/2). This recurrence continues until n reaches the base case of 0, where the result is 1.

Here's the implementation of binary exponentiation in Rust:

fn binary_pow(a: u32, mut n: u32) -> u32 {
    let mut result = 1;

    while n > 0 {
        if n & 1 == 1 {
            result *= a; // Accumulate the result using binary multiplication.
        }

        a *= a; // Square the base for each iteration.
        n >>= 1; // Halve the exponent.
    }

    result
}

In this implementation, we iteratively update result and a based on the binary properties of n, optimizing the calculation process.

Part 4: Conclusion

Combining all of the above, we get a way to calculate fibonacci numbers very quickly. Below is all the code that, without third-party dependencies, calculates these numbers very well

use std::cmp::max;
use std::fmt;
use std::ops::{Add, Mul};

#[derive(Debug, Clone)]
struct BigInt {
    data: Vec<u32>,
}

impl BigInt {
    fn new(value: u32) -> Self {
        BigInt {
            data: vec![value],
        }
    }

    fn from_vec(data: Vec<u32>) -> Self {
        BigInt { data }
    }

    fn to_string(&self) -> String {
        self.data.iter().rev().map(|digit| digit.to_string()).collect()
    }
}

impl Add<&BigInt> for &BigInt {
    type Output = BigInt;

    fn add(self, other: &BigInt) -> BigInt {
        let max_len = max(self.data.len(), other.data.len());
        let mut result = Vec::new();
        let mut carry = 0;

        for i in 0..max_len {
            let a = if i < self.data.len() { self.data[i] } else { 0 };
            let b = if i < other.data.len() { other.data[i] } else { 0 };
            let sum = a + b + carry;
            result.push(sum % 10);
            carry = sum / 10;
        }

        if carry > 0 {
            result.push(carry);
        }

        BigInt::from_vec(result)
    }
}

impl Mul<&BigInt> for &BigInt {
    type Output = BigInt;

    fn mul(self, other: &BigInt) -> BigInt {
        let mut result = BigInt::new(0);

        for (i, num) in other.data.iter().enumerate() {
            let mut carry = 0;
            let mut temp_result = vec![0; i];

            for &digit in self.data.iter() {
                let product = digit * num + carry;
                temp_result.push(product % 10);
                carry = product / 10;
            }

            if carry > 0 {
                temp_result.push(carry);
            }

            result = &result + &BigInt::from_vec(temp_result);
        }

        result
    }
}

fn matrix_mul(a: &[[BigInt; 2]; 2], b: &[[BigInt; 2]; 2]) -> [[BigInt; 2]; 2] {
    let mut result = [[BigInt::new(0), BigInt::new(0)], [BigInt::new(0), BigInt::new(0)]];

    for i in 0..2 {
        for j in 0..2 {
            for k in 0..2 {
                result[i][j] = &result[i][j] + &(&a[i][k] * &b[k][j]);
            }
        }
    }

    result
}

fn matrix_power(matrix: &[[BigInt; 2]; 2], power: u32) -> [[BigInt; 2]; 2] {
    if power == 0 {
        [
            [BigInt::new(1), BigInt::new(0)],
            [BigInt::new(0), BigInt::new(1)],
        ]
    } else if power == 1 {
        matrix.clone()
    } else {
        let half_power = power / 2;
        let half_matrix = matrix_power(matrix, half_power);
        let result = matrix_mul(&half_matrix, &half_matrix);
        if power % 2 == 0 {
            result
        } else {
            matrix_mul(&result, matrix)
        }
    }
}

fn fibonacci(n: u32) -> BigInt {
    if n == 0 {
        BigInt::new(0)
    } else if n == 1 || n == 2 {
        BigInt::new(1)
    } else {
        let base_matrix = [
            [BigInt::new(1), BigInt::new(1)],
            [BigInt::new(1), BigInt::new(0)],
        ];
        let matrix_power_n_minus_1 = matrix_power(&base_matrix, n - 1);
        matrix_power_n_minus_1[0][0].clone()
    }
}

impl fmt::Display for BigInt {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

fn main() {
    let n = 10000;
    let result = fibonacci(n);
    println!("Fibonacci({}) = {}", n, result);
}

The result of the program execution:

You can try it here: rust playground
Also you can see more posts here: Boosty

Supercharge Your File Management with NetFolders: Organize, Secure, and Collaborate

Bogdan Galin — Mon, 21 Aug 2023 15:56:00 +0000

Are you tired of juggling multiple file-sharing services, worrying about security, or struggling with version control? Say hello to NetFolders, a powerful TypeScript-based Node.js file server and management system that will transform the way you handle files.

🌟 Why NetFolders?

Streamlined File Management: With NetFolders, you can easily upload, store, and manage your files in one centralized location. No more searching through various platforms to find what you need!

Rock-Solid Security: NetFolders offers robust authentication options, ensuring that your files are secure. Set up an authentication key for extra peace of mind.

Effortless Collaboration: Share files with colleagues, clients, or team members with ease. They can download files using unique tokens, maintaining privacy and control over your data.

Server-side Logging: Keep track of every action with the built-in logging utility. Know who accessed what and when, ensuring accountability and transparency.

🚀 How You Can Use NetFolders

Project Collaboration: Simplify collaboration by sharing files securely with your project team. Say goodbye to clunky email attachments and disorganized folders.

Document Management: Keep important documents neatly organized, easily accessible, and securely stored with NetFolders. Access them from anywhere, anytime.

Personal File Server: Set up your personal file server for remote access to your files, maintaining control over your data and privacy.

Educational Resources: For educators and trainers, NetFolders can be a fantastic tool for sharing lecture materials, assignments, and resources with students.

Photographers and Designers: Photographers, designers, and creatives can showcase their portfolios or deliver high-quality files to clients in a professional manner.

Discover the future of file management with NetFolders. Get started today and take control of your files, security, and collaboration needs. See the GitHub repository to learn more and contribute!

👉 Have you tried NetFolders yet? Share your experience and thoughts in the comments below! Let's revolutionize the way we manage and collaborate on files.

GitHub Repository