ajdevhub

Supercharge Your Static Site: Adding a Free, Real-Time CMS to GitHub Pages

2026-02-24T18:30:00+00:00

There is an undeniable beauty to static site generators like Jekyll, Hugo, and Next.js. They are incredibly fast, ridiculously secure, and can be hosted for completely free on GitHub Pages.

However, they all share one incredibly frustrating bottleneck: The Publishing Experience.

If you want to write a new blog post or add a new project to your portfolio, you typically have to open your IDE, create a new Markdown file, manually type out the YAML Front Matter exactly right, write your post in raw text, commit the file, and git push it to your repository. It is a tedious workflow, especially when you just want to fix a typo from your phone.

But what if you could have the speed and security of a Static GitHub Pages site, combined with the beautiful, rich-text dashboard of WordPress?

Enter Decap CMS (formerly Netlify CMS).

In this post, I am going to walk you through exactly how I added a completely free, database-less, real-time Content Management System to this very portfolio.

Architecture: How it Works

Because a GitHub Pages site is purely static HTML/CSS, you cannot run a traditional backend database. So, where does the CMS live?

Decap CMS is a “Headless CMS”. It is literally just a single HTML file and a Javascript bundle (admin/index.html) that lives in your repository. When you navigate to /admin, the React application boots up in your browser.

When you write a post and hit “Publish”, the CMS uses the GitHub API to literally write the Markdown file and commit it sequentially to your repository on your behalf. GitHub Pages detects the new commit, rebuilds your site automatically, and your blog is live in seconds.

Step 1: Bridge the Authentication (The Secret Sauce)

To allow the CMS to safely commit files to your GitHub repository without forcing you to memorize OAuth tokens, you need an Identity broker. The absolute easiest way to do this is to link your GitHub repository to Netlify.

[!NOTE] Your code still permanently lives on GitHub. Netlify is simply acting as the fast CDN host and the authentication broker.

Go to Netlify and create a free account.
Click Add new site -> Import an existing project -> Deploy with GitHub.
Select your Jekyll/Hugo repository and hit Deploy.

Step 2: Enable Git Gateway

Once your site is live on Netlify, we need to explicitly give it permission to edit your GitHub repository.

In your Netlify dashboard, go to Site settings > Identity (on the left menu).
Click the massive Enable Identity button.
Scroll further down that same page to Services > Git Gateway.
Click Enable Git Gateway.

This securely binds your Netlify Auth infrastructure directly to your GitHub repository structure.

Step 3: Scaffold the CMS Application

Now we inject the actual CMS into your repository. You only need to create two files. Create an admin folder at the root of your project.

1. `admin/index.html`

This is the React application payload. It loads the CMS and the Netlify Identity login widget.

[!WARNING] If you are accessing the /admin panel from your native github.io domain instead of the .netlify.app domain, you MUST supply your Netlify URL to the Identity widget during initialization, otherwise the login will fail due to cross-origin issues!

     charset="utf-8" />
     name="viewport" content="width=device-width, initial-scale=1.0" />
    </span>My Content Manager<span class="nt">

2. `admin/config.yml`

This file is the brain of the CMS. It tells Decap exactly what folders to look at (e.g., _posts) and what fields to generate in the dashboard UI. Notice that we set the backend to git-gateway.

backend:
  name: git-gateway
  branch: master # Update this to 'main' if that is your default branch

media_folder: "assets/images/posts"
public_folder: "/assets/images/posts"

collections:
  - name: "blog"
    label: "Blog Posts"
    folder: "_posts"
    create: true
    slug: "---"
    fields:
      - {label: "Layout", name: "layout", widget: "hidden", default: "post"}
      - {label: "Title", name: "title", widget: "string"}
      - {label: "Publish Date", name: "date", widget: "datetime"}
      - {label: "Categories", name: "categories", widget: "list", default: ["general"]}
      - {label: "Body", name: "body", widget: "markdown"}

Step 4: The Crucial Routing Fix

