DEV Community: Hosni Zaaraoui

Tech Infrastructure & Security Weekly Digest

Hosni Zaaraoui — Mon, 25 May 2026 11:50:02 +0000

Welcome to this week's technical news analysis. This edition breaks down groundbreaking shifts in autonomous AI exploitation, the expansion of local-to-cloud native tools, and massive global investments straining our current power grids.

1. The Dawn of Autonomous Exploitation: DARPA and Frontier AI Shake Infrastructure Security

What Happened

At the latest DARPA AI bug-hunting challenge, security researchers demonstrated a fundamental shift in vulnerability discovery. AI agents autonomously identified, chained, and exploited highly complex vulnerabilities in core infrastructure software—including the Linux kernel, the U-Boot boot loader, and foundational Apache libraries. Concurrently, Anthropic highlighted capabilities in frontier models (such as their Mythos Preview) that autonomously achieve local privilege escalation in Linux environments by chaining multiple zero-day flaws without human intervention.

Why It Matters

This marks the official transition from AI acting as a defensive assistant to AI acting as an autonomous threat actor. Security teams can no longer rely on manual patch management or standard "point-in-time" vulnerability scans. Because these autonomous agents can pivot from initial network entry to deep horizontal movement in under an hour, infrastructure administrators must pivot to automated, continuous mitigation to keep up.

Beginner Explanation

Imagine your server's security is like a giant castle. Traditionally, a hacker had to manually test every single brick to find a loose one, climb up, and find another weak spot inside. It took days or weeks. Now, an "AI Agent" is like a swarm of thousands of automated inspectors that can scan the whole castle in seconds, instantly find four different minor, unrelated flaws, and figure out exactly how to combine them to open the front gates—completely on their own.

Advanced Technical Insight

The core threat vector lies in the orchestration capabilities of modern LLM architectures when paired with execution sandboxes. Instead of merely identifying isolated buffer overflows or race conditions, these agentic workflows utilize iterative execution feedback loops.

For instance, an agent encounters an unpatched io_uring or netfilter subsystem flaw in the Linux kernel. If the initial exploit payload fails, the agent parses the kernel panic log or registers state, modifies the shellcode dynamically, and tests alternative heap-grooming techniques until successful Local Privilege Escalation (LPE) is achieved. This makes traditional static signature detection entirely obsolete.

Practical Takeaway

Action Item: Security Operations Centers (SOCs) must transition from passive vulnerability management to Continuous Threat Exposure Management (CTEM). Prioritize implementing runtime security tools (like eBPF-based systems) that detect anomalous kernel behaviors rather than relying solely on post-vulnerability CVE patches.

Learning Corner: What is Local Privilege Escalation (LPE)?

Local Privilege Escalation occurs when an attacker who already has restricted, low-level access to a system (such as a standard user account or a compromised service container) exploits a flaw in the operating system kernel or a root-running daemon to grant themselves full system administrative rights (root or SYSTEM).

2. Red Hat Bridges Local Dev and Cloud Infrastructure for Agentic Workflows

What Happened

At the recent Red Hat Summit, Red Hat announced the general availability of Red Hat Desktop alongside massive upgrades to its Advanced Developer Suite. The release specifically focuses on bridging the gap between an engineer’s local workstation and complex hybrid cloud targets, focusing heavily on building and deploying containerized, "agentic" AI applications seamlessly across Kubernetes and OpenShift environments.

Why It Matters

DevOps engineers often face a painful friction point: code works flawlessly on a local machine but fails due to networking, storage, or permission mismatches when pushed to cloud environments. By unifying local containers with enterprise cloud fabrics, Red Hat is standardizing the pipeline for the next generation of automation tools, significantly reducing time-to-production for engineering teams.

Beginner Explanation

When developers build software, they usually write and test it on their personal laptops. But when it goes live, it runs on massive networks of cloud servers. This often leads to the classic developer excuse: "Well, it worked on my machine!" Red Hat's new tools essentially clone the exact environment of the giant cloud system and shrink it down into the developer's laptop, ensuring that whatever works locally will work perfectly in the cloud.

