Linux on Linux Security

Using systemd-resolved to Tame DNS Lookup Surprises on Multi-Homed Linux Machines

Sat, 11 Jul 2026 08:24:10 +0200

Introduction to systemd-resolved

I’ve seen this go wrong when working with multi-homed Linux machines: DNS lookup surprises can be a real pain. A multi-homed machine, with multiple network interfaces each connected to a different network, can lead to DNS resolution problems. The system may not know which interface to use for DNS lookups, causing all sorts of issues. This is where people usually get burned - trying to troubleshoot DNS problems without a clear understanding of how their system is configured. To address this issue, I usually start with systemd-resolved, a tool that can help manage DNS resolution and provide more predictable behavior.

Recovering from a Botched Package Upgrade with apt and snapshotting

Fri, 10 Jul 2026 11:49:45 +0200

Introduction to Recovery

I’ve seen this go wrong when a package upgrade fails - it can be frustrating and even lead to system instability. When this happens, it’s essential to have a plan in place to recover your system. Fortunately, with the right tools and techniques, recovering from a botched package upgrade is relatively straightforward. In this article, we’ll explore how to use apt and snapshotting to recover from a failed package upgrade on a Linux system.

Troubleshooting DNS Leaks with systemd-resolved and resolv.conf

Thu, 09 Jul 2026 08:15:21 +0200

Introduction to DNS Leaks

I’ve seen DNS leaks become a major concern for Linux users, especially those relying on systemd-resolved. A DNS leak occurs when your system sends DNS queries to an unintended DNS server, potentially exposing your browsing history and other sensitive information. In this article, I’ll share my experience and insights on how to identify and troubleshoot DNS leaks using systemd-resolved and resolv.conf.

Understanding systemd-resolved

Systemd-resolved is a powerful tool that provides DNS resolution. It acts as a local DNS resolver, caching DNS queries and responses to improve performance. By default, systemd-resolved uses the DNS servers provided by your network configuration, but you can configure it to use specific DNS servers. To check the current DNS servers used by systemd-resolved, run:

Extracting Valuable Data from Systemd Journal Logs with jq and grep

Wed, 08 Jul 2026 09:39:13 +0200

Introduction to Systemd Journal Logs

I’ve worked with Linux systems for years, and one of the most powerful tools at my disposal is systemd journal logs. These logs provide a centralized location for logging system events, making it easier to troubleshoot and diagnose issues. By default, systemd stores these logs in a binary format, which can make them a bit tricky to parse and analyze. However, with the help of tools like jq and grep, you can extract valuable data from these logs.

Taming Disk Space Usage with find and xargs in a Busy /var/log Directory

Tue, 07 Jul 2026 08:58:55 +0200

Introduction to Disk Space Management

I’ve seen this go wrong when managing a busy /var/log directory - disk space usage can quickly become a concern. All those logs from various system services, applications, and security tools can accumulate, leading to storage issues if not properly maintained. In practice, this can be a real headache, especially when you’re dealing with limited disk space. To avoid this, we can use find and xargs to keep the /var/log directory in check.

Taming Disk Space Usage with btrfs Snapshots and Automatic Pruning

Mon, 06 Jul 2026 10:42:14 +0200

Introduction to btrfs Snapshots

I’ve been using btrfs for years, and one of its most powerful features is its ability to create snapshots. These are read-only copies of a subvolume at a particular point in time, which can be used for backups, testing, and even recovering from accidental file deletions or modifications. Don’t bother with other file systems if you need this level of flexibility.

Creating Snapshots

To get started with btrfs snapshots, you’ll first need to ensure that your system is using btrfs. Run lsblk -f and look for the btrfs label. If you’re using btrfs, creating a snapshot is straightforward:

Troubleshooting Slow systemd Service Restarts with systemd-analyze

Sun, 05 Jul 2026 10:06:58 +0200

Introduction to systemd-analyze

I’ve seen my fair share of slow service restarts on Linux systems, and troubleshooting them can be a real challenge. That’s where systemd-analyze comes in - a powerful tool that helps analyze and troubleshoot systemd services. In this article, I’ll share how to use systemd-analyze to identify and potentially fix issues related to slow systemd service restarts.

Understanding systemd-analyze

The real trick is to understand what systemd-analyze can do for you. It’s a command-line tool that comes bundled with systemd, providing detailed information about the boot process, services, and their dependencies. With systemd-analyze, you can identify performance bottlenecks, slow services, and even issues with the system’s boot process. Don’t bother with manual logging and debugging - systemd-analyze can save you a lot of time and effort.

Taming SSH Config Chaos: Organizing Your SSH Client Settings for Multiple Servers and Identities

Sat, 04 Jul 2026 10:26:43 +0200

Taming SSH Config Chaos

If you’re like me, you’re constantly juggling multiple servers and identities. Managing SSH connections can be a real headache, especially when dealing with different usernames, ports, and private keys. I’ve seen this go wrong when you have to remember a dozen different connection settings. The real trick is to organize your SSH client settings in a way that makes sense for your workflow.

Understanding SSH Config Files

The SSH client configuration is stored in the ~/.ssh/config file. This is where you define settings for your SSH connections, such as hostname, username, port, and private key. By default, the SSH client looks for this file and applies the settings. To get started, create a new ~/.ssh/config file using your favorite text editor:

Using SSH to Tunnel Traffic Through a Jump Host for Secure Access to a Remote Network

Fri, 03 Jul 2026 09:11:35 +0200

Introduction to SSH Tunneling

I’ve seen this go wrong when people try to access remote networks without using a secure method - that’s where SSH tunneling comes in. This technique leverages an intermediate host, known as a jump host, to securely access remote networks. It’s particularly useful when direct access is restricted due to firewall rules or network policies. By using SSH to tunnel traffic through a jump host, you can establish a secure connection to a remote server or network, even if direct access is not possible.

Using Third-Party Repositories Without Polluting Your Package Manager

Thu, 02 Jul 2026 08:15:00 +0200

Introduction to Third-Party Repositories

I’ve seen this go wrong when Linux users need a specific package that’s not available in their default repositories. That’s where third-party repositories come in – they provide additional packages that can enhance the functionality of your system. However, adding these repositories can sometimes lead to version conflicts and dependency issues, which can be a real headache.

Understanding the Risks

Before adding a third-party repository, it’s crucial to understand the potential risks. When you add a repository, you’re essentially trusting the repository maintainer to provide secure and compatible packages. If the repository contains malicious or outdated packages, it can compromise the security and stability of your system. I’ve noticed that several high-profile incidents in 2025 highlighted the importance of verifying the integrity of third-party repositories. Don’t bother with repositories that don’t have a clear track record of providing secure packages.

Resolving the "Unknown Host" Headache: Troubleshooting DNS Issues with systemd-resolved and resolv.conf

Wed, 01 Jul 2026 09:38:07 +0200

Introduction to DNS Troubleshooting