There is one major “Gotcha” that frustrated me during implementation.

To gain access to your shiny new CMS dashboard, you have to invite yourself via the Netlify Identity panel. Netlify will send you an email with a link that looks like this: yourwebsite.com/#invite=token123

The Problem: The email link usually drops you onto your homepage, not the /admin page. If your homepage doesn’t have the Netlify Identity script loaded, the website won’t know how to intercept that #invite= URL token! You’ll just see your normal site.

The Fix: You must inject the Identity script into your global layout template (usually _layouts/default.html) before the closing tag. Furthermore, if you are inviting users from the github.io domain, you must map the URL in the footer:

Now, no matter where the invite email links you, the Identity widget will catch the token and open the setup modal!

Step 5: Invite Yourself and Publish

Go back to your Netlify Dashboard and click the Identity tab at the top.
Click Invite Users and send an invite to your email.
Click the link in your email, set your password in the modal, and you are in!

Navigating to yourwebsite.com/admin/ will now greet you with a beautiful, rich-text WYSIWYG editor. You can drag and drop images, assign categories natively, and write your technical documentation naturally.

When you click “Publish”, the CMS handles the Git pipeline invisibly in the background. It is truly the ultimate blend of static-site performance and modern content management.

[!TIP] You can easily expand your admin/config.yml to define multiple collections. For example, I have a second collection mapping directly to my _projects repository to easily update my portfolio showcases!

Reconstructing Files from FTP Network Traffic: Understanding FTP, PCAP, and TCP Reassembly

2026-02-01T00:00:00+00:00

During a recent interview assignment, I was asked to design a system that could reconstruct a file transferred using FTP by analyzing raw network traffic. This task helped me understand how real-world file transfers work at the protocol level.

In this post, I’ll explain the core concepts behind FTP, Active and Passive modes, and how I used PCAP analysis and TCP reassembly to solve the problem.

What is FTP?

FTP (File Transfer Protocol) is one of the oldest protocols used to transfer files over a network.

It works on top of TCP and is mainly used to:

Upload files to servers
Download files from servers
Manage remote directories

FTP is simple, reliable, and still used in many legacy and internal systems.

However, traditional FTP does not encrypt data, which makes it useful for learning and traffic analysis.

Why is FTP Used?

FTP is used because:

It is easy to implement
It supports large file transfers
It works well over TCP
It is supported by almost all operating systems

In many internal networks and testing environments, FTP is still widely used.

For my assignment, FTP was chosen because it allows capturing raw file data from the network.

Two Connections in FTP

Unlike most protocols, FTP uses two TCP connections:

Connection Type	Purpose	Default Port
Control Channel	Commands and responses	21
Data Channel	File transfer	Dynamic

The control channel handles login and commands.
The data channel carries actual file bytes.

Understanding this separation is critical for packet analysis.

Passive FTP (PASV / EPSV Mode)

In Passive mode, the server opens a data port and tells the client where to connect.

Flow:

Client → Server (21)
Server → Client (PASV / EPSV response)
Client → Server (Data Port)

Examples

IPv4:

227 (192,168,1,5,32,144)

IPv6:

229 (|||49210|)

Why Passive Mode Exists

Passive FTP is widely used because:

It works behind firewalls
It works with NAT
It avoids incoming connections to clients

Most modern FTP clients use passive mode by default.

Active FTP (PORT / EPRT Mode)

In Active mode, the client opens a port and asks the server to connect.

Flow:

Client → Server (21)
Client → Server (PORT / EPRT)
Server → Client (Data Port)

Examples

IPv4:

PORT 192,168,1,5,32,144

IPv6:

EPRT |2|::1|8336|

Limitations of Active Mode

Active FTP often fails because:

Firewalls block incoming connections
NAT breaks address mapping

This is why Active mode is rarely used today.

Problem Statement of My Assignment

The assignment required me to:

Transfer a file using FTP
Capture traffic using tcpdump
Analyze the PCAP file
Extract raw bytes
Reconstruct the original file