Advanced Technical Insight

The underlying integration heavily optimizes local container runtimes (via Podman) to mirror enterprise Kubernetes/OpenShift constructs. This features native manifests, local ingress routing simulation, and identical security context constraints (SCCs).

For engineers building AI-native apps, it allows local testing of persistent data stores and microservices, mapping hardware execution directly from local developer GPUs (using NVIDIA CUDA runtimes) straight into production-ready OpenShift deployment templates without rewriting configuration file definitions.

Practical Takeaway

Action Item: DevOps and platform engineers should download and evaluate the new Red Hat Advanced Developer Suite to build out unified local-to-cloud workflows, focusing specifically on containerizing applications using Podman to eliminate runtime drift.

Learning Corner: Podman vs. Docker

While Docker uses a centralized background service (a background daemon running as root) to manage containers, Podman is architecture-rootless and daemonless by default. This means Podman launches containers as direct child processes of the user who called them, drastically lowering the system's attack surface and making local development significantly more secure.

3. Hyper-Scale Strain: AI Data Center Demands Trigger Search for Sustainable Infrastructure

What Happened

Global technology market forecasts from Gartner highlighted that worldwide spending on AI infrastructure is climbing over 47% year-over-year, driven heavily by AI-optimized servers, network fabrics, and specialized cloud environments. This unprecedented hyper-scale expansion is putting severe pressure on global energy grids, prompting hyperscalers to venture into alternative energy markets—including the successful IPO debut of geothermal energy startups like Fervo Energy, backed heavily by data center demand.

Why It Matters

For systems architects and cloud engineers, infrastructure is no longer just a software configuration problem; it is a physical and environmental constraint. The massive power draw of modern high-density compute clusters means that availability zones, region selections, and cloud expenditures will increasingly be dictated by green energy access and thermal efficiency constraints.

Beginner Explanation

Every time you ask an advanced AI to generate text, code, or images, a massive cluster of high-tech computers in a remote data center has to do incredibly heavy math. These computers run so hot and pull so much electricity that our normal power grids are struggling to keep up. Because of this, tech giants are now funding alternative energy sources, like tapping into the natural heat from deep inside the Earth (geothermal energy), just to keep their data servers running.

Advanced Technical Insight

Modern AI clusters utilizing high-performance server blocks demand staggering levels of Power Usage Effectiveness (PUE) and altered data center architectures. Traditional data centers were engineered for low-density racks (averaging 5kW to 15kW per rack).

Next-generation AI server deployments demand upwards of 40kW to 100kW+ per rack. This shift forces a massive infrastructure migration away from traditional air cooling toward closed-loop liquid cooling architectures and direct grid ties to carbon-free base-load energy providers like enhanced geothermal systems (EGS) or Small Modular Reactors (SMRs).

Practical Takeaway

Action Item: Cloud architects should prioritize studying FinOps frameworks and green computing patterns. When designing massive pipeline workloads, evaluate multi-region deployment topologies that dynamically target cloud regions optimized for low-carbon footprints and higher power efficiencies.

Learning Corner: What is PUE?

Power Usage Effectiveness (PUE) is a standard metric used to determine how efficiently a computer data center uses energy. It is calculated using the following formula:

$$\text{PUE} = \frac{\text{Total Facility Energy}}{\text{IT Equipment Energy}}$$

An ideal PUE is $1.0$, meaning every single watt of power entering the facility goes directly into powering the actual computing servers, rather than being wasted on cooling systems or lighting.

Key Trends This Week

Rise of Agentic Architectures: AI is rapidly evolving from a passive text chatbot into persistent, multi-step autonomous software agents capable of executing complex code pipelines and network probing independently.
The Death of Periodic Monitoring: The speed at which autonomous exploits can occur is forcing enterprises to ditch daily/weekly vulnerability scans in favor of live, continuous runtime analysis.
Density Shift in the Cloud: Cloud data centers are shifting dramatically from general-purpose CPUs to high-density compute environments, reshaping the physical layout, cooling requirements, and energy reliance of the cloud.