We’ve all been there - trying to access a website or service, only to be met with an “Unknown Host” error. These errors often stem from DNS issues, which can be frustrating to troubleshoot, especially when you’re not sure where to start. In my experience, the culprits are usually misconfigured resolv.conf files or problems with systemd-resolved. In this article, I’ll walk you through the practical aspects of troubleshooting DNS issues, focusing on systemd-resolved and resolv.conf, to help you resolve the “Unknown Host” headache efficiently.

Troubleshooting Btrfs Snapshot Overfill with systemd Timers and Log Rotation

Tue, 30 Jun 2026 09:01:31 +0200

Introduction to Btrfs Snapshots

I’ve worked with Btrfs for years, and its snapshot feature is one of my favorites. It allows you to create a read-only copy of a subvolume at a particular point in time, which is super useful for backups, testing, and rolling back changes. However, managing these snapshots can become a real pain, especially when dealing with a large number of them. In this article, I’ll show you how to troubleshoot Btrfs snapshot overfill issues using systemd timers and log rotation.

Troubleshooting Systemd Service Boot Delays with systemd-analyze

Mon, 29 Jun 2026 09:10:15 +0200

Introduction to Systemd Service Boot Delays

I’ve seen this go wrong when working with Linux systems managed by systemd - boot delays can be frustrating and impact system performance. In my experience, understanding how to troubleshoot these delays is crucial for maintaining efficient and reliable systems. Many Linux distributions, including Debian, Arch Linux, and OpenSUSE, rely on systemd for service management, so it’s essential to know how to use systemd-analyze to identify and resolve boot delays caused by systemd services.

Using SSH Keys with Multiple Identities and Agents for Simplified Remote Access

Sun, 28 Jun 2026 09:46:19 +0200

Introduction to SSH Keys and Agents

I’ve seen many Linux users struggle with managing multiple remote systems, but SSH keys and agents can make a huge difference. By using SSH keys, you can authenticate to remote servers without entering a password, making it easier to manage multiple systems. In practice, this means you can quickly switch between systems without having to remember a bunch of passwords.

Generating SSH Keys

To start using SSH keys, you need to generate a key pair on your local system. I usually start with the ssh-keygen command to generate a key pair:

Mastering SSH Connection Sharing with ControlMaster and ControlPersist

Sat, 27 Jun 2026 10:48:08 +0200

I’ve seen this go wrong when people don’t understand how SSH connection sharing works. It’s actually pretty simple: SSH connection sharing is a feature that allows you to reuse an existing SSH connection for multiple SSH sessions. This can significantly speed up your workflow, especially when working with remote servers. In this article, we’ll explore how to master SSH connection sharing using ControlMaster and ControlPersist.

Using pgrep and pkill to Simplify Process Management and Avoid Common Mistakes with background Tasks

Fri, 26 Jun 2026 11:11:33 +0200

Introduction to pgrep and pkill

When I’m managing background tasks and processes in Linux, I always reach for pgrep and pkill. These two commands are often overlooked, but they’re incredibly useful for searching for and managing processes by name. I’ve seen this go wrong when people use ps with grep - it’s just not as precise. With pgrep and pkill, you can avoid common mistakes when dealing with background tasks.

Simplifying Remote File Transfers with SSH and rsync Over a Jump Host

Thu, 25 Jun 2026 08:22:25 +0200

Introduction to Remote File Transfers

I’ve seen this go wrong when you’re trying to transfer files between machines, especially in scenarios where direct access is not possible. Using a jump host can simplify the process. A jump host, also known as a bastion host, is an intermediary server that you use to access other servers. In this article, we’ll explore how to use SSH and rsync over a jump host for secure and efficient remote file transfers.

Taming Log Rotation: Preventing Disk Space Issues with systemd-journald and Log File Management

Wed, 24 Jun 2026 11:55:31 +0200

Introduction to Log Rotation

Log rotation - it’s one of those tasks that’s easy to overlook, but can quickly become a major headache if you don’t stay on top of it. I’ve seen this go wrong when log files consume all the available disk space, bringing a system to its knees. With many Linux distributions now using systemd-journald as the default logging mechanism, understanding how to manage log rotation is more important than ever.

Taming Log Rotation: Strategies for Preventing /var/log Overflow on Busy Systems

Tue, 23 Jun 2026 10:41:31 +0200

Introduction to Log Rotation

I’ve seen log files grow out of control and bring down entire systems, so log rotation is something I take seriously. It’s a crucial aspect of Linux system maintenance, ensuring that log files don’t consume all available disk space. On busy systems, logs can fill up quickly, leading to issues with system performance and even causing services to fail.

Understanding Log Rotation

Log rotation involves periodically switching out log files, typically by renaming the current log file and starting a new one. This process can be configured to occur at set intervals, such as daily or weekly, and can also be triggered by the size of the log file. Most Linux distributions come with a log rotation system pre-configured, often using the logrotate utility. Don’t bother with manual log rotation unless you have a specific reason to do so - logrotate is a well-tested and reliable tool.

Taming systemd Service Restart Behavior: When to Use Restart, Retry, and Timeout Options

Mon, 22 Jun 2026 09:07:35 +0200

Introduction to systemd Service Restart Behavior

I’ve seen this go wrong when a service is not properly configured - systemd, the core component of most modern Linux distributions, is responsible for managing system services. One of its key features is the ability to automatically restart services that fail or terminate unexpectedly, controlled by the Restart directive in the service unit file. However, I’ve found that the Restart directive alone may not be sufficient to handle all scenarios, which is where the Retry and Timeout options come into play.

Troubleshooting Broken Permissions on Shared Directories with setgid and ACLs

Sun, 21 Jun 2026 10:09:46 +0200

Introduction to Shared Directory Permissions

When working with shared directories in Linux, permissions can quickly become a complex issue. I’ve seen this go wrong when multiple users need to collaborate on the same project, and suddenly, nobody can access the files they need. The setgid bit and Access Control Lists (ACLs) are two powerful tools for managing these permissions. In this article, we’ll explore how to troubleshoot broken permissions on shared directories using setgid and ACLs.

Using systemd-resolved with Multiple DNS Servers and Split Horizon DNS

Sat, 20 Jun 2026 08:55:08 +0200

Introduction to systemd-resolved

I’ve been using systemd-resolved for a while now, and I have to say, it’s a game-changer when it comes to managing DNS resolution on Linux systems. As of 2026, it’s become a crucial component in many Linux distributions, including Ubuntu, Debian, and Fedora. In this article, I’ll walk you through how to use systemd-resolved with multiple DNS servers and split horizon DNS, including some practical examples and troubleshooting notes.

Taming Dependency Chaos: Using apt-mark to Pin Packages in Debian-Based Systems

Fri, 19 Jun 2026 10:03:12 +0200

Introduction to Dependency Management

As someone who’s spent years running Linux systems, I can tell you that dependency management is crucial for maintaining a healthy and stable system. You’re probably already familiar with keeping your packages up to date, but sometimes you need to pin specific packages to prevent them from being updated. This can help maintain system stability or prevent potential security issues. In this article, I’ll walk you through how to use apt-mark to pin packages in Debian-based systems.

