DEV Community: B Mithilesh

OverTheWire: Bandit - Level 0

B Mithilesh — Tue, 22 Jul 2025 16:53:10 +0000

OverTheWire: Bandit - Level 0

Level Goal

The goal of this level is to log into the game using SSH. Once logged in, go to the Level 1 page to find out how to beat Level 1.

Connection Details

Username: bandit0
Password: bandit0
Hostname: bandit.labs.overthewire.org
Port: 2220

Commands You May Need

ssh – OpenSSH remote login client

What is SSH?

SSH (Secure Shell) is a cryptographic network protocol for operating network services securely over an unsecured network. It’s commonly used to remotely log into machines, transfer files, and execute commands securely.

Solution Steps

Open Terminal
- On Windows, use PowerShell or Command Prompt.
- On Linux/macOS, use the built-in terminal.
Execute SSH Command:

   ssh bandit0@bandit.labs.overthewire.org -p 2220

Fingerprint Prompt: If prompted to accept the server's fingerprint, type:

yes

Password Prompt: Enter the password:

   bandit0

Successful Login: You should see a banner like:

   This is an OverTheWire game server. More information on http://www.overthewire.org/wargames

To Exit SSH: Type exit or use Ctrl + D.

Helpful Tips

Ensure your internet connection is stable before connecting.
If the connection hangs, try re-running the SSH command.
Double-check the port number -p 2220 — it's not the default SSH port.

Next Step

Once you’ve successfully logged in, proceed to Bandit Level 1 to continue.

Bypass Netflix’s Same Household Block — With a Fullscreen Playbar That Just Works

B Mithilesh — Mon, 16 Jun 2025 14:02:08 +0000

Built out of frustration as a broke student, this extension adds a fullscreen playbar to Netflix and blocks those annoying “same home network” modals. No fancy UI — just works. Makes Netflix load faster, look better, and stop nagging.

No data collected, no bloat, no BS. Just pure DOM hacking.

Because I just wanted to watch in peace 😤

Ambient lighting - DIY

B Mithilesh — Sun, 15 Jun 2025 13:53:26 +0000

✨ Bring Your Screen to Life with Ambient LED Lighting

Ever seen TVs or gaming setups that glow with colors matching what's happening on the screen? That's ambient lighting — and now you can bring that magic to your own setup.

🎥 What Is It?

Imagine watching a sunset in a movie, and your room softly glows orange and red to match. Or playing a game, and as explosions light up your screen, your walls reflect the same fiery burst. That's what ambient LED lighting does — it extends your screen beyond the frame, creating an immersive atmosphere.

🌈 How Does It Work?

Without getting too technical: Tiny LED lights are placed around your screen — usually behind it. These lights "watch" what's happening on the edges of your screen in real-time, and then glow in matching colors. The result? Your entire room reacts to your screen, creating a dynamic, living light show that follows the action.

🛋 Where Can You Use It?

🎮 Gaming setups – Feel like you're inside the game
📺 Home theaters – Add drama, warmth, and immersion
💻 Desktops – Ambient vibes for work or late-night browsing
🎶 Music visualizers – Sync lights with beats and moods
🧘‍♂️ Relaxation spaces – Create calming light environments that shift slowly over time

💡 Why It's Awesome

Makes screens feel larger and more cinematic
Reduces eye strain by softening the contrast between screen and room
Transforms any space into something futuristic and alive
Highly customizable: brightness, colors, patterns, and more

Whether you're a movie lover, gamer, or just someone who loves a cool vibe — ambient LED lighting adds a whole new dimension to your experience.

Simple Sieve - DSA

B Mithilesh — Sun, 15 Jun 2025 13:19:31 +0000

🧮 A Simple Sieve of Eratosthenes in Java: Find All Primes Up to N

"The prime numbers are the building blocks of all natural numbers."

— Carl Friedrich Gauss

Prime numbers play a fundamental role in number theory and cryptography. In this post, we'll walk through the Sieve of Eratosthenes — a simple and efficient algorithm to generate all prime numbers up to a given number n.

We'll cover:

✅ What the sieve is
🧠 How it works
🔧 Java implementation (with fixed code)
🌍 Real-life applications of primes

📌 What Is the Sieve of Eratosthenes?