When Ping Doesn't Quite Work as Expected

Hosni Zaaraoui — Sun, 17 May 2026 12:08:11 +0000

I was trying to troubleshoot a network issue the other day and I found myself staring at a ping command that just wouldn't work.

I was trying to ping a website, but it kept saying 'unknown host'. I was confused - I knew the website was up and running, so why couldn't I ping it?

It turns out, the issue was with the DNS resolution. The ping command relies on the DNS to resolve the hostname to an IP address.

If the DNS can't resolve the hostname, the ping command will fail.

To fix the issue, I used the 'dig' command to check the DNS resolution.

I realized that the DNS server I was using wasn't able to resolve the hostname. I switched to a different DNS server and voila! The ping command started working.

The takeaway from this experience is that networking issues can often be complex and multi-layered.
It's not always just a simple matter of 'it works' or 'it doesn't work'.
Sometimes, you need to dig deeper (pun intended) to understand what's really going on.

What's your go-to command for troubleshooting network issues?

Unraveling the Mystery of SSH Connection Refusals

Hosni Zaaraoui — Thu, 14 May 2026 09:08:56 +0000

I was trying to set up a new homelab server the other day, and I stumbled upon this frustrating issue.

At first, I thought it was a firewall problem, but after checking the rules, I realized that wasn't the case.

After some digging, I discovered that the issue was due to the SSH service not being enabled on the server.
I know, I know, it sounds like a rookie mistake!

But here's the thing: I had enabled the service, but I hadn't restarted it after making some configuration changes.

The command 'sudo systemctl restart sshd' saved the day.

It got me thinking, though - what other services might be in a similar state?

I started checking the status of other services, and sure enough, I found a few that needed a restart.

Moral of the story: always double-check the service status after making changes, and don't be afraid to restart when necessary.

My Linux Permissions Epiphany

Hosni Zaaraoui — Sun, 10 May 2026 12:00:26 +0000

I was trying to delete a file in my homelab the other day, but I kept getting a permission denied error, even though I was logged in as root. I was confused - I thought being root meant I had unlimited power over the system.

It turns out, I was misunderstanding how Linux permissions work.

The root user can't necessarily overwrite any file, especially if it's owned by a different user or has specific permissions set.

I learned that the 'chmod' command can be used to change the permissions of a file, and the 'chown' command can be used to change the owner of a file.
For example, to change the permissions of a file to allow the owner to read, write, and execute, you can use the command: chmod 700 filename.

My takeaway from this experience is that understanding Linux permissions is crucial for any system administrator.
It's not just about being the root user, but about understanding how the system is configured and how to work within those constraints.

What's your most memorable Linux permissions lesson?

Debugging a Mysterious Docker Issue

Hosni Zaaraoui — Sat, 09 May 2026 09:22:21 +0000

I recently encountered a weird issue with my Docker container where it would start, run for a few seconds, and then exit with a non-zero status code.

I checked the logs, but there were no obvious errors.

I spent hours trying to figure out what was going on, trying different Docker commands and searching online for solutions.

It wasn't until I used the 'docker logs -f' command to view the container's logs in real-time that I saw the issue.

The problem was that my container was trying to connect to a database that wasn't available yet.

I realized that I needed to add a dependency to my Docker Compose file to ensure that the database was up and running before my container started.

The fix was simple, but it took me a while to get there.

Has anyone else ever encountered a similar issue? What was your solution?

The day I realized the shebang matters

Hosni Zaaraoui — Sat, 09 May 2026 08:50:14 +0000

First I ran:

chmod +x hello.py
./hello.py

and got:

Permission denied

I thought the 755 bit was enough, but the real issue was the shebang line.

If the first line of a script doesn't point to a valid interpreter, the kernel tries to execute the file directly and fails with permission denied.

The fix? Add a proper shebang:

!/usr/bin/env python3

or point to the exact path:

!/usr/bin/python3

Then run chmod +x hello.py again.

Now it works.
Lesson: Always double-check the shebang, especially when moving scripts between machines.