The main challenge was handling multiple TCP packets and rebuilding the file correctly.

Understanding PCAP Files

A PCAP file stores raw network packets captured from an interface.

Each packet contains:

Link Layer Header
IP Header (IPv4 / IPv6)
TCP Header
Application Data

My program reads PCAP files using libpcap and extracts TCP payloads.

TCP Reassembly

TCP splits large data into small segments.

Packets may arrive:

Out of order
Duplicated
Delayed

So reconstruction requires:

Collecting all segments
Sorting by sequence number
Removing duplicates
Writing in correct order

This process is called TCP reassembly.

Handling IPv4 and IPv6

Originally, my implementation only supported IPv4.

Later, I upgraded it to support IPv6 by:

Detecting IP version
Parsing IPv6 headers
Supporting EPSV mode
Using unified IP address structures

This made the tool dual-stack compatible.

Tools and Technologies Used

Tool	Purpose
C++	Core implementation
libpcap	Packet parsing
tcpdump	Packet capture
Pure-FTPd	FTP server
CMake	Build system
Wireshark	Debugging

Key Learnings

Through this project, I learned:

How FTP works internally
Difference between Active and Passive modes
How TCP ensures reliability
How packet captures are structured
How to reconstruct application data from network traffic
How to design modular C++ systems

Conclusion

This assignment helped me move from using networking tools to understanding how they work internally.

Reconstructing a file from raw packets gave me hands-on experience with real-world networking and systems programming.

In future, I plan to extend this project with:

Active FTP support
Multi-session handling
Advanced retransmission recovery
Better CLI filters

← All Blogs Home 🏠

How to Create a New GitHub Repo and Push a Local Project

2026-01-18T00:00:00+00:00

How to Create a New GitHub Repo and Push a Local Project 🚀

When you start a new project locally (Java, DSA notes, website, etc.), the next step is usually to push it into GitHub. This guide explains the complete workflow to:

✅ Create a new GitHub repository
✅ Initialize Git in your local project
✅ Commit your code
✅ Push it to GitHub

This is a reusable step-by-step process you can follow for any future project.

Prerequisites

Before starting, make sure you have:

A GitHub account
Git installed on your system

Check Git installation:

git --version

Step 1: Create a New Repository on GitHub

Open GitHub and click ”+” → New repository
Enter a repository name
Example: JavaFoundry
Choose repo visibility:
- ✅ Public (recommended for portfolio)
- 🔒 Private (if needed)
Important: Do NOT check:
- “Add a README”
- “Add .gitignore”
- “Add license”

(We will create them locally.)

Click Create repository

GitHub will show the repo URL like:

HTTPS: https://github.com//.git
SSH: git@github.com:/.git

Step 2: Open Terminal in Your Local Project Folder

Navigate into your project folder:

cd path/to/your/project

Verify files:

ls

Step 3: Initialize Git in Your Local Folder

Run:

git init

Now your folder becomes a Git repository.

Step 4: Add a `.gitignore` File (Recommended)

A .gitignore tells Git what NOT to push to GitHub.

Create .gitignore:

touch .gitignore

For Java + IntelliJ projects, add:

# IntelliJ IDEA
.idea/
*.iml

# Java build output
out/
target/
*.class

# OS files
.DS_Store
Thumbs.db

Step 5: Stage Your Code

Stage everything:

git add .

Check status:

git status

Step 6: Commit Your Changes

Commit with a meaningful message:

git commit -m "Initial commit"

Step 7: Link Local Repo with GitHub Repo (Add Remote)

Add the GitHub remote:

✅ Using HTTPS

git remote add origin https://github.com//.git

Verify remote:

git remote -v

Step 8: Push Your Code to GitHub

Rename branch to main (GitHub standard):

git branch -M main

Push code:

git push -u origin main

✅ Done — your local project is now available on GitHub.

Step 9: Verify on GitHub

Go to your repo page and refresh. You should see:

all your files
latest commit message
branch main

Common Errors and Fixes

1) ❌ `remote origin already exists`

Fix:

git remote remove origin
git remote add origin https://github.com//.git

2) ❌ Authentication Failed (HTTPS)

GitHub no longer allows password authentication for git pushes.

✅ Fix options:

Use Personal Access Token (PAT) as password
OR use SSH
OR use GitHub Desktop (easy UI)

Recommended Workflow for Future Updates

Whenever you make changes:

git add .
git commit -m "Updated notes: Constructors + GC"
git push

Bonus: Best Repo Structure for Learning Projects

If you’re building a learning repo like JavaFoundry:

JavaFoundry/
├── src/
├── notes/
│   ├── constructors.md
│   ├── methods.md
│   └── memory-management-gc.md
├── diagrams/
│   └── *.puml
├── README.md
└── .gitignore

This makes your repo clean and scalable.

Summary

✅ Create repo on GitHub
✅ git init locally
✅ git add .
✅ git commit -m "..."
✅ git remote add origin
✅ git push -u origin main

← All Blogs Home 🏠

🇺🇸 Treasury Bond kya hota hai? India ne US Treasury holdings 2025 me 21% kyun kam ki?

2026-01-12T00:00:00+00:00

Bond kya hota hai? India ne US Treasury holdings 2025 me 21% kyun kam ki?

Aapne kabhi news me suna hoga:

“India ne US Treasury holdings 21% reduce ki.”

Lekin asli question ye hai 👇

✅ US Treasury hota kya hai?
✅ India apna paisa wahan kyun rakhta hai?
✅ Aur 2025 me cut kyun kiya?

Chaliye isko ekdum asaan language me samajhte hain.

✅ Quick Summary (30 sec read)

📌 Treasury bond = US government ko loan
📌 India (RBI) apne Forex Reserves ka part US Treasury me invest karta hai
📌 2025 me India ki holdings ~$241.4B se ~$190.7B ho gayi (~21% down)
📌 Main reason: Diversification + risk management (gold / non-dollar assets)

1️⃣ Treasury Bond ka matlab kya hota hai? 💵

Treasury Bond (T-Bond) = Government ka loan instrument

Jab government ko paise chahiye hote hain, wo public/institutions se udhaar leti hai, aur uske badle bond deti hai.

Simple example:

Government: “Mujhe ₹10,000 udhaar do 10 saal ke liye. Main har saal interest dungi, aur maturity par ₹10,000 wapas kar dungi.”

✅ Interest = Coupon
✅ Return date = Maturity

2️⃣ T-Bill vs Treasury Bond 🧾

Feature	T-Bill	Treasury Bond
Duration	Short term (<= 1 year)	Long term (1+ years)
Interest	Coupon nahi hota	Regular coupon interest
Return	Discount based	Coupon + maturity value

📌 Easy line:

✅ T-Bill = short term parking
✅ Bond = long term stable income

3️⃣ Interest rate aur bond price ulta kyun chalta hai? 📉📈

Golden rule:

📌 Interest rate badhta hai → old bond ka price girta hai
📌 Interest rate ghatta hai → old bond ka price badhta hai

🔥 Example (super simple)

Maan lo aapke paas old bond hai:

Face value: ₹1000
Coupon: 7% → yearly ₹70

Ab new bonds market me 10% dene lage:

New bond yield: 10% → yearly ₹100

Investor kya sochega?

“Old bond (₹70) kyu loon jab new bond (₹100) mil raha?”

Toh old bond sell karne ke liye uska price cheap hona padega.

✅ Isliye: Rates ↑ → Old Bond price ↓

Reverse case:

Agar market rate 7% ho gaya aur old bond 10% de raha, toh old bond valuable ban jaata hai → price badhta hai.

✅ Isliye: Rates ↓ → Old Bond price ↑

💡 Callout: Bond me coupon fixed hota hai, market rates change hote rehte hain. Isi wajah se bond ka price ulta chalta hai.

