# Numeric method (octal)
chmod 755 script.sh      # rwxr-xr-x (owner: full, others: read+execute)
chmod 644 document.txt   # rw-r--r-- (owner: read+write, others: read-only)
chmod 700 private/       # rwx------ (owner-only access)
chmod 600 secrets.txt    # rw------- (owner can read/write, no one else)
 
# Symbolic method (more flexible)
chmod u+x script.sh      # Add execute for owner (user)
chmod g+w file.txt       # Add write for group
chmod o-r file.txt       # Remove read for others
chmod a+r file.txt       # Add read for all (a = all = ugo)
 
# Multiple changes at once
chmod u+rwx,g+rx,o+r file.txt  # Owner: full, group: read+execute, others: read
 
# Set exact permissions (= instead of +/-)
chmod u=rwx,g=rx,o=r file.txt  # Same as 754
 
# Copy permissions from one category to another
chmod g=u file.txt       # Group gets same permissions as owner
 
# Recursive (apply to directory and all contents)
chmod -R 755 project/
 
# Recursive for files and directories differently
find project/ -type f -exec chmod 644 {} \;   # Files: 644
find project/ -type d -exec chmod 755 {} \;   # Directories: 755
 
# Add execute permission to all .sh files
chmod +x *.sh
 
# Remove write permission for group and others
chmod go-w *
 
# Make file readable by everyone, writable only by owner
chmod 644 document.txt
# Or symbolically:
chmod u=rw,go=r document.txt
 

