Forem: Janak bista

Building a Linux Server From Scratch

Janak bista — Mon, 13 Apr 2026 20:27:59 +0000

Setting up a Linux server from scratch is one of the most valuable skills in system administration, DevOps, and cybersecurity. It helps you understand how servers actually work under the hood instead of relying on managed services.

In this guide, I’ll walk through how to build a basic Linux server, configure it, and make it ready for real-world use.

Why Build Your Own Linux Server?

A self-built Linux server helps you:

Understand system internals (users, permissions, services)
Host applications (web apps, APIs, databases)
Practice DevOps skills
Prepare for cybersecurity labs
Gain full control over your environment

Step 1: Choose Your Linux Distribution

For servers, the most common choices are:

Ubuntu Server (beginner-friendly)
Debian (stable and lightweight)
CentOS / Rocky Linux (enterprise-style systems)

In this guide, we will install Ubuntu Server.

Step 2: Install Linux Server

Get Ubuntu Server from:

Download ISO:Install:

Use VirtualBox, VMware, or physical machine
Select:
Minimal installation
OpenSSH server (IMPORTANT)

Step 3: Configure Network

Check IP address:

ip a

Test internet:

ping google.com

Update system:

sudo apt update && sudo apt upgrade -y

Step 4: Secure Your Server
Create a new user:

sudo adduser user1

Give sudo access:

sudo usermod -aG sudo user1

Enable SSH access

Install SSH (if not installed):

sudo apt install openssh-server -y

Check SSH status:

sudo systemctl status ssh

Change SSH port (basic security step)

sudo nano /etc/ssh/sshd_config

Change:

Port 22 → Port 2222

Restart SSH:

sudo systemctl restart ssh

Step 5: Configure Firewall (UFW)

Enable firewall:

sudo ufw enable

Allow SSH:

sudo ufw allow 2222/tcp

Check status:

sudo ufw status

Step 6: Install a Web Server (Optional but Common)
Install Nginx:

sudo apt install nginx -y

Start service:

sudo systemctl start nginx

Enable on boot:

sudo systemctl enable nginx

Test:

http://your-server-ip

Step 7: Install Database (Optional)
MySQL:

sudo apt install mysql-server -y

Secure installation:

sudo mysql_secure_installation

Step 8: Install Developer Tools

sudo apt install git curl wget unzip -y

Step 9: Monitor Server

Check system usage:

top

Disk usage:

df -h

Memory usage:

free -h

Step 10: Final Test

Try accessing your server:

SSH login:
ssh user1@your-server-ip -p 2222
Open browser:
http://your-server-ip

🚀 What You have:

A secure Linux server
SSH access configured
Firewall protection
Optional web server and database
Basic monitoring tools

Sherlock for Digital Forensics & Reconnaissance (OSINT Guide)

Janak bista — Mon, 13 Apr 2026 20:16:19 +0000

In cybersecurity one of the first steps in an investigation is Open Source Intelligence (OSINT) gathering. OSINT helps analysts understand a target’s digital footprint using publicly available information.

One of the most powerful OSINT tools for username reconnaissance is Sherlock.

🔍 What is Sherlock?

Sherlock is a Python-based OSINT tool that allows you to search for a username across hundreds of social media platforms.

It helps investigators:

Identify where a username exists online
Map digital footprints across platforms
Support forensic investigations and threat intelligence
Perform ethical reconnaissance in cybersecurity labs

⚙️ Installation

Clone the repository

git clone https://github.com/sherlock-project/sherlock.git

Navigate into the directory

cd sherlock

Install dependencies

pip3 install -r requirements.txt

🚀 Basic Usage
🔎 Search a username across platforms

python3 sherlock username123

💾 Save results to a file

python3 sherlock username123 --output results.txt

📁 Save results in JSON format (useful for analysis)

python3 sherlock username123 --output results.json --json

How Koin works

Janak bista — Mon, 26 Sep 2022 04:41:27 +0000

Koin woks on simple domain specific language(DSL) model, a computer languages created for specific application domain.

In koin we have to create a module first .In this module all the dependent objects are there, then we have to load one or more modules in to koin in application class by calling start koin method. Then we can inject object wherever we want.

Here are the key term

get(): It is used inside constructors to resolve needed instances.
factory : It is used to indicate a new instance must be created
each time it is injected.
single :It indicates that a unique instance will be created at
the beginning and shared on every future injection.
name : It is used to name definition . This is required when we want to have multiple instances of the same class with different types

Interceptors

Janak bista — Thu, 22 Sep 2022 04:54:51 +0000

Interceptors are the powerful mechanism that can monitor, rewrite, and retry API call.

We need to add a logger for each network call ,but by using interceptor we can add a logger once and it will work for each network calls.

Another use-case is caching the response of network calls to build an offline-first app.

Interceptors are of two types :

Interceptors added between the Application Code (our written code) and the OkHttp Core Library are referred to as application interceptors. These are the interceptors that we add with addInterceptor().
Interceptors on the network: These are interceptors placed between the OkHttp Core Library and the server. These can be added to OkHttpClient by using the addNetworkInterceptor command ().

Here’s a simple interceptor that logs the outgoing request and the incoming response.

class LoggingInterceptor implements Interceptor {
  @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();
    logger.info(String.format("Sending request %s on %s%n%s",
        request.url(), chain.connection(), request.headers()));

