DEV Community: Wahyu K. A.

🔄 Introducing Galus: A Lightweight and Blazing-Fast Live Reload Tool for Go Developers

Wahyu K. A. — Sat, 26 Jul 2025 09:49:45 +0000

⚡ Sick of slow build times with Air or CompileDaemon? Meet Galus — your new best friend for rapid Go development.

👋 Hey, fellow Gophers!

If you’ve built REST APIs in Go using frameworks like Gin, Chi, or Fiber, you probably rely on live reload tools to avoid rebuilding your server manually every time you save a file.

The usual suspects?
🧊 Air
⚙️ CompileDaemon

Both are awesome. I’ve used them extensively.
But here's the catch — as my projects grew, so did the wait time.

Every. Single. Save.

I was spending more time waiting for builds than actually coding. And let’s be real — ain’t nobody got time for that.

So I decided to build my own tool.
And thus, Galus was born.

🧠 Why I Built Galus

I hit that breaking point where I just wanted something:

Lightweight 🪶
Fast as hell ⚡
Easy to set up 🛠️

🌀 Galus = Golang Auto Live Update System

🔧 What Makes Galus Different?

✅ No fuss setup — just run galus init and you're good to go.
✅ Insanely fast builds — even on large, complex projects.
✅ Automatic rebuild + restart — zero config watching.
✅ Built with Go developers in mind — minimal overhead, no bloated features.

The goal is simple:
Make your dev loop feel instant, again.

🚀 Getting Started

Install Galus

go get github.com/aliftech/galus

Install the binary to make galus available globally

go install github.com/aliftech/galus

Initialize in your project:

galus init

Run:

galus

That’s it. Galus will handle the rest.

🗺️ Roadmap

Galus is still early-stage, but I’ve got a roadmap full of features I’m actively working on:

🧪 Custom build commands
🌈 Color-coded logs
🔀 Plugin support for advanced workflows
🛡️ Better error handling & recovery

Want to contribute?
Jump in 👉 github.com/aliftech/galus

🧠 I Need Your Feedback!

This is where you come in.

If you:

Have ever been frustrated with live reload tools...
Want something faster, simpler, and more Go-centric...
Like experimenting with new dev tools...

Then please give Galus a spin and let me know what you think.

💬 Let’s Chat

What live reload tool do you use today — and why?
What feature is absolutely essential in your dev workflow?
Have you tried Galus? How was it?

Hit me up in the comments or on GitHub — I’d love to collaborate with fellow Gophers.

🌟 If You Like It, Star It!

If Galus helps you, even just a little, consider giving it a ⭐ on GitHub. It helps a ton!

👉 github.com/aliftech/galus

Let’s make Go dev faster, together. 💪

Jin: A Passive OSINT & Recon CLI Toolkit Built with Go

Wahyu K. A. — Sat, 22 Jun 2024 14:32:25 +0000

Disclaimer: This article describes a tool intended for ethical, educational, and authorized security work. Only use it against targets you own or have explicit permission to test. Unauthorized scanning is illegal in most jurisdictions.

When you start a security assessment — bug bounty, penetration test, or even just hardening your own infrastructure — the first thing you reach for is reconnaissance. You want answers to questions like:

What is this server actually running?
Which ports are exposed to the internet?
Is that WordPress install behind a CDN? Which framework is it using?
Are there subdomains I don't know about?

There are many tools that answer each of these questions. But most of them are heavyweight, require lots of setup, or spread the answers across multiple utilities with different output formats.

Jin is a single Go binary that answers all of them — with a friendly interactive shell, clean human-readable output, and JSON mode for scripting. Let me show you what it does and why I think it earns a spot in your toolkit.

What is Jin?

Jin (Just Intelligence Network) is an open-source, passive-first OSINT and reconnaissance CLI toolkit. It's an evolution of a Python project that focused on ethical port scanning, rewritten in Go and redesigned around a clean, testable architecture.

The current version ships three commands, all usable interactively or as one-shot commands:

Command	What it does
`info`	Full server reconnaissance: headers, TLS, cloud provider, plus an automated security score
`ports`	TCP connect scan for open ports, with service detection
`tech-stack`	Fingerprints the tech stack (CMS, frameworks, CDN, WAF...) with confidence levels and evidence
`tech-stack --subdomains`	Also discovers subdomains from certificate transparency logs and pulls DNS records

Every command has a --json flag for structured output, so you can pipe results into other tools or CI pipelines.

Why Go?

The original version of Jin was written in Python. The rewrite in Go brings some serious quality-of-life improvements:

One static binary — no runtime, no virtualenv, no dependency headaches. Copy it to a box and it works.
Fast startup — a scan kicks off in milliseconds, which matters a lot in an interactive REPL.
Goroutines for concurrency — subdomain discovery and fingerprinting run in parallel.
Small container footprint — the Docker image is Alpine-based and statically linked.
Clean architecture — the codebase uses hexagonal (ports & adapters) design, which makes the tool easy to extend with new scanners without touching the domain logic.

The three commands

Let's walk through each command with real output shapes.

1. `info` — full server reconnaissance

Point Jin at any URL and it fetches the response, extracts the interesting headers, detects the cloud provider, and — my favorite part — produces a weighted security report with a letter grade:

🌐 URL:          https://example.com
🗃️  Base Domain:  example.com
☁️  Cloud:        Cloudflare
✅ Status:       200
🖥️  Server:      cloudflare
📄 Content-Type: text/html; charset=UTF-8
⏱️  Scan Time:   423ms

🔒 TLS Version:  TLS 1.3
🔐 Cipher Suite: TLS_AES_128_GCM_SHA256

🛡️  Security Insights: B+ (82/100)
  ✅ TLS:                       Serving over TLS 1.3
  ⚠️  HSTS:                     Missing Strict-Transport-Security header
  ✅ Content-Security-Policy:   Policy enforced
  ✅ X-Frame-Options:           Clickjacking protection enforced
  ✅ X-Content-Type-Options:    nosniff set
  ✅ Referrer-Policy:           Set to strict-origin-when-cross-origin
  ℹ️  Permissions-Policy:        Not set
  ✅ Cookie Flags:              No obvious cookie issues
  ✅ CORS:                      Restricted to: https://app.example.com
  ✅ Version Disclosure:        No version numbers exposed in Server/X-Powered-By

📋 Headers:
  cache-control:       max-age=0, private, must-revalidate
  content-encoding:    br
  content-security-policy: default-src 'self'; ...
  set-cookie:          __cf_bm=<redacted> [Secure, HttpOnly, SameSite=None]
  ...

The security checks cover the OWASP-relevant quick wins: TLS, HSTS, Content-Security-Policy (including a linter that flags unsafe-inline, unsafe-eval, and overly broad sources), X-Frame-Options, nosniff, Referrer-Policy, Permissions-Policy, cookie flags (Secure / HttpOnly / SameSite), CORS misconfigurations (like * combined with credentials=true), and version disclosure in headers.

Each check has a weight, so the final score is a genuine 0–100 weighted grade (A+ down to F) — not just a checklist. Notice the set-cookie header above: cookie values are redacted in output while security-relevant attributes are preserved, because you don't want to leak a real session token into a report.

You can also run jin https://example.com directly — a bare URL is treated as an info scan.

2. `ports` — TCP connect scan

Jin scans a curated default list of common services, or your own:

🔍 Open ports:
  22/ssh
  80/http
  443/https
  5432/postgresql

jin ports -t example.com -p 80,443,8080,8443

Default ports include FTP, SSH, SMTP, DNS, HTTP(S), mail, MySQL, PostgreSQL, Redis, and MongoDB — and you can pass a comma-separated custom list with -p. Each port is mapped to its service name, and output is clean enough to grep or script against.

3. `tech-stack` — fingerprinting, subdomains & DNS

This is the most fun one. Jin fingerprints a target across 13 categories — CMS, web server, backend runtime, programming language, web framework, JS framework, JS library, CSS framework, WAF/reverse proxy, analytics, CDN, security, and other:

🧩 Stack:  WordPress, Nginx, PHP, jQuery, Cloudflare
⏱️  Scan Time: 1.2s

▸ CMS
  WordPress (6.5.2)          High (80%)
    • Meta tag: generator=WordPress 6.5.2
▸ Web Server
  Nginx                      Very High (97%)
    • Header: Server: nginx
▸ Programming Language
  PHP                        High (80%)
    • Header: X-Powered-By: PHP/8.2.9
▸ JavaScript Library
  jQuery (3.7.1)             High (80%)
    • Markup: jquery-3.7.1.min.js
▸ WAF / Reverse Proxy
  Cloudflare                 Very High (97%)
    • Header: Server: cloudflare

Every detection comes with a confidence level and the evidence that produced it — the actual header value, meta tag, cookie, or script path. No black box.

Run it with --subdomains (or -s) and Jin goes deeper:

jin tech-stack -t example.com --subdomains

Subdomain discovery queries crt.sh, the public certificate transparency log. This is a purely passive technique — it reads public certificate data and never sends a single packet to the target, so there's no scanning footprint.
Each discovered subdomain is probed and fingerprinted independently, so you get a map of the whole attack surface: blog.example.com runs WordPress, api.example.com runs Express, mail.example.com is unreachable.
DNS records (nameservers, MX, TXT) are pulled with the Go standard library, which is great for spotting SPF/DKIM/DMARC posture and hosting infrastructure at a glance:

🗂️  DNS Records:
  Nameservers: ns1.cloudflare.com, ns2.cloudflare.com
  MX Records:  aspmx.l.google.com, ...
  TXT Records:
    • v=spf1 include:_spf.google.com ~all
    • google-site-verification=...

The interactive REPL

Running jin with no arguments drops you into a proper REPL — not a crude loop, but a real readline shell:

jin
jin> https://example.com
jin> ports -t example.com -p 80,443
jin> tech-stack -t example.com --subdomains
jin> exit

Nice touches that make it genuinely usable for research sessions:

Tab completion for all commands.
Command history persisted to ~/.jin_history.
Up/Down arrow to recall previous commands.
Ctrl+C aborts the in-flight scan and exits cleanly; exit/quit/Ctrl+D (EOF) also work.
Even a plain line reader fallback when stdin isn't a TTY.

One-shot usage still works exactly as before, which keeps Docker and scripting happy:

jin ports -t example.com
jin tech-stack -t example.com --subdomains --json | jq '.categories'

JSON output for automation

Every command accepts --json. The output is a stable, well-shaped document designed for parsing — with scanned_at, duration_ms, and machine-friendly fields. For example, the tech-stack JSON groups detections by category and includes per-technology evidence and confidence scores, plus the subdomain and DNS sections when requested.

This makes Jin easy to slot into recon pipelines, dashboards, or internal asset-discovery tooling.

Installation

From source

Requires Go 1.25+:

git clone https://github.com/sapiuwu/jin.git
cd jin
go build -o jin ./cmd/
./jin

With Docker

docker pull wahyouka/jin:v2.3.0

# interactive REPL
docker run -it --entrypoint jin wahyouka/jin:v2.3.0

# one-shot
docker run -it wahyouka/jin:v2.3.0 tech-stack -t example.com --subdomains

The image is a static, Alpine-based build with CA certificates and timezone data baked in.

A peek under the hood

If you're the kind of person who reads the source before trusting a security tool (you should be), Jin won't disappoint. It's organized as a textbook hexagonal architecture:

cmd/          → composition root (main.go)
internal/
  domain/     → pure domain models, no dependencies
  port/       → driving ports (services) & driven ports (scanners)
  application/→ use-case services (scan orchestration, security scoring)
  adapter/
    in/cli/   → CLI + REPL, argument parsing, rendering
    out/scanner/ → HTTP scanner, TCP port scanner, CT-log enumerator, DNS lookup
  config/     → centralized timeouts & tuning knobs
  container/  → dependency wiring