Have you run into this before?

Welcoming My DEV.to Content Generator Agent

Hosni Zaaraoui — Sat, 09 May 2026 08:36:23 +0000

While experimenting with automation using n8n, I built a DEV.to content generator that creates and publishes technical posts automatically 🚀

It’s still a work in progress and I’m continuously improving it, but from now on some of the posts published here will be generated through this system.

Mainly focused on:

Linux
Cybersecurity
Automation
SysAdmin

A fun mix of automation, AI, and technical content creation 👨‍💻⚡

Linux sysadmin tips & shortcuts

Hosni Zaaraoui — Tue, 05 May 2026 17:19:30 +0000

Process & Port Management

Find what’s using a port:

ss -tulnp | grep :8080
Kill process by port:

kill -9 $(lsof -t -i:8080)
Top processes (better than top):

btop

Show process tree:

ps auxf

File & Disk Tricks

Human-readable disk usage:

df -h du -sh *

Find large files:

find / -type f -size +500M 2>/dev/null
Quickly clean logs:

truncate -s 0 /var/log/syslog

Search Like a Pro

Grep with line numbers + ignore case:

grep -in "error" file.log
Recursive search:

grep -r "password" /etc
Use less smarter:
/pattern → search
Shift+G → go to end

Networking Essentials

Check open ports:

ss -tuln
Test connectivity:

nc -zv 192.168.1.10 80
Show IPs:

ip a
Live traffic sniff:

tcpdump -i eth0

Services & Systemd

Check service status:

systemctl status nginx
Restart service:

systemctl restart nginx
View logs:

journalctl -u nginx -f

Memory & Performance

Memory usage:

free -h
CPU + memory snapshot:

top
IO stats:

iostat

Terminal Shortcuts (Huge Time Savers)

Ctrl + C → kill command
Ctrl + Z → pause (background it)
fg → bring back
Ctrl + A → start of line
Ctrl + E → end of line
Ctrl + R → search history 🔥

History & Productivity

Show history:

history
Re-run last command:

!!
Re-run command with sudo:

sudo !!

Permissions & Ownership

Change ownership:

chown user:user file
Change permissions:

chmod 755 script.sh

Package Management (Debian/Ubuntu)

Update & upgrade:

apt update && apt upgrade -y
Find package:

apt search nginx
Remove package:

apt remove nginx

Debugging & Logs

Follow logs live:

tail -f /var/log/syslog
Last 100 lines:

tail -n 100 file.log
Watch command output:

watch -n 2 "df -h"

Pro-Level Tricks

Run command in background:

nohup command &
Run multiple commands safely:

command1 && command2
Pipe like a wizard:

cat file | grep error | sort | uniq
Temporary Python web server:

python3 -m http.server 8000

Bonus (Sysadmin Mindset)

Always check logs first (/var/log or journalctl)
If something uses a port → ss + lsof → kill
If service fails → systemctl status + journalctl
If server slow → top + iostat + free

Stdout vs stderr vs stdin

Hosni Zaaraoui — Fri, 24 Apr 2026 14:29:56 +0000

One of the most useful Linux concepts for beginners is understanding the 3 standard streams:
· stdin for input
· stdout for normal output
· stderr for errors
Once this clicks, redirection and pipes make a lot more sense.
I made this one-image cheat sheet to simplify it.

Signals in Linux explained visually

Hosni Zaaraoui — Fri, 24 Apr 2026 14:28:28 +0000

Stopping a process in Linux isn’t just “kill it.”
Signals are how Linux communicates with running processes:
· some ask nicely
· some interrupt
· some pause
· and some force termination
This one-image visual explains the most common Linux signals and when to use them.

Linux Basics That Actually Matter (Files, Editing & Permissions)

Hosni Zaaraoui — Sun, 12 Apr 2026 12:02:24 +0000

Most beginner Linux posts say:
“Use touch, use nano, use chmod…”

But they don’t explain why things work the way they do.

Let’s fix that.

1. File Creation — It’s Not Just “touch”

Yes:

touch file.txt creates a file
mkdir dir/ creates a directory