4️⃣ India US Treasuries kyun buy karta hai? 🇮🇳💰🇺🇸

India ke paas Forex Reserves hote hain — matlab foreign currency savings.

Forex reserves ka use:

INR stability maintain karna
Imports & global payments
Crisis buffer
Global confidence

RBI forex reserves ko safe + liquid assets me invest karta hai.

✅ US Treasuries popular isliye:

Very safe
Highly liquid (jaldi bech sakte)
USD global currency hai

5️⃣ RBI Forex Reserves ka breakdown 🍰

Forex reserves mainly 4 parts:

Foreign Currency Assets (FCA) – sabse bada part
Gold
SDR (IMF asset)
IMF reserve position

👉 US Treasuries FCA ke andar aate hain.

6️⃣ News analysis: India ne 2025 me 21% holdings kyun kam ki? 📰

News ke according:

Oct 2024: ~$241.4B
Oct 2025: ~$190.7B
➡️ ~21% reduction

Iska matlab?

❌ Ye “trust issue” nahi hai
✅ Ye “portfolio optimization / diversification” hai

7️⃣ Major reasons (simple analysis) 🧠

✅ Reason 1: Diversification

RBI sirf US assets pe dependent nahi rehna chahta:

Gold badhana
Other currencies/assets badhana

✅ Reason 2: Dollar weaken risk

Agar USD weaken hota hai toh return impact ho sakta hai. Isliye RBI balance karta hai.

✅ Reason 3: Fed rate cycle

US rates/yields change hote rehte hain. RBI apna duration risk / allocation adjust karta hai.

✅ Reason 4: Global uncertainty

Geopolitical uncertainty badhne par central banks apne reserves ka structure rethink karte hain.

8️⃣ Iska INR/USD pe kya impact? 💱

Immediate direct impact usually small hota hai, because RBI actively manage karta hai.

But indirectly:

Reserves flexible ban jaate hain
Currency intervention easier ho sakta hai
Risk hedging better hoti hai

✅ Key Takeaways (1-minute recap)

Treasury bond = government ko loan
T-Bill = short term, discount based
Interest rate ↑ ⇒ old bond price ↓
Interest rate ↓ ⇒ old bond price ↑
RBI forex reserves me US Treasuries important asset hain
India ne holdings reduce ki: main reason diversification + risk management

FAQs ❓

Q1. Treasury bond safe hota hai?

Haan, generally world ka safest asset category me count hota hai.

Q2. T-Bill aur bond me key difference?

T-bill short term hota hai aur discount return deta hai; bond long term hota hai aur coupon deta hai.

Q3. Kya India US se distance bana raha hai?

Nahi. Ye exit nahi hai — diversification strategy hai.

Q4. Bond price rate ke opposite kyu hota?

Coupon fixed hota, market rate change hota — isliye price adjust hota.

✍️ Final line

India ne US Treasury holdings reduce kiye because RBI apne forex reserves ko “more diversified & future-proof” banana chahta hai.

Ye ek healthy financial strategy hai, trust issue nahi! 💪

💡 Pro Tip: Treasury bonds aur forex reserves ki understanding aapko global economy ke patterns samajhne me help karti hai. Next time jab bhi "Treasury yields" ya "Fed rates" news me aaye, aap context samajh paoge!

← All Blogs Home 🏠

DevToolBox: A Comprehensive Network Packet Analysis Suite

2025-12-31T00:00:00+00:00

Introduction

As a developer working with network protocols and data plane technologies, I found myself repeatedly needing tools to analyze packet captures, generate test data, and inspect binary files. Rather than switching between multiple tools, I built DevToolBox — a unified web-based suite that brings together four essential utilities in one place.

🔗 GitHub Repository

🎯 The Problem Space

Network engineers and developers often face these challenges:

PCAP Analysis — Need to read, modify, and understand network packet captures
Test Data Generation — Creating realistic PCAP files for testing network protocols
Binary Inspection — Analyzing firmware, protocol payloads, and unknown binary files
Capture Management — Merging multiple PCAP files from different sources