Each scanner is an out adapter implementing a driven port, and the CLI is the in adapter talking to driving ports. That means:

Adding a new detection signature is a self-contained change.
Swapping crt.sh for another CT log source doesn't touch application code.
The rendering layer is fully decoupled from the scanning layer.
Everything is testable with fake adapters.

When would you actually use this?

Bug bounty / pentest recon — map the attack surface before touching a target: what runs, where, on which ports, and which subdomains exist.
Own-infrastructure hygiene — run info against your own sites and fix the "free wins": missing HSTS, missing CSP, cookie flags, CORS misconfigs.
Competitive intel (legally) — a quick fingerprint of public-facing stacks.
Learning security — watching the evidence lines is a great way to learn how fingerprinting actually works.
Rapid triage — one binary, one command, one screen, instead of assembling nmap + whatweb + dnsrecon output by hand.

The honest limits

Jin is not a replacement for a full arsenal:

The port scanner is a TCP connect scan — it's slower and more detectable than SYN scanning, and it won't detect UDP services.
Fingerprinting is signature-based — heavily obfuscated or custom-built apps may come back with nothing.
Subdomain discovery relies on certificate transparency only — it won't find subdomains that never got a public certificate.
The security score is a starting point, not a certification. It can't catch logic bugs, auth flaws, or injection vulnerabilities.

Wrapping up

Jin is a thoughtful, well-engineered little tool that makes the first five minutes of any recon fast and pleasant — a passive OSINT pass, a port overview, and a tech-stack map, all from one binary with output you can actually read.

If that sounds useful to you:

GitHub: github.com/sapiuwu/jin
Install it, run jin with no arguments, and scan something you own.

And remember — with great recon power comes great responsibility. Only point it at targets you're authorized to investigate. Happy (ethical) hunting.

Introducing EOSAV: A Free and Open-Source Antivirus for Everyone

Wahyu K. A. — Thu, 01 Feb 2024 04:25:10 +0000

In today's digital world, where cyber threats lurk around every corner, safeguarding your devices from malware is not just an option, it's a necessity. Did you know that a malware attack occurs every 39 seconds?** That's why you need a robust antivirus solution that protects you effectively without compromising your budget or privacy. Look no further than EOSAV, the free and open-source antivirus designed to keep your devices safe and secure.

EOSAV: Simple, Powerful, and Open

EOSAV stands out from the crowd with its unique combination of simplicity, powerful protection, and open-source development.

Effortless User Experience: Say goodbye to complicated interfaces and confusing configurations. EOSAV boasts a clean and intuitive design that makes it easy to navigate and understand, even for users with limited technical knowledge.
Comprehensive Protection: Don't let the lightweight design fool you. EOSAV packs a punch, employing multiple detection methods like real-time scanning, on-demand scanning, and signature-based detection to shield you from viruses, trojans, ransomware, and other malicious threats.
Open Source for Transparency and Trust: As an open-source project, EOSAV's code is freely available for inspection and modification. This ensures transparency and security, knowing that your data is never collected or shared without your knowledge. Why Choose EOSAV?

Here's why EOSAV should be your go-to choice for antivirus protection:

It's Free: Protect your devices without breaking the bank. EOSAV is completely free to download and use, with no hidden costs or subscriptions.
It's Lightweight: Unlike resource-heavy antivirus programs, EOSAV runs smoothly in the background, minimizing impact on your system performance.
It's Customizable: Modify the open-source code to tailor EOSAV to your specific needs, adding or removing features as desired.
It's a Collaborative Effort: Join a vibrant community of developers and security enthusiasts, contributing to continuous improvement and innovation.

Join the Fight Against Cybercrime!

By choosing EOSAV, you're not just protecting your own devices, you're actively contributing to a safer digital environment for everyone. Become part of the open-source movement and help us build a future where everyone can enjoy the internet with peace of mind.

Download EOSAV today and experience the power of free and open-source antivirus protection!

Get Started:

Visit our website: http://eosav.site/

Together, let's create a safer digital world!

Beyond Signatures: Exploring Modern Antivirus Techniques