Taming systemd Restart Policies to Prevent Service Chaos

Thu, 18 Jun 2026 10:48:52 +0200

Introduction to systemd Restart Policies

I’ve seen systemd restart policies go wrong when not properly configured, leading to a never-ending cycle of restarts without resolving the underlying issue. To avoid this chaos, it’s essential to understand how systemd manages system services, including starting, stopping, and restarting them as needed. The key to taming these restart policies lies in understanding how systemd service files work and how to configure them effectively.

Troubleshooting Local Port Conflicts with ss and nftables on a Multi-Service Linux Server

Wed, 17 Jun 2026 09:42:05 +0200

Introduction to Troubleshooting Local Port Conflicts

When dealing with a Linux server that’s running multiple services, I’ve seen this go wrong when two or more services try to bind to the same port - it’s a recipe for disaster. This is where people usually get burned, as one or more of the services will fail to start. To avoid this, we can use the ss command and nftables to troubleshoot local port conflicts.

Troubleshooting DNS Leaks with systemd-resolved and resolv.conf

Tue, 16 Jun 2026 10:58:16 +0200

Introduction to DNS Leaks

I’ve seen DNS leaks become a major concern for Linux users who care about their online privacy. Essentially, a DNS leak happens when your system’s DNS queries slip outside a secure tunnel - think VPN - and potentially expose your browsing history to prying eyes. Given the current online security landscape, being able to troubleshoot these leaks is more important than ever.

Understanding systemd-resolved

Systemd-resolved is a key system service in Linux that handles DNS resolution. It’s part of the systemd suite and is widely used in modern distributions like Ubuntu, Debian, and Fedora. One of the benefits of systemd-resolved is that it can be configured to use DNS over TLS (DoT) or DNS over HTTPS (DoH), which encrypts DNS queries and reduces the risk of leaks.

Resolving DNS Issues with resolvectl and systemd-resolved in a Home Network

Mon, 15 Jun 2026 09:54:03 +0200

Introduction to DNS Resolution

When setting up a home network, DNS resolution is one of those critical components that can be a real pain to troubleshoot. I’ve seen this go wrong when people are new to Linux, so let’s dive into how to use resolvectl to resolve DNS issues with systemd-resolved.

Understanding systemd-resolved

systemd-resolved is a system service that handles DNS resolution, among other network-related tasks. It’s part of the systemd suite and is widely used in many Linux distributions, including Ubuntu, Debian, and Fedora. The real trick is that systemd-resolved provides improved DNS security and better support for modern DNS protocols like DNS over TLS (DoT) and DNS over HTTPS (DoH). Don’t bother with trying to use it without understanding these benefits, as they’re a key part of what makes systemd-resolved so useful.

Troubleshooting Slow Network Connectivity with ss and resolvectl on Linux

Sun, 14 Jun 2026 08:16:06 +0200

Introduction to Network Troubleshooting

I’ve seen my fair share of slow network connectivity issues on Linux, and having the right tools at your disposal can make all the difference. Two tools that I rely on are ss and resolvectl, which can help you diagnose and troubleshoot network issues. In this article, we’ll explore how to use these tools to identify and potentially fix slow network connectivity problems.

Understanding `ss`

The ss command is a replacement for the traditional netstat command, and it provides more detailed information about network connections, including TCP, UDP, and Unix domain sockets. To get started with ss, you can use the following command to display all active connections:

Taming Disk-Hungry Logs with systemd's Persistent Journal and Log Rotation

Sat, 13 Jun 2026 11:46:55 +0200

Introduction to Log Management

I’ve seen log management become a major headache for many Linux administrators. Logs are essential for diagnosing issues, detecting security threats, and optimizing system performance, but they can grow rapidly and consume significant disk space. In practice, this can lead to performance issues and even system crashes. To avoid this, we can use systemd’s persistent journal and log rotation features.

Understanding systemd’s Journal

Systemd’s journal is a centralized logging system that collects log messages from various system components, including systemd services, kernel messages, and application logs. The real trick is to configure it to use persistent storage, so logs aren’t lost upon system reboot. By default, the journal stores log messages in a volatile storage area, which isn’t very useful for long-term log management.

Using systemd to Manage and Rotate Logs for Forgotten System Services

Fri, 12 Jun 2026 08:50:25 +0200

Introduction to Log Management with systemd

I’ve seen many Linux admins struggle with log management, especially when it comes to system services that are often overlooked. Systemd is a powerful system and service manager that provides a wide range of features, including process management, dependency handling, and log management. In this article, I’ll focus on using systemd to manage and rotate logs for system services.

Understanding systemd Logs

The real trick is to understand how systemd logs work. Systemd logs are stored in a binary format, which can be read using the journalctl command. This command provides a powerful way to filter, search, and manage system logs. By default, systemd stores logs in /var/log/journal, but this can be configured to use a different location. Don’t bother with trying to read the binary logs directly - just use journalctl.

Resolving Dependency Conflicts When Mixing Third-Party Repositories with Distribution Packages

Thu, 11 Jun 2026 09:22:32 +0200

Introduction to Dependency Conflicts

I’ve seen this go wrong when mixing third-party repositories with distribution packages - dependency conflicts can cause frustration and potential security risks. As a Linux user, understanding how to resolve these conflicts is crucial for maintaining a stable and secure system. In this article, we’ll explore the common causes of dependency conflicts, how to identify them, and practical steps to resolve them.

Understanding Dependency Conflicts

Dependency conflicts occur when two or more packages require different versions of the same dependency. This can happen when you install packages from third-party repositories, which may not be compatible with the distribution’s packages. For example, if you’re running Ubuntu 22.04 and want to install the latest version of ffmpeg from a third-party repository, it can cause a conflict because the repository requires a newer version of libavcodec than what’s available in Ubuntu 22.04.

Troubleshooting Poor Video Performance on Linux Laptops with Hybrid Graphics and Wayland

Wed, 10 Jun 2026 08:29:11 +0200

Introduction to Troubleshooting

When dealing with Linux laptops that have hybrid graphics, getting the best video performance can be tough, especially with Wayland. I’ve seen this go wrong when people don’t take the time to understand how their system is set up. As of 2026, many Linux distributions have made big strides in supporting hybrid graphics and Wayland, but issues still pop up. In this article, we’ll go over some practical steps for troubleshooting poor video performance on these laptops.

Taming systemd Timer Services to Run Your Daily Backup at a Reasonable Hour

Tue, 09 Jun 2026 09:05:53 +0200

Introduction to systemd Timer Services

I’ve been using systemd timer services for years to schedule tasks on my Linux systems, and I have to say, they’re a game-changer. Most Linux distributions, including Debian, Arch Linux, and OpenSUSE, use systemd as their default init system, so it’s worth learning how to use them. In this article, I’ll show you how to use systemd timer services to run daily backups at a reasonable hour.

Troubleshooting Common Connection Issues with resolvectl and ss on Linux

Mon, 08 Jun 2026 11:07:29 +0200