Existing tools are either:

Command-line based (steep learning curve)
Desktop applications (platform-specific)
Limited to single functionality
Expensive commercial software

DevToolBox addresses this gap with a modern, web-based interface that’s accessible, intuitive, and completely free.

🛠️ The Four Core Tools

1. PCAP Editor

The PCAP Editor lets you upload and analyze PCAP/PCAPNG files with detailed packet information:

Protocol Breakdown — View TCP, UDP, ICMP, DNS, HTTP, TLS packets
Field Modification — Edit MAC addresses, IP addresses, ports, VLAN IDs
Application Layer Editing — Modify HTTP Host headers, TLS SNI fields, DNS queries
Automatic Checksums — Recalculates IP and TCP checksums automatically
Download Modified Captures — Export your changes as new PCAP files

Use Cases:

Protocol testing and debugging
Security research and forensics
Network simulation
Anonymizing packet captures

2. PCAP Generator

Create synthetic PCAP files with complete TCP 3-way handshake flows:

Multiple Protocols — TCP, HTTP, UDP, DNS (UDP/TCP), TLS
Realistic Flows — Full TCP lifecycle: SYN → SYN-ACK → ACK → Data → FIN-ACK
Incremental IPs — Generates unique flows with auto-incrementing destination IPs
VLAN Support — Add VLAN tagging for enterprise network simulation
Custom Configuration — Configure MAC addresses, IPs, ports, packet counts

Use Cases:

Creating test datasets
Load testing network equipment
Protocol implementation testing
Network simulation scenarios

3. PCAP Merger

Combine multiple PCAP/PCAPNG files into a single capture:

Preserve Timing — Maintains original packet timestamps
Maintain Order — Keeps chronological packet sequence
Multi-Format Support — Works with PCAP and PCAPNG formats
Automatic Statistics — Shows packet counts from merged files

Use Cases:

Consolidating forensics data
Merging test captures
Combining multi-interface captures
Creating comprehensive datasets

4. Hex Viewer

Upload any binary file and view it with dual modes:

Text View — Human-readable text with auto-detected encoding (UTF-8, ASCII, Latin-1, UTF-16, UTF-32)
Hex View — Traditional hex dump with ASCII representation
Format Detection — Automatically identifies JSON, XML, Plain Text, Binary
Pattern Search — Search by hex pattern or ASCII text
Pagination — Handle large files efficiently
Export Options — Copy to clipboard or export as hex dump

Use Cases:

Firmware analysis
Protocol reverse engineering
File forensics
Unknown file format inspection

🏗️ Technical Architecture

Backend: Python + Flask + Scapy

The backend is built with:

Flask — Lightweight REST API server
Scapy — Powerful Python library for packet manipulation
File Handling — Secure upload/download with size limits

Key modules:

app.py — Flask API endpoints
pcap_handler.py — PCAP processing logic
utils.py — Helper functions for encoding/checksums

Frontend: Vue.js 3 + Vite

The frontend features:

Vue.js 3 — Modern reactive framework
Vite — Fast development and build tool
Axios — HTTP client for API calls
Component Architecture — Separate views for each tool

Key components:

Home.vue — Landing page with tool navigation
PCAPEditor.vue — Editor interface
PCAPGenerator.vue — Generator form
PCAPMerger.vue — Merger interface
HexViewer.vue — Hex/text viewer

Communication Flow

User → Vue.js Frontend → Axios HTTP → Flask Backend → Scapy Processing → Response → Display

🚀 Key Features & Implementation

Automatic Checksum Recalculation

When modifying packet fields (IPs, ports), checksums must be updated:

# Delete old checksums
del packet[IP].chksum
del packet[TCP].chksum

# Scapy automatically recalculates on packet serialization

Complete TCP Flow Generation

Generating realistic TCP flows requires proper state handling:

SYN — Client initiates connection
SYN-ACK — Server responds
ACK — Client acknowledges
PSH-ACK — Data transmission
FIN-ACK — Connection termination

Each packet has proper sequence and acknowledgment numbers.

Multi-Format PCAP Support

Using Scapy’s rdpcap() and wrpcap() functions:

Automatically detects PCAP vs PCAPNG
Preserves timestamp precision
Handles both formats seamlessly

Hex Viewer Encoding Detection

The hex viewer tries multiple encodings:

encodings = ['utf-8', 'ascii', 'latin-1', 'utf-16', 'utf-32']
for encoding in encodings:
    try:
        text = data.decode(encoding)
        return text, encoding
    except UnicodeDecodeError:
        continue

📊 Performance Considerations

File Size Limits — Default 100MB, configurable up to 500MB
Pagination — Large files displayed in chunks
Incremental Processing — Packets processed one at a time
Client-Side Rendering — Vue.js handles DOM updates efficiently

🔧 Quick Start

# Clone repository
git clone https://github.com/Ajay3007/devtoolbox.git
cd devtoolbox

# Backend setup (Terminal 1)
python -m venv .venv
.venv\Scripts\activate  # Windows
pip install -r backend/requirements.txt
python backend/app.py

# Frontend setup (Terminal 2)
cd frontend
npm install
npm run dev

Visit http://localhost:8080 and start analyzing!

🎓 Real-World Use Cases

Network Forensics

Analyze suspicious traffic captures from IDS/IPS systems, modify timestamps for timeline analysis, and extract specific protocols for detailed inspection.

Protocol Testing

Generate synthetic traffic to test protocol implementations, verify state machine handling, and stress-test network equipment.

Security Research

Modify packet fields to test security controls, create proof-of-concept exploits in controlled environments, and analyze malware network behavior.

Education

Learn about network protocols by inspecting real packet captures, understand TCP 3-way handshake with visual flows, and practice protocol analysis.

🔮 Future Enhancements

Packet Filtering — Filter by protocol, IP, port, or custom expressions
Statistics Dashboard — Visual graphs for protocol distribution, bandwidth usage
Batch Operations — Modify multiple packets simultaneously
Protocol Dissectors — Deep inspection for more application protocols
Live Capture — Real-time packet capture from network interfaces
Export Formats — Support for CSV, JSON exports of packet data

📝 Lessons Learned

1. Scapy is Powerful but Complex

Scapy’s flexibility comes with a learning curve. Understanding packet layers and field manipulation required extensive documentation reading.

2. Checksum Handling

Automatic checksum recalculation works well, but edge cases (like tunneled packets) need special handling.

3. File Upload Security

Always validate file types, limit file sizes, and sanitize filenames to prevent security issues.

4. Frontend-Backend Separation

Using Vue.js + Flask allows independent development and easier testing of both layers.

🎯 Conclusion

DevToolBox started as a personal need and evolved into a comprehensive toolkit for network analysis. By combining multiple utilities in a single web interface, it simplifies workflows for network engineers, security researchers, and developers.

The project demonstrates:

Practical application of data plane concepts
System design for web-based tools
Integration of Python packet processing with modern JavaScript frameworks

Whether you’re debugging network issues, generating test data, or learning about protocols, DevToolBox provides an accessible, powerful solution.

Try it out: GitHub - Ajay3007/devtoolbox

Built with 💻 by Ajay — Exploring the intersection of networking, data plane, and software engineering.

← All Blogs Home 🏠

Two Pointer Technique Explained

2025-01-05T00:00:00+00:00

What is the Two Pointer Technique?

The Two Pointer Technique is a common algorithmic approach where we use two indices (pointers) to traverse a data structure like an array or string.

It is widely used in:

DSA
Algorithms
Competitive Programming

Why use Two Pointers?

Reduces time complexity
Avoids unnecessary nested loops
Makes solutions cleaner and faster

Example Problem

Problem:
Check if there exists a pair in a sorted array whose sum is equal to X.

Approach