Wahyu K. A. — Wed, 17 Jan 2024 02:52:58 +0000

Hello everyone, still with me. Today I want to write something different, because for last week, I have learned, explore, and researched about cyber security especially about how malicious code work. But, I am not gonna writing a content about how to hack something. I just want to share my mini research about antivirus. In my mini research, I tried to created my own antivirus, just a simple antivirus with GUI (Graphical User Interface).

In this article I want to try to explain about the depth of antivirus technologies. And please take a note, in this article I am not going to make a tutorial about how to create antivirus, I just want to explain in the simple way about the technology beyond the antivirus. Ok, enough for pleasantries, lets go to our topic.

Introduction
In the vast of digital realm, just like in medieval times, we face lurking threats that aim to harm our precious data and systems. But, instead of dragon or sorcerers, we encounter malicious software (malware), often in the form of viruses, worms, and trojan. Thankfully, we have our own digital knights – antivirus software – to defend us from these cyber threats. For more specific information about malware, you can visit this article.

What is Antivirus
Antivirus software, as the name suggests, is designed to detect, prevent, and remove malware from your computer or device. Imagine it as a security system with multiple layers of protection, constantly scanning your digital terrain for suspicious activity and neutralizing any invaders before they can cause harm.

A journey through time: The history of antivirus
The story of antivirus begin in the early day of computing, around the 1970s, when the first computer viruses started appearing. These early threats were relatively simple, but they served as a wake-up call for the need for digital protection.

1971: The first known computer virus, Creeper emerges on DEC PDP-10 mainframe computers. This playful virus displayed the message "I'm the creeper, catch me if you can!" while replicating itself across machines.
1984: The Elk Cloner virus infects Apple II computers, displaying a poem before corrupting floppy disks.
1989: The Morris Worm becomes the first major internet worm, causing widespread disruption by infecting thousands of computers and crippling internet traffic.

These early encounters with malware led to the development of the first antivirus programs in the late of 1980s. These pioneers, like John McAfee and Eugene Kaspersky, laid the foundation for the sophisticated solution we have today.

Development and Evolution of Antivirus
Early antivirus software relied on signature-based detection, identifying and blocking known malware based on specific digital patterns, like virus signatures. This approach was effective against familiar threats, but it struggled with new and never-before-seen malware.

As malware creators became more sophisticated, antivirus developers had to adapt. This led to the development of several new technologies:

Heuristic: This technique analyzes programs for suspicious behavior, even if they don't match known virus signatures. Think of it as a detective looking for clues rather than just comparing mugshots.
Machine Learning: Advanced algorithms analyze vast amounts of data to identify patterns and anomalies, allowing antivirus software to detect even zero-day attacks. It's like having a constantly learning and evolving detective on your side.
Sandbox Technology: This creates a virtual environment when suspicious files can be safely execute and monitored, revealing their true nature without harming your actual system. Imagine testing a suspicious potion in a controlled lab before drinking it.
Behavioral Analysis: By monitoring how programs interact with your system, antivirus software can identify malicious activities, even if they are hidden within seemingly harmless code. It's like watching someone's actions to see if they are up to something shady.

These advancements have made modern antivirus solutions much more effective and adaptable, offering multi-layered protection against an ever-evolving threat landscape.

The future of antivirus
The battle against malware is an ongoing one, and antivirus developers are constantly innovating to stay ahead of the curve. Emerging technologies like artificial intelligence and blockchain are expected to play a significant role in the future of antivirus, leading to even more intelligent and proactive protection.

So, the next time you connect to the digital world, remember the tireless knights standing guard in the background – your antivirus software. They may not wear shining armor, but they wield powerful tools to keep your digital kingdom safe from harm.

Convert JSON Data To YAML in Python

Wahyu K. A. — Sat, 06 Jan 2024 08:48:10 +0000

Hello everyone, in this session i would like to share a simple tutorial about how to convert json data into yaml. In this tutorial i am gonna use python as programming language and a library called FormatFusion. FormatFusion is a powerful data converter library for python, you can check the detail in this https://pypi.org/project/FormatFusion/.