Introduction to Troubleshooting Connection Issues

When working with Linux, connection issues can arise due to various reasons such as misconfigured DNS settings, firewall rules, or network interface configurations. I’ve seen this go wrong when a simple DNS misconfiguration can bring down an entire application. To troubleshoot these issues, Linux provides a range of tools, including resolvectl and ss. In this article, we will explore how to use these tools to diagnose and resolve common connection problems.

Taming Package Versions with apt-mark and pinning to Avoid Dependency Conflicts

Sun, 07 Jun 2026 10:36:07 +0200

Introduction to Package Versioning

When managing packages on a Linux system, you’ve likely encountered version conflicts, especially when dealing with dependencies. I’ve seen this go wrong when trying to update a package, only to find that it breaks another package that depends on it. In my experience, apt remains a crucial tool for managing packages, and understanding how to use apt-mark and pinning can help avoid these kinds of dependency conflicts.

Troubleshooting Disk Usage Issues with Duplicate Files and Unnecessary Logs on Btrfs and Ext4 Filesystems

Sat, 06 Jun 2026 09:38:34 +0200

Introduction to Disk Usage Issues

I’ve seen disk usage issues plague even the most well-maintained Linux systems, often due to duplicate files and unnecessary logs. As of 2026, both Btrfs and Ext4 filesystems are widely used, each with their own set of tools and best practices for troubleshooting and resolving these issues. In this article, we’ll delve into practical steps for identifying and addressing duplicate files and unnecessary logs on both Btrfs and Ext4 filesystems, focusing on current tools and methodologies.

Taming systemd-resolved: Troubleshooting DNS leaks and resolving domain name surprises on Linux desktops and servers

Fri, 05 Jun 2026 10:35:34 +0200

Introduction to systemd-resolved

I’ve seen systemd-resolved become a crucial part of many Linux distributions, including Ubuntu, Debian, and Fedora, as of 2026. It’s designed to provide a robust and secure way to resolve domain names on Linux systems. However, like any complex system, it can sometimes behave unexpectedly, leading to DNS leaks and domain name resolution surprises.

Understanding DNS Leaks

A DNS leak occurs when your system sends DNS queries to an unintended DNS server, potentially revealing your browsing history and online activities to third parties. This can happen when your system is configured to use a specific DNS server, but systemd-resolved is not properly configured to respect this setting. Don’t bother with manually trying to diagnose DNS leaks - just use online tools such as dnsleaktest.com or ipleak.net to check for them.

Taming systemd-resolved: How to Configure DNS Settings for Split Horizon Environments

Thu, 04 Jun 2026 11:14:28 +0200

Introduction to systemd-resolved

I’ve seen many Linux admins struggle with configuring DNS settings for split horizon environments. systemd-resolved, a DNS resolver component of the systemd suite, can make life easier. In this article, I’ll walk you through how to configure DNS settings for split horizon environments using systemd-resolved.

Understanding Split Horizon Environments

Split horizon environments are network setups where multiple DNS servers provide different answers for the same domain name, depending on the client’s location or network. I’ve encountered this in organizations with multiple offices or data centers, where different DNS servers serve different locations. For example, a company with offices in the US and Europe might have two separate DNS servers, one for each region, providing different IP addresses for the same domain name.

Rescuing a Linux System Stuck in Emergency Mode: A Step-by-Step Recovery Guide

Wed, 03 Jun 2026 11:47:11 +0200

Introduction to Emergency Mode

I’ve seen this go wrong when a Linux system encounters a critical issue during boot - it may enter Emergency Mode. This mode provides a minimal environment for troubleshooting and recovery. With many Linux distributions, including Debian and Arch Linux, updating their boot processes to use systemd, understanding how to rescue a system stuck in Emergency Mode is crucial.

Identifying the Issue

To rescue a system in Emergency Mode, you first need to identify the cause of the issue. Don’t bother with guessing - check the system logs, which are usually available in the /var/log directory. I usually start with the journalctl command to view the system logs:

Troubleshooting Failed Mounts at Boot Time with systemd and fstab

Tue, 02 Jun 2026 09:15:54 +0200

Introduction to Troubleshooting Failed Mounts

When I’m dealing with a Linux system that won’t boot properly, one of the first things I check is the mount points. systemd and the /etc/fstab file are crucial in this process, but issues can still arise, leading to failed mounts and potential system instability. In this article, I’ll walk you through practical steps to troubleshoot and resolve failed mounts at boot time, focusing on systemd and fstab configurations.

Taming Disk-Hungry Logs with systemd-journald and logrotate

Mon, 01 Jun 2026 10:10:58 +0200

Introduction to Log Management

I’ve seen log files grow out of control and consume disk space, affecting system performance. To tame disk-hungry logs, I recommend using systemd-journald and logrotate. These tools help manage log data, making it easier to troubleshoot, debug, and perform security audits.

Understanding systemd-journald

systemd-journald is a system service that collects and stores log messages from various sources. It provides a centralized logging system, which I find more efficient than traditional text-based log files. To view log messages, use the journalctl command:

Rescuing a Broken Linux System with a systemd Emergency Mode Shell

Sun, 31 May 2026 08:26:25 +0200

Introduction to Emergency Mode

I’ve seen this go wrong when a Linux system encounters a critical issue during boot - it can be a real headache. But, thankfully, Linux has a built-in safety net called emergency mode. This mode kicks in when there’s a failed filesystem check or an inability to mount a necessary partition, providing a minimal environment for troubleshooting and repair. With the advancements in Linux, understanding how to use emergency mode is crucial for system administrators and users alike.

When Disk Space Disappears: Tracking Down and Preventing Logs from Filling Up Your Linux Disks

Sat, 30 May 2026 10:13:51 +0200

Introduction to Disk Space Issues

I’ve seen this go wrong when managing Linux systems - the sudden disappearance of disk space. It’s often caused by log files filling up the disk, large files being stored in unexpected locations, or even malware consuming disk space. In this article, I’ll focus on tracking down and preventing logs from filling up your Linux disks.

Understanding Log Files

Log files are essential for Linux system administration, providing valuable information about system events, errors, and security issues. However, if not properly managed, log files can grow rapidly and consume large amounts of disk space. The most common log files that can cause issues are:

Troubleshooting DNS Leaks with systemd-resolved and resolv.conf on a Small Linux Server

Fri, 29 May 2026 08:36:48 +0200

Introduction to DNS Leaks

I’ve seen DNS leaks cause issues on even the most secure Linux servers. Ensuring your DNS setup is solid is crucial, and one common problem is a DNS leak, where your system inadvertently reveals your DNS queries to unauthorized parties. In this article, I’ll walk you through troubleshooting DNS leaks using systemd-resolved and resolv.conf on a Linux server.

Understanding systemd-resolved

systemd-resolved is a powerful tool that provides DNS resolution capabilities. It’s designed to be a caching, validating DNS resolver that can also handle DNSSEC validation. To check if systemd-resolved is running on your system, use the following command:

Debugging systemd Service Startup Failures with systemd-analyze and Journalctl

Thu, 28 May 2026 11:31:56 +0200

Introduction to Debugging systemd Services

I’ve seen this go wrong when you’re trying to troubleshoot issues with your Linux system - those pesky systemd services can be a real pain. They’re the backbone of your system, managing everything from network connections to system logging. Debugging these services can be a daunting task, especially for those new to Linux administration. Fortunately, systemd provides two powerful tools to help you diagnose and resolve issues: systemd-analyze and journalctl.

Taming Split DNS Chaos with systemd-resolved and Local Hostname Resolution

Wed, 27 May 2026 08:34:11 +0200

Introduction to Split DNS Chaos

I’ve seen this go wrong when working with multiple networks or self-hosted services: split DNS configurations can become a real headache. Luckily, many Linux distributions have started adopting systemd-resolved as the default DNS resolver, which makes managing split DNS scenarios much simpler. In this article, I’ll walk you through how to use systemd-resolved for local hostname resolution and taming that split DNS chaos.

Understanding systemd-resolved

The real trick is understanding how systemd-resolved works. It’s a systemd component that provides DNS resolution and caching, and it can be configured to use multiple DNS servers and handle split DNS scenarios with ease. To check if systemd-resolved is enabled on your system, run the following command:

Reclaiming Disk Space from Unused Snapshot Copies on Btrfs Filesystems

Tue, 26 May 2026 08:09:16 +0200

Introduction to Btrfs Snapshots

I’ve worked with Btrfs for a while now, and one of its most useful features is snapshotting. This allows you to create a read-only copy of a subvolume at a given point in time, which is perfect for backups, testing, and rolling back changes. However, over time, these snapshot copies can accumulate and consume significant disk space. In practice, this can become a real issue if you’re not careful.

Troubleshooting Slow DNS Lookups with systemd-resolved and resolvectl

Mon, 25 May 2026 08:57:59 +0200

Introduction to Troubleshooting Slow DNS Lookups

I’ve seen slow DNS lookups bring Linux systems to a crawl, and with our increasing reliance on online services, efficient DNS resolution is crucial. This article focuses on troubleshooting slow DNS lookups using systemd-resolved and resolvectl, which are integral to many modern Linux distributions.

Understanding systemd-resolved

systemd-resolved is a system service that provides DNS resolution, replacing traditional implementations like glibc’s resolver. It offers improved security, better DNSSEC handling, and efficient management of multiple DNS servers. To check if it’s running on your system, use:

Taming systemd-resolved: Avoiding DNS Leaks and Surprises with Split DNS Configurations

Sun, 24 May 2026 10:21:18 +0200

Introduction to systemd-resolved

I’ve worked with Linux systems for years, and one thing that’s become increasingly important is DNS resolution. systemd-resolved is a DNS resolver component of the systemd suite, designed to provide a flexible and secure way to resolve domain names. It was introduced in systemd version 216, released in 2015, and has since become a standard component in many Linux distributions. By default, systemd-resolved uses a split DNS configuration, which can sometimes lead to DNS leaks and unexpected behavior. I’ve seen this go wrong when a system has multiple network interfaces or connections, each with its own DNS resolver configuration.

Using systemd to Manage and Rotate Log Files Without Running Out of Disk Space

Sat, 23 May 2026 11:26:20 +0200

Introduction to Log Rotation with systemd

I’ve seen log files consume entire disks, bringing systems to a grinding halt. That’s why log rotation is crucial - it ensures your logs don’t get out of control. With systemd, you’ve got a robust mechanism for managing and rotating logs. In this article, I’ll dive into using systemd for log rotation, covering its benefits, configuration, and some practical examples.

Understanding systemd’s Role in Log Rotation

systemd’s journald is a game-changer for log management. It collects and stores log messages from various sources, including systemd services, kernel messages, and other system components. This centralized logging system makes it easier to manage and rotate logs. By leveraging systemd’s capabilities, you can configure log rotation to suit your specific needs, keeping your system stable and secure.

Taming systemd-resolved: Tips for Troubleshooting and Customizing DNS Resolution on Linux

Fri, 22 May 2026 10:04:50 +0200

Introduction to systemd-resolved

I’ve been using systemd-resolved for a while now, and I have to say, it’s a big improvement over traditional DNS resolvers. As of 2026, many Linux distributions, including Ubuntu, Debian, and Fedora, have adopted systemd-resolved as the default DNS resolver. While it offers several benefits, including improved security and performance, some users may encounter issues or require customization to suit their specific needs. Don’t bother with trying to disable it, though - it’s usually worth the effort to get it working right.

Using rsync and systemd to Automate Offsite Backups of Selected Config Files and User Data

Thu, 21 May 2026 10:49:01 +0200

Introduction to Automated Offsite Backups

As a Linux user, you’ve probably learned the hard way how important it is to protect your configuration files and user data from loss or corruption. I’ve seen this go wrong when a disk fails or a configuration change goes awry. One way to ensure the integrity of this data is to set up automated offsite backups. In this article, we’ll explore how to use rsync and systemd to create a reliable and efficient backup system.

Troubleshooting Broken Dependencies After Adding a Third-Party Repository

Wed, 20 May 2026 09:28:17 +0200

Introduction to Dependency Troubleshooting

I’ve seen this go wrong when adding third-party repositories to a Linux system - it’s a great way to get the latest software, but it can also lead to broken dependencies and a whole lot of frustration. In this article, I’ll walk you through the practical steps to troubleshoot and resolve broken dependencies after adding a third-party repository.

Understanding Dependencies

Before we dive into troubleshooting, let’s take a step back and understand how dependencies work in Linux. Dependencies are packages that a particular package requires to function correctly. When you install a package, the package manager (such as apt or dnf) will automatically install any required dependencies. However, when adding third-party repositories, the package manager may not always be able to resolve dependencies correctly, leading to broken packages. Don’t bother with trying to manually resolve these dependencies - it’s a recipe for disaster.

Using jq to Parse and Manipulate JSON Logs from systemd-journald

Tue, 19 May 2026 08:58:34 +0200

Introduction to jq and systemd-journald

I’ve found that working with Linux systems often involves digging through logs to troubleshoot issues. systemd-journald is a key component in this process, collecting and storing log messages from various sources. Since these logs are often in JSON format, tools like jq become incredibly useful for parsing and manipulation. In this article, I’ll walk you through how to use jq to parse and manipulate JSON logs from systemd-journald.

Troubleshooting systemd Service Startup Failures with Dependency Ordering and Journalctl

Mon, 18 May 2026 10:30:29 +0200

Introduction to systemd Service Troubleshooting

I’ve seen this go wrong when services fail to start due to complex dependency ordering and logging issues. systemd, with its powerful tools for diagnosing problems, makes it easier to identify and fix these issues. In this article, we’ll focus on practical examples of using dependency ordering and journalctl to troubleshoot systemd service startup failures.

Understanding systemd Dependencies