# Web server files
chmod 644 *.html *.css *.js     # Web assets
chmod 755 cgi-bin/*.cgi         # CGI scripts
chmod 600 config/database.php   # Database credentials
 
# SSH keys (must be restricted!)
chmod 700 ~/.ssh                # SSH directory
chmod 600 ~/.ssh/id_rsa         # Private key
chmod 644 ~/.ssh/id_rsa.pub     # Public key
chmod 644 ~/.ssh/authorized_keys # Authorized keys
chmod 644 ~/.ssh/known_hosts    # Known hosts
 
# Shell scripts
chmod +x script.sh              # Make executable
chmod 755 /usr/local/bin/myscript  # System-wide script
 
# Log files
chmod 640 /var/log/myapp.log    # Owner+group read, owner write
 
# Shared project directory
chmod 775 shared_project/        # Owner+group can do everything
 

# Change owner
sudo chown alice file.txt
 
# Change owner and group
sudo chown alice:staff file.txt
 
# Change group only
sudo chown :staff file.txt
# Or use chgrp:
sudo chgrp staff file.txt
 
# Recursive (directory and all contents)
sudo chown -R alice:staff project/
 
# Follow symbolic links (change link targets, not links)
sudo chown -L alice file.txt
 
# Change from one user to another (security cleanup)
sudo chown -R newuser:newuser --from=olduser:olduser /var/www/
 
# Verbose: show what's being changed
sudo chown -v alice file.txt
# Output: changed ownership of 'file.txt' from root to alice
 
# Reference file (copy ownership from another file)
sudo chown --reference=template.txt newfile.txt
 

# Fix ownership after sudo operations
sudo chown -R $USER:$USER ~/myproject
 
# Set up web server files
sudo chown -R www-data:www-data /var/www/html
 
# Give ownership to a specific user
sudo chown -R bob:developers /opt/project
 
# Change ownership of all files owned by old user
sudo find /home -user olduser -exec chown newuser {} \;
 

# Basic syntax: find [path] [tests] [actions]
 
# Find by name (case-sensitive)
find /home -name "report.txt"
find . -name "*.py"
 
# Case-insensitive name search
find . -iname "readme*"
 
# Find by type
find . -type f          # Regular files only
find . -type d          # Directories only
find . -type l          # Symbolic links only
find . -type b          # Block devices
find . -type c          # Character devices
 
# Find by size
find . -size +100M      # Files larger than 100MB
find . -size -1k        # Files smaller than 1KB
find . -size 50M        # Files exactly 50MB
find /var/log -size +1G # Huge log files
 
# Find by modification time
find . -mtime -7        # Modified in the last 7 days
find . -mtime +30       # Modified more than 30 days ago
find . -mtime 0         # Modified today
find . -mmin -60        # Modified in the last 60 minutes
 
# Find by access time
find . -atime -1        # Accessed in the last 24 hours
 
# Find by change time (metadata change)
find . -ctime -7        # Changed in the last 7 days
 
# Find by permissions
find . -perm 644        # Exact match
find . -perm -u+x       # At least owner execute
find . -perm /u+w       # Owner has write (any)
 
# Find by owner
find . -user alice
find . -group staff
find /home -user bob -group developers
 
# Find empty files/directories
find . -empty
find /tmp -type f -empty  # Empty files only
 
# Find by depth
find . -maxdepth 2 -name "*.txt"  # Only 2 levels deep
find . -mindepth 2 -name "*.log"  # At least 2 levels deep
 
# Combine criteria (AND by default)
find . -name "*.log" -size +10M -mtime +30
# Finds .log files larger than 10MB, modified more than 30 days ago
 
# OR criteria
find . -name "*.jpg" -o -name "*.png"
find . \( -name "*.txt" -o -name "*.md" \) -size +1M
 
# NOT criteria
find . ! -name "*.tmp"
find . -not -name "*.log"
 
# Exclude directories
find . -name "*.py" -not -path "*/venv/*"
find . -name "*.js" -not -path "*/node_modules/*"
 

# Delete found files (BE CAREFUL!)
find /tmp -name "*.tmp" -mtime +7 -delete
 
# Execute a command on each found file
find . -name "*.txt" -exec cat {} \;
find . -name "*.sh" -exec chmod +x {} \;
# {} is replaced with the found filename
# \; ends the -exec command
 
# Execute with confirmation (interactive)
find . -name "*.log" -ok rm {} \;
# Asks: < rm ... ./file.log > ? y
 
# Execute multiple commands
find . -name "*.txt" -exec echo "Processing: {}" \; -exec wc -l {} \;
 
# Use + instead of \; to pass multiple files at once (faster)
find . -name "*.txt" -exec grep "pattern" {} +
# Equivalent to: grep "pattern" file1.txt file2.txt file3.txt
 
# Print with details (like ls -l)
find . -name "*.py" -ls
 
# Print full path
find . -name "*.txt" -print
# Or with null separator (safe for filenames with spaces)
find . -name "*.txt" -print0
 
# Use xargs for better performance (handles spaces correctly)
find . -name "*.txt" -print0 | xargs -0 grep "error"
find . -type f -name "*.log" -print0 | xargs -0 gzip
 

# Find and count all Python files
find . -name "*.py" | wc -l
 
# Find large log files and compress them
find /var/log -name "*.log" -size +100M -exec gzip {} \;
 
# Find files not accessed in 90 days and archive
find /data -type f -atime +90 -exec mv {} /archive/ \;
 
# Find broken symbolic links
find . -type l ! -exec test -e {} \; -print
 
# Find duplicate files by size (first pass)
find . -type f -exec ls -lS {} + | awk '{print $5, $NF}' | sort -n
 
# Find world-writable files (security audit)
find / -perm -002 -type f -print 2>/dev/null
 
# Find SetUID/SetGID programs (security audit)
find / -perm /6000 -type f -ls 2>/dev/null
 
# Find all shell scripts
find . -type f -name "*.sh" -o -name "*.bash"
 
# Find files owned by specific user
find /home -user olduser -exec chown newuser:newuser {} +
 
# Find and remove empty directories
find . -type d -empty -delete
 
# Find files modified between two dates
find . -type f -newermt "2024-01-01" ! -newermt "2024-02-01"
 
# Find files by inode number (useful after accidental deletion)
find . -inum 123456
 

# Update the database first (run daily via cron usually)
sudo updatedb
 
# Search for a file
locate report.txt
 
# Case-insensitive search
locate -i readme
 
# Count matches
locate -c "*.py"
 
# Show only existing files (database might be stale)
locate -e report.txt
 
# Limit number of results
locate -l 10 "*.log"
 
# Show database statistics
locate -S
 
# Use basic regex
locate -r "report.*\.pdf$"
 
# Match only basename (not full path)
locate -b "\report.txt"
 

# Fast search for filenames
locate nginx.conf
 
# Comprehensive real-time search with criteria
find / -name "nginx.conf" -type f -newer /tmp/marker 2>/dev/null
 

# Find where a command's binary is
which python
# /usr/bin/python
 
which ls
# /usr/bin/ls
 
which -a python
# Show ALL occurrences in PATH
# /usr/bin/python
# /usr/local/bin/python
 
# Find binary, source, and manual pages
whereis ls
# ls: /usr/bin/ls /usr/share/man/man1/ls.1.gz
 
whereis python
# python: /usr/bin/python /usr/lib/python3.10 /usr/share/man/man1/python.1.gz
 
# Show how the shell interprets a command
type cd
# cd is a shell builtin
 
type ls
# ls is aliased to 'ls --color=auto'
 
type python
# python is /usr/bin/python
 
type -a python
# Show all definitions
# python is /usr/bin/python
# python is /usr/local/bin/python
 
type -t ls
# Show type only: alias, keyword, function, builtin, file
# alias
 

# Verify which Python you're using
which python && python --version
 
# Find all installed versions of a program
whereis -b python
 
# Check if a command is available
if command -v docker &> /dev/null; then
    echo "Docker is installed"
fi
 
# Find what conflicts with your script name
type -a mycommand
 

# Show disk space for all filesystems
df
 
# Human-readable sizes (KB, MB, GB)
df -h
 
# Show specific filesystem
df -h /home
 
# Show filesystem type
df -hT
 
# Show only local filesystems (exclude network mounts)
df -hl
 
# Show inodes instead of blocks
df -i
 
# Show only specific filesystem type
df -t ext4
 
# Exclude specific filesystem type
df -x tmpfs
 
# Total summary
df -h --total
 

# Check root filesystem usage
df -h /
 
# Alert if filesystem is >90% full
df -h | awk '$5+0 > 90 {print "WARNING: " $0}'
 
# Monitor specific mount point
df -h /var/log
 
# Check all ext4 filesystems
df -hT | grep ext4
 

# Size of current directory (summary)
du -sh .
 
# Size of each item in current directory
du -sh *
 
# Size with depth limit (show top-level only)
du -h --max-depth=1
 
# Size with depth=2
du -h --max-depth=2
 
# Find the 10 largest directories
du -h --max-depth=1 | sort -hr | head -10
 
# Size of a specific directory
du -sh /var/log
 
# Exclude certain patterns
du -sh --exclude="*.log" /var
 
# Show grand total at the end
du -ch /var/log | tail -1
 
# All files, not just directories
du -ah
 
# Apparent size (actual file size, not disk blocks)
du -sh --apparent-size file.txt
 
# Show timestamps
du -h --time /var/log/*
 

# Find what's eating disk space
du -h /home | sort -hr | head -20
 
# Disk usage by file type
find . -name "*.log" -exec du -ch {} + | tail -1
find . -name "*.mp4" -exec du -ch {} + | tail -1
 
# Space used by Docker
sudo du -sh /var/lib/docker
 
# Find large directories in /var
sudo du -h /var | grep "^[0-9\.]*G"
 
# Compare sizes before and after cleanup
du -sh project/ > before.txt
# ... cleanup operations ...
du -sh project/ > after.txt
diff before.txt after.txt
 
# Disk usage excluding hidden files
du -sh --exclude=".*" ~