The Sieve of Eratosthenes is a classic algorithm used to find all prime numbers less than a given integer n. It does so by iteratively marking the multiples of each prime starting from 2.

Time Complexity: O(n log log n)

Space Complexity: O(n)

💡 How Does It Work?

Create a boolean array of size n + 1, initialized to true. Each index represents a number.
Starting from 2, for each number, if it is marked true, mark all its multiples as false.
At the end, all indices with true are prime.

🧪 Java Implementation

Here's a clean and corrected version of the sieve algorithm in Java:

import java.util.Scanner;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // Input the upper limit

        boolean[] isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);

        isPrime[0] = false;
        isPrime[1] = false;

        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i) {
                    isPrime[j] = false;
                }
            }
        }

        System.out.println("Prime numbers up to " + n + " are:");
        for (int i = 2; i <= n; i++) {
            if (isPrime[i]) {
                System.out.print(i + " ");
            }
        }
    }
}

🔍 Fixes Made to the Original Code

Replaced undeclared variable num with n
Fixed syntax error: === → == (Java uses == for comparison)
Included primes up to n (inclusive)
Set isPrime[0] and isPrime[1] to false explicitly
Used Arrays.fill() for simplicity and clarity

🌍 Real-Life Applications of Prime Numbers

🔐 Cryptography & Cybersecurity

Public-key encryption algorithms like RSA use large primes for secure key generation.

🎲 Random Number Generation

Primes are used in linear congruential generators and hash functions to produce uniform randomness.

💽 Hashing Algorithms

Prime table sizes reduce hash collisions, improving performance in hash tables and bloom filters.

🎮 Procedural Generation in Graphics

Games use prime intervals to generate less predictable world seeds and layouts.

📊 Mathematical Research & Theories