Before we start the tutorial, it is important to know what is json and yaml.

JSON
JSON stands for Javascript Object Notation. It is a lightweight data-interchange format that's widely used for transmitting data between computers. Think for it as a language for computers to talk to each other in a way that's both easy to understand and efficient to transmit. For further information about json, you can visit JSON: The Lightweight Data-Interchange Format.

Here is some keys to know about json:

human-readable: JSON is written in the plaintext, so it is easy for human to read and understand, even if they don't know how to program. This make it a great choice for things like configuration files and API responses.
language independent: even though it is based on javascript syntax, json can be used with any programming language. There are libraries and frameworks available for all major languages that can read and write json data.
lightweight: JSON files are very small and compact, which make them ideal for transmitting data over the internet. This is why json is often used for web APIs and web applications.
structured: JSON data is organized into key-value pairs and arrays. This make it easy to access and manipulate specifict place of data.

Here are some common uses of JSON:

web APIs: Many web APIs use json to send and receive data. Example, when you use a weather API to get current temperature, the API will return data in json format.
configuration files: Many application use json files to store configuration setting. This make it easy to changes the setting without having to modify the code itself.
data storage: JSON can be used to store data in a file or database. This is a common way to store data for web applications.

Here is the json example data:

{
  "person": {
    "name": "John Doe",
    "address": {
      "street": "123 Main St",
      "city": "Anytown",
      "state": "CA"
    }
  }
}

YAML
YAML ain't a markup language, though originally it meant Yet Another Markup Language. It is another data serialization language similar to json, often used for configuration files and data exchange. However, unlike json, it prioritize human readability with more intuitive and concise syntax. For further information about yaml, you can check it in my article YAML: The Friendly Face of Data – Unveiling The Depth of Human-Readable Code. Here are some key points about yaml:

Human-readable

Use indentation to define structure, similar to python code, make it easier to understand the hierarchy of data.
No need for closing tags or square bracket like json, simplifying the visual layout.
Support comments for annotation, further clarifying the meaning of the data.

Powerful and Flexible
A superset of json, meaning any valid json file is also a valid yaml file.
Support various data types including strings, numbers, booleans, lists, dictionaries, and often custom types.
Allows for anchors and aliases to reference data elsewhere in the document, reducing redundancy.
Common Uses
Configuration files for applications and servers.
Data exchange between programs and services.
Storing application state and settings.
Defining automation scripts and playbooks.

Here is the yaml example data:

name: My Application
version: 1.0.0
settings:
  debug: true
  port: 8080
data:
  users:
  - name: John Doe
    email: john.doe@example.com

We have already talking about both json and yaml. Now, it is the time to go to our main topic. First of all, we need to install FormatFusion library using the following command:

pip install FormatFusion

After that we can use the library to convert our json data into yaml format. Here is the example:

from FormatFusion.json_to_yaml import json_to_yaml

json_data = """{
    "name": "John Doe",
    "age": 30,
    "city": "New York"
}"""

yaml_data = json_to_yaml(json_data)
print(yaml_data)

We can also convert yaml data into json format using yaml_to_json function just like the example bellow.

from FormatFusion.yaml_to_json import yaml_to_json

yaml_data = """
   name: John Doe
   age: 30
   city: New York
"""

json_data = yaml_to_json(yaml_data)
print(json_data)

And that's it. How was it? It was easy, right? Converting JSON to YAML with the FormatFusion library is a breeze. In addition to converting YAML and JSON data, FormatFusion can also be used to convert other data formats. For more information, please visit the FormatFusion documentation on the GitHub repository. That's all for this tutorial. Thank you for reading and I hope it was helpful.

Here is an image of the FormatFusion library documentation:

Here are some additional tips for converting JSON to YAML:

If your JSON data is nested, you can use the indent property to control the indentation level of the YAML output.
If your JSON data contains comments, you can use the comment property to specify how to handle them in the YAML output.
If your JSON data contains special characters, you can use the escape property to specify how to escape them in the YAML output. I hope this helps!