But here’s what matters:

Linux is a hierarchical filesystem
Everything starts from / (root), and every file has a purpose.

Examples:

/etc/ → configuration files
/var/log/ → logs
/home/user/ → user data

Insight:
Where you create a file matters more than how.

Creating a script in /tmp vs /usr/local/bin changes its lifecycle and usage.

2. Editing Files — Understanding the Workflow

Editors are not just tools, they define how you work.

🔹 nano

Simple, visible shortcuts
Good for quick edits

🔹 vim

Modes (insert / normal / command)
Extremely fast once mastered

But here’s the key point:

In Linux, editing often means modifying system-critical files

Examples:

Editing /etc/ssh/sshd_config affects remote access
Editing /etc/fstab can break boot

Insight:
Always know what file you are editing, not just how.

3. Permissions — The Core of Linux Security

Every file has:

Owner (user)
Group
Others

And 3 permissions:

Read (r)
Write (w)
Execute (x)

Example:
-rwxr-x---

Meaning:

Owner → full access
Group → read & execute
Others → no access

Commands:

chmod → change permissions
chown → change owner

Real insight:
Permissions are not just protection — they define behavior.

Example:

A script without x won’t run
A service without read access won’t start

4. GUI Tools — Useful, But Limited

File managers like:

Thunar
Dolphin
Files (GNOME)

Help you:

Visualize permissions
Move files quickly

But:

They hide complexity.

You won’t see:

Recursive permission changes
Hidden system behavior
Ownership logic clearly

Best approach:
Use GUI to explore
Use CLI to understand and control

Final Thought

Linux becomes easy when you stop memorizing commands and start understanding:

Why files are placed somewhere
What happens when you edit them
How permissions affect execution

That’s the difference between a beginner… and someone who actually knows Linux.

💬 What broke your system the first time?

Next: Real-world mistakes + how I debugged them in my labs.

🐧 “Linux is Hard” — Until You Actually Use It

Hosni Zaaraoui — Wed, 08 Apr 2026 14:35:49 +0000

For a long time, I thought Linux wasn’t for normal people.

It looked complicated.
Terminal everywhere.
Strange commands.
Things breaking for no reason.

So I did what most people do:

I installed Linux… in a VM.

The Illusion of “Trying Linux”

Using Linux in a virtual machine feels like you’re learning it.

But you’re not really living with it.

You don’t customize it
You don’t rely on it
You don’t fix real problems
You just test things… and leave

If something breaks?

You close it. Done.

That’s why Linux feels unusable at this stage.

Why Linux Feels “Not Ready”

From the outside, Linux seems:

Too technical
Not user-friendly
Missing “basic” features
Hard to fix when something goes wrong

And honestly, at the beginning… it does feel that way.

Because you don’t yet know your options.

What Changed When I Switched

Everything changed when I made Linux my main OS.

Not because it suddenly became easier…

But because I started learning how it actually works.

I discovered:

There’s always more than one way to do something
Most problems have simple fixes (once you know where to look)
You can shape the system to fit you

Instead of adapting to the OS…
The OS adapts to you.

The “Aha” Moment

The biggest realization was this:

Linux isn’t hard.

It’s just different.

And once you understand a few core ideas:

reading logs
using the terminal
knowing where things live

It stops feeling broken… and starts feeling powerful.

It’s Not About Being an Expert

You don’t need to know everything.

You just need to:

Google errors
Try small fixes
Learn one thing at a time

That’s it.

And over time, things that looked impossible become simple.

Why I’m Starting This Series

I’m documenting my journey of using Linux as a daily driver.

Not as an expert—but as someone figuring things out step by step.

I’ll share:

Simple tips that actually help
Fixes to real problems I run into
Small tweaks that improve daily usage
Things I wish I knew earlier

If You’re Hesitating

If you think:

“Linux isn’t for me”

You’re probably at the same stage I was.

Using it without really using it.

The real experience starts when you commit to it.

Linux isn’t unusable.

It just doesn’t try to hide how things work.

And once you understand that… everything changes.