The study of primes leads to groundbreaking theorems and conjectures (e.g., Goldbach's, Riemann Hypothesis).

🚀 Try It Out Yourself

You can run the above code on any online Java compiler:

🔗 Replit
🔗 JDoodle
🔗 OnlineGDB

Just copy-paste the code, input a number like 100, and watch the primes roll out!

How to Share Internet Connection on Linux (Server to Client via Ethernet)

B Mithilesh — Thu, 16 Jan 2025 16:43:13 +0000

Sharing an Internet connection on Linux between two computers using an Ethernet cable might seem tricky at first, but it’s straightforward once you know the steps. Whether you’re troubleshooting, setting up a local network, or just exploring Linux networking, this guide has you covered.

📡 Steps to Configure Internet Sharing on the Server

1. Open Network Connections

Click on the network icon in the system tray or panel.
Select "Edit Connections..." from the dropdown menu.

2. Edit the Wired Connection

In the Network Connections dialog, locate and double-click your Wired Connection.
This is the connection that will be used to share Internet access. 👉 Leave the wireless connection untouched if it’s the one connected to the Internet.

3. Modify IPv4 Settings

Navigate to the "IPv4 Settings" tab.
Set the Method to "Shared to other computers".
Save and close the settings.

4. Reconnect the Wired Network

Disconnect and reconnect the Wired Network so it gets a new IP address.
Make sure the server and client are physically connected via an Ethernet cable.

5. Retrieve Connection Information

Click on "Connection Information" in the network menu.
Note down the IP address and network mask assigned to the wired connection. (Example: 10.42.0.1/255.255.255.0).

🖧 Steps to Configure the Client Computer

1. Open Network Connections

On the client computer, click the network icon and select "Edit Connections...".

2. Edit the Wired Connection

Locate and double-click your Wired Connection.

3. Modify IPv4 Settings

Navigate to the "IPv4 Settings" tab.
Set the Method to "Manual".
Assign an IP address on the same subnetwork as the server. 👉 Example: 10.42.0.69
Use the IP and network mask from the server for:
- Netmask: 255.255.255.0
- Gateway: 10.42.0.1
- DNS Servers: 10.42.0.1

4. Reconnect the Wired Network

Disconnect and reconnect the Wired Network to apply the new settings.

🚀 Final Step

Pat yourself on the back and surf away! 🎉

📢 Additional Notes

Make sure the Ethernet cable is connected before reconnecting the networks on both computers.
If Internet sharing doesn’t work as expected, verify the server’s firewall settings to ensure proper traffic routing.

Let me know if you have any questions or if this guide worked for you in the comments! 👇

Regression

B Mithilesh — Mon, 26 Aug 2024 16:20:49 +0000

Regression Evaluation Metrics

When working with regression models, it's crucial to evaluate their performance by comparing the predicted and actual values. Here are some common metrics used for this purpose:

Mean Absolute Error (MAE)

The Mean Absolute Error (MAE) indicates by how much each prediction was wrong on average, without considering whether the prediction was over or under the actual value. This metric is the mean of the absolute errors for the entire validation set.

For example, consider predicting the number of ice creams sold. If the absolute errors are 2, 3, 3, 1, 2, and 3, the MAE is calculated as:

MAE = (2 + 3 + 3 + 1 + 2 + 3) / 6 = 2.33

Mean Squared Error (MSE)

While MAE treats all discrepancies equally, sometimes it's desirable to amplify larger errors. The Mean Squared Error (MSE) does this by squaring the errors before averaging them, which emphasizes larger errors more.

Using the same ice cream example, the squared errors are 4, 9, 9, 1, 4, and 9, so the MSE is:

MSE = (4 + 9 + 9 + 1 + 4 + 9) / 6 = 6

Root Mean Squared Error (RMSE)

The MSE metric is useful, but it doesn't represent the quantity measured by the label due to the squaring process. To bring it back to the original scale, we calculate the Root Mean Squared Error (RMSE), which is the square root of MSE.

For the example:

RMSE = √6 ≈ 2.45 (ice creams)

Coefficient of Determination (R²)

The Coefficient of Determination, or R², measures the proportion of variance in the actual values explained by the model. An R² value closer to 1 indicates a better fit.

The formula for R² is:

R² = 1 - ∑(y - ŷ)² / ∑(y - ȳ)²

In simple terms, if our ice cream regression model has an R² of 0.95, it means that 95% of the variance in ice cream sales can be explained by the model.

Iterative Training

In practice, developing a regression model involves iterative training. This includes:

Feature selection and preparation: Choosing the right features and applying transformations to ensure a better model fit.
Algorithm selection: While linear regression is one option, many other regression algorithms could be explored.
Algorithm parameters: Adjusting hyperparameters to control the algorithm's behaviour and improve performance.

Through multiple iterations, a data scientist refines the model to achieve the best evaluation metrics suitable for the scenario.

Tree structure of Machine Learning

B Mithilesh — Sun, 04 Aug 2024 13:36:24 +0000

Supervised machine learning

Supervised machine learning is a general term for machine learning algorithms in which the training data includes both feature values and known label values. Supervised machine learning is used to train models by determining a relationship between the features and labels in past observations, so that unknown labels can be predicted for features in future cases.

Regression

Regression is a form of supervised machine learning in which the label predicted by the model is a numeric value. For example:

- The number of ice creams sold on a given day, based on the temperature, rainfall, and windspeed.
- The selling price of a property based on its size in square feet, the number of bedrooms it contains, and socio-economic metrics for its location.
- The fuel efficiency (in miles-per-gallon) of a car based on its engine size, weight, width, height, and length.

Classification

Classification is a form of supervised machine learning in which the label represents a categorization, or class. There are two common classification scenarios.
Binary classification

In binary classification, the label determines whether the observed item is (or isn't) an instance of a specific class. Or put another way, binary classification models predict one of two mutually exclusive outcomes. For example:

Whether a patient is at risk for diabetes based on clinical metrics like weight, age, blood glucose level, and so on.
Whether a bank customer will default on a loan based on income, credit history, age, and other factors.
Whether a mailing list customer will respond positively to a marketing offer based on demographic attributes and past purchases.

In all of these examples, the model predicts a binary true/false or positive/negative prediction for a single possible class.
Multiclass classification

Multiclass classification extends binary classification to predict a label that represents one of multiple possible classes. For example,

The species of a penguin (Adelie, Gentoo, or Chinstrap) based on its physical measurements.
The genre of a movie (comedy, horror, romance, adventure, or science fiction) based on its cast, director, and budget.

In most scenarios that involve a known set of multiple classes, multiclass classification is used to predict mutually exclusive labels. For example, a penguin can't be both a Gentoo and an Adelie. However, there are also some algorithms that you can use to train multilabel classification models, in which there may be more than one valid label for a single observation. For example, a movie could potentially be categorized as both science fiction and comedy.

Unsupervised machine learning

Unsupervised machine learning involves training models using data that consists only of feature values without any known labels. Unsupervised machine learning algorithms determine relationships between the features of the observations in the training data.

Clustering

The most common form of unsupervised machine learning is clustering. A clustering algorithm identifies similarities between observations based on their features, and groups them into discrete clusters. For example:

Group similar flowers based on their size, number of leaves, and number of petals.
Identify groups of similar customers based on demographic attributes and purchasing behavior.

In some ways, clustering is similar to multiclass classification; in that it categorizes observations into discrete groups. The difference is that when using classification, you already know the classes to which the observations in the training data belong; so the algorithm works by determining the relationship between the features and the known classification label. In clustering, there's no previously known cluster label and the algorithm groups the data observations based purely on similarity of features.

In some cases, clustering is used to determine the set of classes that exist before training a classification model. For example, you might use clustering to segment your customers into groups, and then analyze those groups to identify and categorize different classes of customer (high value - low volume, frequent small purchaser, and so on). You could then use your categorizations to label the observations in your clustering results and use the labeled data to train a classification model that predicts to which customer category a new customer might belong.

IpLookup website - know your device IP in the network and device specifications

B Mithilesh — Fri, 05 Jul 2024 12:48:54 +0000

https://ip.mithileshdev.co/

Dev Blog: Building a Web App to Display IP Address, Geolocation, and Device Specs

Introduction

In this blog, I'll walk you through the process of building a web application that displays your IP address, geolocation, and detailed device specifications. This project was a fantastic learning experience, showcasing the power of modern web technologies and APIs.
Project Overview

Our web app provides the following features:

IP Address and Geolocation
Device Specifications
Network Information

Let's dive into the implementation, breaking it down into small, digestible snippets.
Setting Up the Project

We started with a basic HTML structure to create the foundation of our web app.

This simple setup includes placeholders for the different pieces of information we plan to display.
Fetching IP Address and Geolocation

To get the user's IP address and geolocation, we used the IP Geolocation API. Here's the snippet for fetching and displaying this data:

javascript

async function fetchIPAndLocation() {
    const response = await fetch('https://api.ipgeolocation.io/ipgeo?apiKey=YOUR_API_KEY');
    const data = await response.json();
    document.getElementById('ip-address').innerText = `IP Address: ${data.ip}`;
    document.getElementById('location').innerText = `Location: ${data.city}, ${data.country_name} (Lat: ${data.latitude}, Lon: ${data.longitude})`;
}

fetchIPAndLocation();

Using fetch, we make an API call to get the IP address and geolocation data, then update the HTML with this information.
Gathering Device Specifications

To collect various device specs, we used multiple browser APIs. This snippet illustrates how to get screen size, device memory, CPU cores, and GPU info:

javascript

function getDeviceSpecs() {
    const specs = {};
    specs.screenWidth = window.screen.width;
    specs.screenHeight = window.screen.height;
    specs.deviceMemory = navigator.deviceMemory || 'N/A';
    specs.hardwareConcurrency = navigator.hardwareConcurrency || 'N/A';

    const gl = document.createElement('canvas').getContext('webgl');
    specs.gpu = gl.getParameter(gl.UNMASKED_RENDERER_WEBGL);

    document.getElementById('device-specs').innerHTML = `
        <h2>Device Specs:</h2>
        <p>Screen Size: ${specs.screenWidth} x ${specs.screenHeight}</p>
        <p>Device Memory: ${specs.deviceMemory} GB</p>
        <p>CPU Cores: ${specs.hardwareConcurrency}</p>
        <p>GPU: ${specs.gpu}</p>
    `;
}

getDeviceSpecs();

We accessed properties like window.screen.width and navigator.deviceMemory, and used WebGL to get GPU information.
Displaying Battery Information

The Battery Status API provides battery level details:

javascript

async function getBatteryInfo() {
    const battery = await navigator.getBattery();
    document.getElementById('device-specs').innerHTML += `
        <p>Battery Level: ${battery.level * 100}%</p>
        <p>Battery Temperature: Not directly available, simulated value: 30°C</p>
    `;
}

getBatteryInfo();

Although direct battery temperature isn't available, we simulated it for demonstration purposes.
Fetching Network Information

We used the Network Information API to display network details:

javascript

function getNetworkInfo() {
    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
    const type = connection.effectiveType;
    const downlink = connection.downlink;
    const rtt = connection.rtt;

    document.getElementById('network-info').innerHTML = `
        <h2>Network Info:</h2>
        <p>Connection Type: ${type}</p>
        <p>Downlink: ${downlink} Mbps</p>
        <p>RTT: ${rtt} ms</p>
    `;
}

getNetworkInfo();

This snippet accesses connection properties to show the type, downlink speed, and round-trip time.
Calculating FPS

For calculating FPS, we used the Performance API:

javascript

function calculateFPS() {
    let lastFrame = performance.now();
    let frameCount = 0;
    let fps = 0;

    function loop() {
        const now = performance.now();
        frameCount++;
        if (now - lastFrame >= 1000) {
            fps = frameCount;
            frameCount = 0;
            lastFrame = now;
            document.getElementById('device-specs').innerHTML += `<p>FPS: ${fps}</p>`;
        }
        requestAnimationFrame(loop);
    }

    loop();
}

calculateFPS();

By measuring the time between frames, we calculated and displayed the FPS.

Conclusion

Building this web application was a fantastic experience, allowing us to explore various web APIs and enhance our understanding of client-side scripting. The combination of these technologies resulted in a comprehensive tool that provides users with insightful information about their device and network.

Feel free to explore and extend this project. The full code is available on our GitHub repository. Happy coding!

HEIMDALL - Open Source PYscript for bypassing and login captive portals in private networks

B Mithilesh — Sat, 15 Jun 2024 17:42:35 +0000

This Python script automates the process of connecting to a captive portal, often encountered in public Wi-Fi networks. Here’s a summary of how the code works and its usefulness:

Summary:

Setup and Configuration:
- The script imports various libraries, including requests for HTTP requests and JSON for handling JSON data.
- It defines several enums (Client_type, Request_type, Portal_action, Server_response) to manage different client types, request methods, portal actions, and server responses.
Global Variables:
- Global class holds key variables like username, password, client type, portal URL, and timestamps of login and acknowledgement.
Utility Functions:

-Credential Management: get_creds_from_json(path_to_json) reads the username and password from a JSON file.

-Connectivity Tests: gstatic_connect_test() and msft_connect_test() check if the internet is accessible.

-Captive Portal Detection: find_captive_portal() attempts to find and return the captive portal URL.

-Header and Payload Generation: header_generator() and payload_generator() generate HTTP headers and payloads for requests.

-WAN State Monitoring: is_wan_up() checks and logs changes in the WAN state.
Request Functions:

-GET and POST Requests: get_req(uni_host) and post_req(uni_host, portal_action) handle GET and POST requests to the portal.

-Server Response Parsing: parse_server_response(response) interprets the server’s response and updates global state variables accordingly.
Main Logic:

-Program Loop: program_loop() continuously checks the WAN state and attempts to login to the portal if the internet is down. It also sends acknowledgement requests periodically if the client is a desktop.
-Pause Menu: pause_menu() provides a user interface for actions like logging out, exiting, and changing the client type.

Usefulness Compared to Software:

1.Automation:
The script automatically handles login and maintains connectivity, unlike manual software methods.

def program_loop():
    while not exit_flag:
        if not Utility.is_wan_up():
            post_req(uni_host=portal_url, portal_action=Portal_action.LOGIN)

2.Customizability:
Easily adjustable for different portals by modifying headers, payloads, and URLs.

def header_generator(uni_host: str, payload_length: int, request_type: Request_type):
    headers = { 'Host': url_parse.hostname, 'User-Agent': Global.user_agent, ... }

3.Lightweight: Minimal dependencies and resources compared to GUI-based applications.

import requests, json, logging

4.Logging and Monitoring: Provides detailed logs and real-time status updates.

logging.basicConfig(level=logging.INFO, filename='app.log', ...)

5.Cross-Platform Compatibility: Runs on various operating systems using Python.

os.system('cls' if os.name == 'nt' else 'clear')