systemd services are defined in unit files, typically located in /etc/systemd/system/ or /usr/lib/systemd/system/. These files specify the service’s dependencies, which are crucial for determining the order in which services start. Dependencies are defined using directives like Requires, Wants, Before, and After. For instance, a web server service might require the network service to be started before it can start itself.

Taming Log Rotation in systemd: A Practical Approach to Preventing Disk Bloat

Sun, 17 May 2026 10:14:26 +0200

Introduction to Log Rotation

I’ve seen this go wrong when log files grow out of control, filling up the disk and causing system instability. That’s why log rotation is a crucial aspect of Linux system maintenance. With many Linux distributions, including Debian and Arch Linux, adopting systemd as their default init system, understanding how to manage log rotation in a systemd environment is essential. In practice, this means getting familiar with systemd-journald, the component responsible for collecting and storing log messages.

Taming systemd Service Restart Behavior with RestartSec and TimeoutStartSec

Sat, 16 May 2026 08:13:26 +0200

Introduction to systemd Service Restart Behavior

I’ve seen this go wrong when a service fails and systemd keeps restarting it, causing more harm than good. To avoid this, it’s essential to understand how systemd handles service restarts. Systemd is a core component of most modern Linux distributions, responsible for managing system services, including their startup, runtime, and shutdown. One of the key aspects of systemd service management is its ability to automatically restart services that fail or terminate unexpectedly. However, this behavior can sometimes lead to unintended consequences, such as a service restarting indefinitely in a failed state. To mitigate this, systemd provides two important directives: RestartSec and TimeoutStartSec.

Taming Dependency Hell: Using apt-mark to Pin Packages in Debian-Based Systems

Fri, 15 May 2026 10:01:55 +0200

Introduction to Dependency Hell

I’ve seen this go wrong when you’re in the middle of a critical project and a package update breaks a dependency, causing system instability. In Debian-based systems, apt-mark is a useful tool for pinning packages and avoiding this kind of chaos. It’s not a silver bullet, but it can help prevent packages from being automatically removed or upgraded, which can cause conflicts.

What is apt-mark?

apt-mark is a command-line tool that allows you to mark packages as automatically installed or manually installed. This can be a lifesaver when you need to prevent a package from being automatically upgraded to a newer version that may cause conflicts. Don’t bother with trying to manually manage dependencies - apt-mark makes it easy to pin packages to a specific version.

Hardening SSH Access with Mandatory SSH Keys and Disabled Password Authentication

Thu, 14 May 2026 11:50:23 +0200

Introduction to SSH Hardening

Securing SSH access is a no-brainer for any Linux administrator. One effective way to harden SSH access is by using mandatory SSH keys and disabling password authentication. I’ve seen this go wrong when people don’t take the time to set it up properly, so let’s walk through the process.

Understanding SSH Keys

SSH keys are a pair of cryptographic keys used for authentication. The private key is stored on the client machine, while the public key is stored on the server. When a user attempts to connect to the server, the client uses the private key to encrypt a message, which is then decrypted by the server using the public key. If the decryption is successful, the user is granted access.

Using OpenSSL to Verify SSH Server Certificates on Linux Clients

Sat, 09 May 2026 08:45:28 +0200

Introduction to SSH Server Certificate Verification

As a Linux user, you’re probably no stranger to Secure Shell (SSH) and its importance in securely accessing remote servers. With the rise of SSH server certificates, I’ve seen this go wrong when not properly verified - it’s crucial to ensure the authenticity and integrity of your SSH connections. In this article, we’ll explore how to use OpenSSL to verify SSH server certificates on Linux clients.

Hardening SSH Access with Fail2Ban and Public Key Authentication on Debian-based Systems

Fri, 08 May 2026 09:01:29 +0200

Introduction to SSH Hardening

I’ve seen many Linux systems compromised due to weak SSH security, so I want to share my approach to hardening SSH access. As of 2026, SSH remains a vital tool for system administration, development, and self-hosting, but its widespread use also makes it a common target for brute-force attacks and unauthorized access attempts. To mitigate these risks, I recommend using Fail2Ban and Public Key Authentication to secure SSH on Debian-based systems.

Using OpenSSH Certificates for Easier and More Secure Server Access

Thu, 07 May 2026 10:25:40 +0200

Introduction to OpenSSH Certificates

I’ve seen many Linux admins struggle with managing SSH keys for their users. OpenSSH certificates are a game-changer here - they offer a more secure and convenient way to manage access to your Linux servers. By using certificates, you can avoid the hassle of managing individual SSH keys for each user and reduce the risk of key compromise.

Generating a Certificate Authority

To get started with OpenSSH certificates, you need to set up a Certificate Authority (CA). The CA will be used to sign and verify the certificates. I usually start with generating a CA key pair using the following command:

Hardening SSH Without Turning Your Server Into a Museum

Thu, 07 May 2026 03:02:48 +0200

Introduction to SSH Hardening

Securing your SSH server is one of the most critical tasks as a Linux administrator. I’ve seen this go wrong when systems are left vulnerable to unauthorized access. The recent high-profile vulnerabilities discovered in popular SSH implementations in 2025 serve as a reminder to keep your SSH server up to date and configured securely. In this article, we’ll discuss practical steps to harden your SSH server without making it overly restrictive.

Cybersecurity Risks in Containerized Linux Environments

Tue, 05 May 2026 13:34:20 +0200

Cybersecurity Risks in Containerized Linux Environments

As we continue to navigate the complex landscape of containerized Linux environments in 2026, it’s essential to reflect on the lessons learned from 2025 and adapt to the evolving cybersecurity threats. In 2025, we saw a significant increase in the adoption of containerization technologies, with many organizations leveraging Docker, Kubernetes, and other container orchestration tools to streamline their application deployment and management processes.

Containerization and Security

Containerization offers numerous benefits, including improved resource utilization, increased efficiency, and enhanced scalability. However, it also introduces new cybersecurity risks that must be addressed. In 2025, we witnessed several high-profile vulnerabilities, including CVE-2022-36104, which highlighted the importance of securing containerized environments.

Linux Distribution Support for TPM 2.0 Modules

Mon, 04 May 2026 09:33:35 +0200

Leveraging TPM 2.0 for Enhanced Linux Security

The Trusted Platform Module (TPM) 2.0 has become a cornerstone in modern computing, providing a secure environment for key storage, platform authentication, and cryptographic operations. As a Senior Linux Security Architect, I’ll delve into the support for TPM 2.0 modules in various Linux distributions, exploring the technical implementation, security benefits, and potential vulnerabilities.

Introduction to TPM 2.0

TPM 2.0 is a specification defined by the Trusted Computing Group (TCG), aiming to provide a standardized, vendor-agnostic interface for trusted computing. The module itself is a dedicated hardware component, typically a chip or a firmware-based implementation, responsible for managing cryptographic keys, storing platform measurements, and providing attestation services.

Securing SSH with FIDO2 and Physical Security Keys on Fedora

Mon, 04 May 2026 01:39:33 +0200

Introduction to Securing SSH with FIDO2 and Physical Security Keys