    Response response = chain.proceed(request);

    long t2 = System.nanoTime();
    logger.info(String.format("Received response for %s in %.1fms%n%s",
        response.request().url(), (t2 - t1) / 1e6d, response.headers()));

    return response;
  }
}

**
We can add interceptor while building the OkHttpRequest object as follows :**

fun gfgHttpClient(): OkHttpClient {
    val builder = OkHttpClient().newBuilder()
        .addInterceptor(/*our interceptor*/)
    return builder.build()
}

Keeping the response in the cache

If we want to cache the API call response so that when we call the API again, the response will come from Cache. If we have an API call from Client to Server and the Cache-Control header is enabled on the server, OkHttp Core will respect that header and cache the response that was sent from the server for a certain amount of time.

Work Manager Android

Janak bista — Sat, 17 Sep 2022 04:07:13 +0000

Work manager handles the scheduled tasks that can run even if app exits or device restart.

In simple we can say ,Run background jobs using work manager.

For example : sync data from server.

Explanation :

suppose, we have a news app and every 2 hours we goes to server and check whether there is new updated news or not. If there any lets notify the users that new updated news .This is done with the help of work manager.

Scoped Function in Kotlin

Janak bista — Sat, 17 Sep 2022 03:53:38 +0000

There are five scope functions in kotlin : let, run ,with ,also & apply.

let: It takes object it is invoked upon as the parameter & return the result of the lambda expression.let is used for checking nullable property. Syntax : var name : String? = "Hello" name?.let{println(it)}

For Example :

fun PerformOperation() {
val name:String = "Ram"
val person = Person.let {
return "Name: ${it.name}"
}
print(person)

}

Output : Ram

2.also :
It does some additional processing on object it was involked
unlike let object. but returns original object instead of new
return data.

3.run :
It is similar to let function .It returns the last statement .It does not contain 'it' keyword.

4.with :
It is just like run operator .It refers context of the object.

Kotlin Flows On android

Janak bista — Sat, 17 Sep 2022 03:44:20 +0000

In Coroutines, a Flow is a type that can emit multiple values sequentially as opposed to suspend functions that return only a single value.

For Example : we can use Flow to receive live updates from database.

Flows are built on top of coroutines and can produce multiple values.

A flow is conceptually a stream of data that can be computed asynchronously. The emitted values must be of the same type. For example, a Flow<Int> is a flow that emits integer values.

Extension Function

Janak bista — Thu, 15 Sep 2022 14:50:52 +0000

Kotlin gives the programmer the ability to add more functionality to the existing classes, without inheriting them.

This is achieved through a feature known as extensions.

When a function is added to an existing class it is known as Extension Function.

To add an extension function to a class, define a new function appended to the class name.

For Example :

fun main() {
 val list = mutableListOf(1,2,3,4)
 list.swap(0,2)
 print(list)
}
fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // 'this' corresponds to the list
    this[index1] = this[index2]
    this[index2] = tmp

}

Output : [3,2,1,4]

Kotlin Flows On android

Janak bista — Thu, 15 Sep 2022 14:42:15 +0000

In Coroutines, a Flow is a type that can emit multiple values sequentially as opposed to suspend functions that return only a single value.

For Example : we can use Flow to receive live updates from database.

Flows are built on top of coroutines and can produce multiple values.

A flow is conceptually a stream of data that can be computed asynchronously. The emitted values must be of the same type. For example, a Flow<Int> is a flow that emits integer values.

Coroutines

Janak bista — Tue, 13 Sep 2022 14:30:43 +0000

A coroutine is a concurrency design pattern that we can use on Android to simplify code that executes asynchronously. Coroutines were added to Kotlin in version 1.3 and are based on established concepts from other languages.

On Android, coroutines help to manage long-running tasks that might otherwise block the main thread and cause your app to become unresponsive. Over 50% of professional developers who use coroutines have reported seeing increased productivity.

Features : Lightweight , fewer leakage ,jetpack Integration.

Based on the Guide to app architecture, the examples in this topic make a network request and return the result to the main thread, where the app can then display the result to the user.

Specifically, the ViewModel Architecture component calls the repository layer on the main thread to trigger the network request. This guide iterates through various solutions that use coroutines keep the main thread unblocked.

ViewModel includes a set of KTX extensions that work directly with coroutines.

Hilt Dependency Injection

Janak bista — Tue, 13 Sep 2022 14:23:32 +0000

Hilt is a dependency injection library for Android that reduces the boilerplate of doing manual dependency injection.

Doing manual dependency injection requires to construct every class and its dependencies by hand, and to use containers to reuse and manage dependencies.

Hilt provides a standard way to use DI in your application by providing containers for every Android class in your project and managing their lifecycles automatically.

var a = "string"

Hilt is built on top of the popular DI library Dagger to benefit from the compile-time correctness, runtime performance, scalability, and Android Studio support that Dagger provides. For more information, see Hilt and Dagger.

1.RecyclerView in kotlin

Janak bista — Thu, 08 Sep 2022 15:30:36 +0000

1.First we have to add dependency in build.gradle of app or module Folder .

dependencies {
implementation 'androidx.recyclerview:recyclerview:1.2.0'
}

2.Then we have to use RecyclerView Widget from androidx.widget.recyclerview.

3.Create RecyclerView items .
4.Make Adapter class to inflate Recycler items.
5.Then set Adapter on the required screen.