One pointer at the start
One pointer at the end
Move pointers based on the current sum

Sample Code (C++)

#include 
using namespace std;

bool hasPairWithSum(vector<int>& arr, int x) {
    int left = 0, right = arr.size() - 1;

    while (left < right) {
        int sum = arr[left] + arr[right];
        if (sum == x) return true;
        else if (sum < x) left++;
        else right--;
    }
    return false;
}

← All Blogs Home 🏠

ajdevhub

Supercharge Your Static Site: Adding a Free, Real-Time CMS to GitHub Pages

Architecture: How it Works

Step 1: Bridge the Authentication (The Secret Sauce)

Step 2: Enable Git Gateway

Step 3: Scaffold the CMS Application

1. admin/index.html

2. admin/config.yml

Step 4: The Crucial Routing Fix

Step 5: Invite Yourself and Publish

Reconstructing Files from FTP Network Traffic: Understanding FTP, PCAP, and TCP Reassembly

What is FTP?

Why is FTP Used?

Two Connections in FTP

Passive FTP (PASV / EPSV Mode)

Flow:

Examples

Why Passive Mode Exists

Active FTP (PORT / EPRT Mode)

Flow:

Examples

Limitations of Active Mode

Problem Statement of My Assignment

Understanding PCAP Files

TCP Reassembly

Handling IPv4 and IPv6

Tools and Technologies Used

Key Learnings

Conclusion

How to Create a New GitHub Repo and Push a Local Project

How to Create a New GitHub Repo and Push a Local Project 🚀

Prerequisites

Step 1: Create a New Repository on GitHub

Step 2: Open Terminal in Your Local Project Folder

Step 3: Initialize Git in Your Local Folder

Step 4: Add a .gitignore File (Recommended)

Step 5: Stage Your Code

Step 6: Commit Your Changes

Step 7: Link Local Repo with GitHub Repo (Add Remote)

✅ Using HTTPS

Step 8: Push Your Code to GitHub

Step 9: Verify on GitHub

Common Errors and Fixes

1) ❌ remote origin already exists

2) ❌ Authentication Failed (HTTPS)

Recommended Workflow for Future Updates

Bonus: Best Repo Structure for Learning Projects

Summary

🇺🇸 Treasury Bond kya hota hai? India ne US Treasury holdings 2025 me 21% kyun kam ki?

Bond kya hota hai? India ne US Treasury holdings 2025 me 21% kyun kam ki?

✅ Quick Summary (30 sec read)

1️⃣ Treasury Bond ka matlab kya hota hai? 💵

Simple example:

2️⃣ T-Bill vs Treasury Bond 🧾

📌 Easy line:

3️⃣ Interest rate aur bond price ulta kyun chalta hai? 📉📈

Golden rule:

🔥 Example (super simple)

Reverse case:

4️⃣ India US Treasuries kyun buy karta hai? 🇮🇳💰🇺🇸

Forex reserves ka use:

✅ US Treasuries popular isliye:

5️⃣ RBI Forex Reserves ka breakdown 🍰

6️⃣ News analysis: India ne 2025 me 21% holdings kyun kam ki? 📰

Iska matlab?

7️⃣ Major reasons (simple analysis) 🧠

✅ Reason 1: Diversification

✅ Reason 2: Dollar weaken risk

✅ Reason 3: Fed rate cycle

✅ Reason 4: Global uncertainty

8️⃣ Iska INR/USD pe kya impact? 💱

But indirectly:

✅ Key Takeaways (1-minute recap)

FAQs ❓

Q1. Treasury bond safe hota hai?

Q2. T-Bill aur bond me key difference?

Q3. Kya India US se distance bana raha hai?

Q4. Bond price rate ke opposite kyu hota?

✍️ Final line

DevToolBox: A Comprehensive Network Packet Analysis Suite

1. `admin/index.html`

2. `admin/config.yml`

Step 4: Add a `.gitignore` File (Recommended)

1) ❌ `remote origin already exists`