Securing SSH connections is crucial for preventing unauthorized access to Linux systems. Recently, there has been an increase in attacks targeting SSH, including CVE-2022-42010, which allows attackers to bypass authentication using a malicious SSH server. To mitigate such risks, using FIDO2 and physical security keys can significantly enhance the security of SSH connections. In this blog post, we will explore how to secure SSH with FIDO2 and physical security keys on Fedora.

Kali Linux

Thu, 23 Jan 2025 00:00:00 +0000

Kali Linux is a specialized Linux distribution designed for penetration testing, security research, computer forensics, and reverse engineering. Developed and maintained by Offensive Security, Kali Linux has become a go-to platform for ethical hackers and security professionals worldwide. It comes preloaded with a vast array of tools tailored to meet the diverse needs of the cybersecurity domain.

Features and Highlights

Kali Linux stands out from other distributions due to its unique features:

Application-Level Firewalls

Wed, 22 Jan 2025 00:00:00 +0000

In the world of network security, firewalls play a critical role in protecting systems from unauthorized access and malicious traffic. They are a fundamental component of any secure network infrastructure. However, not all firewalls are created equal, and understanding the differences between application-level firewalls and IP-level firewalls is crucial for building an effective defense strategy.

In this post, we’ll explore the key distinctions between these two types of firewalls, with a particular focus on the advantages of application-level firewalls. Let’s break down the basic concepts first.

AppArmor

Sat, 18 Jan 2025 00:00:00 +0000

AppArmor (Application Armor) is a Linux Security Module (LSM) that provides a practical, easy-to-use Mandatory Access Control (MAC) framework for restricting the capabilities of applications. Unlike SELinux, which relies on complex policies, AppArmor simplifies security by using profile-based access control.

Key Features

Profile-Based Access Control: AppArmor restricts application behavior based on predefined profiles.
Path-Based Security Policies: Unlike SELinux, which uses labels, AppArmor policies are based on file paths.
Learning Mode: Allows administrators to create security profiles by observing application behavior.
Fine-Grained Access Control: Provides detailed permission controls over file access, network connections, and capabilities.
User-Friendly Management: Easier to configure and deploy compared to SELinux.

How AppArmor Works

AppArmor uses security profiles that define which files, capabilities, and network accesses an application is allowed. These profiles are enforced at the kernel level, restricting an application’s ability to perform unauthorized actions.

Landlock

Tue, 14 Jan 2025 00:00:00 +0000

Landlock is a Linux Security Module (LSM) that provides a flexible, unprivileged sandboxing mechanism for applications. Unlike traditional LSMs such as SELinux and AppArmor, which enforce mandatory access control policies set by system administrators, Landlock allows applications to define their own security restrictions. This makes it a powerful tool for developers seeking to add additional security layers without requiring elevated privileges.

Key Features

Unprivileged Sandboxing: Landlock enables applications to apply security restrictions without requiring root access or administrative intervention.
Filesystem Access Control: Developers can define which files and directories an application can access.
Incremental Restrictions: A process can only tighten its access permissions over time, preventing privilege escalation.
Composability: Can be used in combination with other LSMs such as SELinux and AppArmor for enhanced security.
User-Space Control: Allows developers to enforce security policies dynamically within their applications.

How Landlock Works

Landlock uses a set of security rules that define what resources an application can access. These rules are enforced at the kernel level and prevent applications from performing unauthorized actions. Unlike traditional access control mechanisms, Landlock works on a per-process basis, meaning individual applications can define and enforce their own security policies without affecting the rest of the system.

Linux Security Modules

Sat, 04 Jan 2025 00:00:00 +0000

Linux Security Modules (LSM)

Linux Security Modules (LSM) is a framework that allows different security models to be implemented as kernel modules. It provides the necessary hooks within the Linux kernel for implementing access control mechanisms beyond the traditional Unix permissions model. Several LSMs are available, each with different use cases and security policies.

SELinux

Security-Enhanced Linux (SELinux) is one of the most well-known Linux Security Modules. Developed by the NSA, SELinux enforces Mandatory Access Control (MAC) policies, restricting processes and users based on predefined security policies.

Exim

Thu, 02 Jan 2025 00:00:00 +0000

Exim is a powerful and flexible Mail Transfer Agent (MTA) used for handling email traffic on Unix-like systems, including Linux. Originally developed at the University of Cambridge, Exim is designed to be highly configurable while maintaining strong security features. It is commonly used as an alternative to Postfix and Sendmail, offering more advanced routing and filtering capabilities.

Key Features

1. Flexible Configuration

Exim allows for highly customizable mail routing and filtering. Administrators can define complex mail-handling rules, making it ideal for specialized email requirements.

Honeypots

Fri, 23 Aug 2024 00:00:00 +0000

Honeypots in Computer Security

Honeypots are important tools in computer security that can help organizations detect and respond to attacks. A honeypot is a system or network that is designed to look like a real target, but is actually used to monitor and analyze attacks. Honeypots can be used to gain insight into attackers’ tactics, techniques, and procedures, and can help organizations improve their security posture.

Detection of Attacks

One of the key benefits of honeypots is that they allow organizations to detect attacks that might otherwise go unnoticed. By mimicking real systems and applications, honeypots can attract attackers who are looking for vulnerabilities to exploit. This can help organizations identify new types of attacks and vulnerabilities that they may not have been aware of previously.

Podman

Sun, 31 Mar 2024 00:00:00 +0000

Introduction

Podman is an alternative to Docker, providing a similar interface. Podman allows users to create and manage containers on a Linux system. One of the challenges with containerization is the need to run containers as the root user, which can pose a security risk. One solution to this problem is to use user namespaces with Podman. In this article, we will explore what user namespaces are, how they can be used with Podman, and how to run a container as root inside the container while being non-root outside the container.

Containers and SELinux

Fri, 31 Mar 2023 00:00:00 +0000

Introduction

Linux containers provide a lightweight and efficient way to run multiple isolated environments on a single host. While containers offer many benefits, such as improved resource utilization and faster application deployment, there are also security concerns that must be considered. One security implementation that can be used with containers is SELinux. In this article, we will explore some of the security features of SELinux and how they can be used to secure Linux containers.

Linux Security

Sat, 25 Mar 2023 00:00:00 +0000

Introduction

As a widely used operating system, Linux is often targeted by hackers and malicious actors. Therefore, it is crucial to harden Linux to make it more secure. Hardening Linux involves taking a series of measures to minimize vulnerabilities, prevent attacks, and mitigate the impact of successful attacks. By implementing these measures, Linux administrators can reduce the risk of data breaches, system disruptions, and other security incidents.

Securing the Linux Kernel

The Linux kernel is the core of the operating system, and securing it is essential for overall system security. To harden the kernel, administrators can implement various measures, such as disabling unnecessary modules, setting kernel parameters, and enabling security features like SELinux or AppArmor. Administrators should also regularly update the kernel to patch known vulnerabilities and apply security fixes.

Seccomp

Sat, 25 Mar 2023 00:00:00 +0000

Introduction: Understanding Seccomp

Seccomp is a Linux kernel feature that enables administrators to restrict the actions that a process can perform, thus providing an additional layer of security. It stands for “secure computing mode” and was first introduced in the 2.6.12 kernel. Seccomp is a powerful tool for enhancing the security of a Linux system, as it helps to mitigate the risks of exploitation from untrusted code and malware.

How Seccomp Works

Seccomp works by limiting the system calls that a process can make. It does this by providing a list of allowed system calls that a process can make, and any system call not on this list is blocked. This list is often referred to as a “filter.” Seccomp operates in two modes: strict mode and filter mode. In strict mode, all system calls except for a whitelist of explicitly allowed ones are blocked. In filter mode, only the system calls explicitly listed in the filter are allowed, with all others being blocked.

VMs and SELinux

Sat, 25 Mar 2023 00:00:00 +0000

Introduction

Libvirt is an open-source tool used for managing virtual machines on Linux systems. One of the challenges with virtualization is ensuring that the host system and virtual machines are secure. SELinux, or Security-Enhanced Linux, is a security module that can be used to add an additional layer of security to both the host system and virtual machines. In this article, we will explore how SELinux can be used to protect the host and virtual machines.

Rootkits on Linux

Thu, 23 Mar 2023 00:00:00 +0000

Rootkits on Linux: A Threat to System Security

A rootkit is a type of malicious software that allows an attacker to gain privileged access to a computer system. This access can be used to steal sensitive information, install additional malware, or carry out other malicious activities. Rootkits on Linux can be particularly dangerous, as they can go undetected for long periods of time and allow an attacker to gain complete control over the system. In this article, we will discuss the threat of rootkits on Linux and how to prevent them using rkhunter.

SELinux

Thu, 23 Mar 2023 00:00:00 +0000

SELinux: Enhancing System Security

SELinux stands for Security-Enhanced Linux, which is a security module implemented in the Linux kernel. It provides an additional layer of security by enforcing mandatory access control policies on top of the traditional discretionary access control mechanisms provided by the Linux kernel. SELinux was developed by the National Security Agency (NSA) and external contributors in collaboration with Red Hat and has been integrated into various Linux distributions, including Red Hat Enterprise Linux, Rocky Linux, AlmaLinux, and Fedora.

KVM

Wed, 22 Mar 2023 00:00:00 +0000

Introduction

The Linux Kernel Virtual Machine (KVM) is a hypervisor that allows multiple virtual machines to run on a single Linux host machine. KVM is an open-source technology that is integrated into the Linux kernel and supports various hardware platforms, including x86, ARM, and PowerPC.

In this article, we will discuss the key features and benefits of KVM, how it works, and how to install and configure KVM on a Linux machine.

Linux on Linux Security

Using systemd-resolved to Tame DNS Lookup Surprises on Multi-Homed Linux Machines

Introduction to systemd-resolved

Recovering from a Botched Package Upgrade with apt and snapshotting

Introduction to Recovery

Troubleshooting DNS Leaks with systemd-resolved and resolv.conf

Introduction to DNS Leaks

Understanding systemd-resolved

Extracting Valuable Data from Systemd Journal Logs with jq and grep

Introduction to Systemd Journal Logs

Taming Disk Space Usage with find and xargs in a Busy /var/log Directory

Introduction to Disk Space Management

Taming Disk Space Usage with btrfs Snapshots and Automatic Pruning

Introduction to btrfs Snapshots

Creating Snapshots

Troubleshooting Slow systemd Service Restarts with systemd-analyze

Introduction to systemd-analyze

Understanding systemd-analyze

Taming SSH Config Chaos: Organizing Your SSH Client Settings for Multiple Servers and Identities

Taming SSH Config Chaos

Understanding SSH Config Files

Using SSH to Tunnel Traffic Through a Jump Host for Secure Access to a Remote Network

Introduction to SSH Tunneling

Using Third-Party Repositories Without Polluting Your Package Manager

Introduction to Third-Party Repositories

Understanding the Risks

Resolving the "Unknown Host" Headache: Troubleshooting DNS Issues with systemd-resolved and resolv.conf

Introduction to DNS Troubleshooting

Troubleshooting Btrfs Snapshot Overfill with systemd Timers and Log Rotation

Introduction to Btrfs Snapshots

Troubleshooting Systemd Service Boot Delays with systemd-analyze

Introduction to Systemd Service Boot Delays

Using SSH Keys with Multiple Identities and Agents for Simplified Remote Access

Introduction to SSH Keys and Agents

Generating SSH Keys

Mastering SSH Connection Sharing with ControlMaster and ControlPersist

Introduction to SSH Connection Sharing

Using pgrep and pkill to Simplify Process Management and Avoid Common Mistakes with background Tasks

Introduction to pgrep and pkill

Simplifying Remote File Transfers with SSH and rsync Over a Jump Host

Introduction to Remote File Transfers

Taming Log Rotation: Preventing Disk Space Issues with systemd-journald and Log File Management

Introduction to Log Rotation

Taming Log Rotation: Strategies for Preventing /var/log Overflow on Busy Systems

Introduction to Log Rotation

Understanding Log Rotation

Taming systemd Service Restart Behavior: When to Use Restart, Retry, and Timeout Options

Introduction to systemd Service Restart Behavior

Troubleshooting Broken Permissions on Shared Directories with setgid and ACLs

Introduction to Shared Directory Permissions

Using systemd-resolved with Multiple DNS Servers and Split Horizon DNS

Introduction to systemd-resolved

Taming Dependency Chaos: Using apt-mark to Pin Packages in Debian-Based Systems

Introduction to Dependency Management

Taming systemd Restart Policies to Prevent Service Chaos

Introduction to systemd Restart Policies

Troubleshooting Local Port Conflicts with ss and nftables on a Multi-Service Linux Server

Introduction to Troubleshooting Local Port Conflicts

Troubleshooting DNS Leaks with systemd-resolved and resolv.conf

Introduction to DNS Leaks

Understanding systemd-resolved

Resolving DNS Issues with resolvectl and systemd-resolved in a Home Network

Introduction to DNS Resolution

Understanding systemd-resolved

Troubleshooting Slow Network Connectivity with ss and resolvectl on Linux

Introduction to Network Troubleshooting

Understanding ss

Taming Disk-Hungry Logs with systemd's Persistent Journal and Log Rotation

Introduction to Log Management

Understanding systemd’s Journal

Using systemd to Manage and Rotate Logs for Forgotten System Services

Introduction to Log Management with systemd

Understanding systemd Logs

Resolving Dependency Conflicts When Mixing Third-Party Repositories with Distribution Packages

Introduction to Dependency Conflicts

Understanding Dependency Conflicts

Troubleshooting Poor Video Performance on Linux Laptops with Hybrid Graphics and Wayland

Introduction to Troubleshooting

Taming systemd Timer Services to Run Your Daily Backup at a Reasonable Hour

Introduction to systemd Timer Services

Understanding `ss`