BAB 17 - PERINTAH DASAR

grep - Search Text Patterns

Opsi Penting:

Bash - grep Examples
# Basic search
$ grep "error" log.txt

# Case insensitive
$ grep -i "error" log.txt

# Show line numbers
$ grep -n "error" log.txt

# Recursive search
$ grep -r "error" /var/log/

# Invert match (show non-matching)
$ grep -v "info" log.txt

# Count matches
$ grep -c "error" log.txt

# List files with matches
$ grep -l "error" *.log

# Match whole word
$ grep -w "error" file.txt

# Extended regex (multiple patterns)
$ grep -E "error|warning|critical" log.txt

# Show context (3 lines before and after)
$ grep -C 3 "error" log.txt

# Show lines after match
$ grep -A 5 "error" log.txt

# Show lines before match
$ grep -B 5 "error" log.txt

# Colorized output
$ grep --color "error" log.txt

# Search for IP addresses
$ grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" log.txt

# Search for email addresses
$ grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" file.txt

# Search and count unique
$ grep "error" log.txt | sort | uniq -c

# Search with multiple files
$ grep "error" file1.txt file2.txt

# Search in specific file types
$ grep -r --include="*.log" "error" /var/log/

# Exclude file types
$ grep -r --exclude="*.bak" "pattern" /dir/

# Recursive with line numbers
$ grep -rn "error" /var/log/

# Case insensitive recursive
$ grep -ri "error" /var/log/

find - Search for Files

Opsi Penting:

Bash - find Examples
# Find file by name
$ find . -name "file.txt"

# Find case insensitive
$ find . -iname "file.txt"

# Find by pattern
$ find . -name "*.txt"
$ find . -name "*.log"

# Find directories only
$ find . -type d

# Find files only
$ find . -type f

# Find by size (greater than 10MB)
$ find . -size +10M

# Find by size (less than 1KB)
$ find . -size -1k

# Find files modified in last 7 days
$ find . -mtime -7

# Find files modified more than 30 days ago
$ find . -mtime +30

# Find files accessed in last 24 hours
$ find . -atime -1

# Find files by user
$ find . -user kali

# Find files by group
$ find . -group users

# Find files with specific permissions
$ find . -perm 755
$ find . -perm -u+r

# Limit search depth
$ find . -maxdepth 2 -name "*.txt"

# Find and execute command
$ find . -name "*.tmp" -exec rm {} \;
$ find . -name "*.log" -exec ls -lh {} \;

# Find and delete
$ find . -name "*.tmp" -delete

# Find empty files
$ find . -type f -empty

# Find empty directories
$ find . -type d -empty

# Find and display with details
$ find . -name "*.txt" -ls

# Find with multiple conditions
$ find . -name "*.log" -size +1M -mtime -7

# Find and count
$ find . -name "*.txt" | wc -l

# Find and copy
$ find . -name "*.txt" -exec cp {} /backup/ \;

# Find with OR condition
$ find . \( -name "*.txt" -o -name "*.log" \)

# Find with NOT condition
$ find . -not -name "*.tmp"

# Find and change permissions
$ find . -name "*.sh" -exec chmod +x {} \;

# Find large files and sort by size
$ find . -type f -exec ls -s {} \; | sort -n | tail -10

Kombinasi grep dan find

Bash - Combined grep and find
# Find files and search content
$ find . -name "*.log" -exec grep "error" {} \;

# Find files and search with line numbers
$ find . -name "*.log" -exec grep -n "error" {} \;

# Find and count matches
$ find . -name "*.log" -exec grep -c "error" {} \;

# Find files containing pattern
$ find . -name "*.log" -exec grep -l "error" {} \;

# Find and display with context
$ find . -name "*.log" -exec grep -C 2 "error" {} \;

# Find large files and search
$ find . -size +10M -name "*.log" -exec grep "error" {} \;

# Find recent files and search
$ find . -mtime -1 -name "*.log" -exec grep "error" {} \;

# Find and replace in files
$ find . -name "*.txt" -exec sed -i 's/old/new/g' {} \;

# Find and delete files with pattern
$ find . -name "*.tmp" -exec grep -l "pattern" {} \; | xargs rm

# Find and archive
$ find . -name "*.log" -exec tar -rvf logs.tar {} \;

Bash - Search Tips
# Use -print0 and xargs -0 for safe file handling
$ find . -name "*.txt" -print0 | xargs -0 grep "pattern"

# Use grep -r instead of find + grep for simple cases
$ grep -r "pattern" /path/

# Exclude directories
$ grep -r --exclude-dir=".git" "pattern" .

# Use find with -exec + for better performance
$ find . -name "*.log" -exec grep -H "error" {} +

# Use ripgrep (rg) for faster searching
$ sudo apt install ripgrep
$ rg "pattern" /path/

# Use fd for faster file finding
$ sudo apt install fd-find
$ fdfind "pattern" /path/

Konsep Permission

Linux menggunakan sistem permission yang ketat untuk mengontrol akses ke file dan direktori. Memahami permission sangat penting untuk keamanan sistem.

Tiga Jenis Permission

Tiga Kategori User

Memahami Permission String

Permission String Format
# Format: [type][owner][group][others]
# Example: -rwxr-xr--

# Breakdown:
# -        = file type (- = file, d = directory, l = link)
# rwx      = owner permissions (read, write, execute)
# r-x      = group permissions (read, execute)
# r--      = others permissions (read only)

# Examples:
-rw-r--r--  file with rw for owner, r for group and others
-rwxr-xr-x  executable file
drwxr-xr-x  directory
-rwx------  executable, owner only
-rw-------  private file (owner read/write only)

chmod - Change File Permissions

Mode Formats:

Numeric Values:

Bash - chmod Examples
# Numeric mode
$ chmod 755 script.sh
# rwxr-xr-x (owner: rwx, group: r-x, others: r-x)

$ chmod 644 file.txt
# rw-r--r-- (owner: rw-, group: r--, others: r--)

$ chmod 600 private.txt
# rw------- (owner: rw-, group: ---, others: ---)

$ chmod 700 private_dir/
# rwx------ (owner: rwx, group: ---, others: ---)

# Symbolic mode
$ chmod u+x script.sh
# Add execute permission for owner

$ chmod g+w file.txt
# Add write permission for group

$ chmod o-r file.txt
# Remove read permission for others

$ chmod u=rwx,g=rx,o=r file.txt
# Set specific permissions

$ chmod a+r file.txt
# Add read for all (a = all)

$ chmod a-x script.sh
# Remove execute for all

# Recursive
$ chmod -R 755 directory/

# Common permission sets
$ chmod 755 directory/    # Standard directory
$ chmod 644 file.txt      # Standard file
$ chmod 700 ~/.ssh        # SSH directory
$ chmod 600 ~/.ssh/id_rsa # SSH private key
$ chmod 644 ~/.ssh/id_rsa.pub # SSH public key

# Copy permissions from another file
$ chmod --reference=file1.txt file2.txt

# Change permissions with verbose
$ chmod -v 755 script.sh
mode of 'script.sh' retained as 0755 (rwxr-xr-x)

# Change only if different
$ chmod -c 755 script.sh

chown - Change Owner and Group

Bash - chown Examples
# Change owner
$ sudo chown user file.txt

# Change owner and group
$ sudo chown user:group file.txt

# Change group only
$ sudo chown :group file.txt

# Recursive
$ sudo chown -R user:group directory/

# Change owner to match another file
$ sudo chown --reference=file1.txt file2.txt

# Verbose
$ sudo chown -v user:group file.txt
changed ownership of 'file.txt' from root:root to user:group

# Change only if different
$ sudo chown -c user:group file.txt

# Recursive with verbose
$ sudo chown -Rv user:group directory/

chgrp - Change Group

Bash - chgrp Examples
# Change group
$ sudo chgrp group file.txt

# Recursive
$ sudo chgrp -R group directory/

# Verbose
$ sudo chgrp -v group file.txt

Special Permissions

Bash - Special Permissions
# SetUID
$ chmod u+s file
$ chmod 4755 file

# SetGID
$ chmod g+s file
$ chmod 2755 file

# Sticky bit (commonly on /tmp)
$ chmod +t directory
$ chmod 1777 directory

# Remove special permissions
$ chmod u-s file
$ chmod g-s file
$ chmod -t directory

# Check special permissions
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root ... /usr/bin/passwd
# 's' indicates SetUID

$ ls -ld /tmp
drwxrwxrwt 1 root root ... /tmp
# 't' indicates sticky bit

umask - Default Permissions

Bash - umask Examples
# Check current umask
$ umask
0022

# umask symbolic
$ umask -S
u=rwx,g=rx,o=rx

# Set umask
$ umask 022
# Files: 644 (rw-r--r--)
# Directories: 755 (rwxr-xr-x)

$ umask 077
# Files: 600 (rw-------)
# Directories: 700 (rwx------)

# Set umask temporarily
$ umask 027

# Set umask permanently (add to ~/.bashrc)
$ echo "umask 027" >> ~/.bashrc

# Test new file creation
$ touch test.txt
$ ls -l test.txt
-rw-r----- 1 user group ... test.txt

Konsep User dan Group

Linux adalah sistem multi-user, memungkinkan banyak user menggunakan sistem secara bersamaan. Setiap user memiliki home directory, permission, dan resource sendiri. Group digunakan untuk mengelola permission secara kolektif.

File-file Penting

useradd - Add User

Opsi Penting:

Bash - useradd Examples
# Basic user creation
$ sudo useradd -m username

# Create with specific shell
$ sudo useradd -m -s /bin/bash username

# Create with full name
$ sudo useradd -m -c "John Doe" username

# Create with specific group
$ sudo useradd -m -g users username

# Create with multiple groups
$ sudo useradd -m -G sudo,docker username

# Create with specific home directory
$ sudo useradd -m -d /custom/home username

# Create with expiry date
$ sudo useradd -m -e 2024-12-31 username

# Create system user (no home, no login)
$ sudo useradd -r -s /sbin/nologin serviceuser

# Create and set password
$ sudo useradd -m username
$ sudo passwd username

# View defaults
$ useradd -D
GROUP=100
HOME=/home
INACTIVE=-1
EXPIRE=
SHELL=/bin/sh
SKEL=/etc/skel
CREATE_MAIL_SPOOL=yes

# Change defaults
$ sudo useradd -D -s /bin/bash
$ sudo useradd -D -b /custom/home

usermod - Modify User

Bash - usermod Examples
# Add user to group
$ sudo usermod -aG group username

# Add user to multiple groups
$ sudo usermod -aG group1,group2,group3 username

# Change primary group
$ sudo usermod -g group username

# Change shell
$ sudo usermod -s /bin/zsh username

# Change home directory
$ sudo usermod -d /new/home -m username

# Lock account
$ sudo usermod -L username

# Unlock account
$ sudo usermod -U username

# Set expiry date
$ sudo usermod -e 2024-12-31 username

# Remove expiry date
$ sudo usermod -e "" username

# Change username
$ sudo usermod -l newname oldname

# Add comment
$ sudo usermod -c "New Full Name" username

# Lock and expire immediately
$ sudo usermod -L -e 1 username

userdel - Delete User

Bash - userdel Examples
# Delete user (keep home directory)
$ sudo userdel username

# Delete user and home directory
$ sudo userdel -r username

# Force delete (even if logged in)
$ sudo userdel -f username

# Delete user and remove from mail spool
$ sudo userdel -r username

# Check if user exists before delete
$ id username && sudo userdel -r username

groupadd, groupmod, groupdel

Bash - Group Management
# Add group
$ sudo groupadd groupname

# Add group with specific GID
$ sudo groupadd -g 1500 groupname

# Add system group
$ sudo groupadd -r systemgroup

# Modify group name
$ sudo groupmod -n newname oldname

# Modify group GID
$ sudo groupmod -g 2000 groupname

# Delete group
$ sudo groupdel groupname

# List groups
$ groups
$ groups username

# View group members
$ cat /etc/group | grep groupname
$ getent group groupname

# Add user to group (alternative)
$ sudo gpasswd -a username groupname

# Remove user from group
$ sudo gpasswd -d username groupname

# Set group administrator
$ sudo gpasswd -A admin groupname

# Set group password
$ sudo gpasswd groupname

Informasi User

Bash - User Information Commands
# Current user info
$ whoami
$ id
uid=1000(kali) gid=1000(kali) groups=1000(kali),... 

# Specific user info
$ id username
$ id -u username    # UID only
$ id -g username    # GID only
$ id -G username    # All groups
$ id -n username    # Names instead of numbers

# Who is logged in
$ who
kali     tty1         2024-01-15 09:00
kali     pts/0        2024-01-15 09:05

# Detailed who
$ who -u
kali     tty1         2024-01-15 09:00 00:05  1234

# Who is logged in (short)
$ w
 09:10:00 up 10 min,  2 users,  load average: 0.00, 0.00, 0.00
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
kali     tty1     -                09:00    5:00   0.00s  0.00s -bash

# Last login
$ last
$ last username
$ last -10    # Last 10 logins

# Failed login attempts
$ lastb
$ sudo lastb

# User password info
$ sudo chage -l username
Last password change                                    : Jan 15, 2024
Password expires                                        : never
Password inactive                                       : never
Account expires                                         : never

# Change password aging
$ sudo chage -M 90 username      # Max days
$ sudo chage -m 7 username       # Min days
$ sudo chage -E 2024-12-31 username  # Expiry date
$ sudo chage -d 0 username       # Force password change

Konsep sudo

sudo (superuser do) memungkinkan user menjalankan command dengan privilege user lain (biasanya root). Ini lebih aman daripada login langsung sebagai root karena:

• Memberikan audit trail (siapa melakukan apa)
• Membatasi command yang bisa dijalankan
• Tidak perlu share root password
• Timeout otomatis setelah periode tidak aktif

Penggunaan Dasar sudo

Bash - sudo Basics
# Run command as root
$ sudo command

# Run command as specific user
$ sudo -u username command

# Run shell as root
$ sudo -i
# # Now in root shell

# Run shell as root (alternative)
$ sudo -s

# Run command with environment preserved
$ sudo -E command

# Run command without password (if configured)
$ sudo -n command

# List allowed commands
$ sudo -l

# Edit sudoers file safely
$ sudo visudo

# Edit specific user's sudoers
$ sudo visudo -f /etc/sudoers.d/username

# Validate sudoers file
$ sudo visudo -c

Konfigurasi sudoers

Bash - sudoers Configuration
# Edit sudoers file
$ sudo visudo

# Basic format:
# user  host=(runas)  commands

# Examples:

# Allow user to run all commands as root
username ALL=(ALL:ALL) ALL

# Allow user to run all commands without password
username ALL=(ALL) NOPASSWD: ALL

# Allow user to run specific commands
username ALL=(ALL) /usr/bin/apt, /usr/bin/systemctl

# Allow group to run commands
%groupname ALL=(ALL) ALL

# Allow group without password
%sudo ALL=(ALL:ALL) NOPASSWD: ALL

# Complex example
username ALL=(root) NOPASSWD: /usr/bin/systemctl restart nginx, \
                              /usr/bin/systemctl status nginx

# Host-specific
username server1=(ALL) ALL

# Command aliases
Cmnd_Alias SERVICES = /usr/bin/systemctl start *, \
                                 /usr/bin/systemctl stop *, \
                                 /usr/bin/systemctl restart *
username ALL=(ALL) SERVICES

# User aliases
User_Alias ADMINS = user1, user2, user3
ADMINS ALL=(ALL) ALL

# Defaults
Defaults:username timestamp_timeout=30
Defaults:username logfile=/var/log/sudo-username.log

sudo History dan Logging

Bash - sudo Logging
# View sudo log
$ sudo grep sudo /var/log/auth.log
$ sudo grep sudo /var/log/secure  # RHEL/CentOS

# View recent sudo commands
$ sudo grep "COMMAND=" /var/log/auth.log | tail

# View sudo commands by user
$ sudo grep "username" /var/log/auth.log | grep "COMMAND="

# Configure sudo logging
$ sudo visudo
# Add: Defaults logfile="/var/log/sudo.log"

# View sudo log
$ sudo tail -f /var/log/sudo.log

sudo Best Practices

Konsep Process

Process adalah instance dari program yang sedang dijalankan. Setiap process memiliki PID (Process ID), status, resource usage, dan parent process. Linux memungkinkan banyak process berjalan secara bersamaan (multitasking).

Melihat Process

Bash - Process Viewing Commands
# ps - Report process status
$ ps
  PID TTY          TIME CMD
 1234 pts/0    00:00:00 bash
 5678 pts/0    00:00:00 ps

# ps with all processes
$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 169432 11520 ?        Ss   09:00   0:01 /sbin/init
root       456  0.0  0.2 274532 18432 ?        Ssl  09:00   0:00 /usr/lib/systemd/systemd-journald

# ps with forest view
$ ps auxf
root         1  0.0  0.1 169432 11520 ?        Ss   09:00   0:01 /sbin/init
root       456  0.0  0.2 274532 18432 ?        Ssl  09:00   0:00  \_ /usr/lib/systemd/systemd-journald

# ps with specific user
$ ps -u username

# ps with specific PID
$ ps -p 1234

# ps with custom format
$ ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%mem

# top - Dynamic process viewer
$ top

# top with specific user
$ top -u username

# top with specific PID
$ top -p 1234

# htop - Enhanced top (if installed)
$ htop

# pgrep - Search processes by name
$ pgrep firefox
1234
5678

# pgrep with details
$ pgrep -a firefox
1234 /usr/lib/firefox/firefox

# pidof - Get PID of running program
$ pidof firefox
1234 5678

# pstree - Display process tree
$ pstree
systemd─┬─ModemManager───2*[{ModemManager}]
        ├─NetworkManager───2*[{NetworkManager}]

# pstree with PIDs
$ pstree -p

# pstree for specific user
$ pstree -u username

Menghentikan Process

Bash - Process Control Commands
# kill - Send signal to process
$ kill PID

# kill with signal
$ kill -SIGTERM PID
$ kill -15 PID

# kill force
$ kill -SIGKILL PID
$ kill -9 PID

# killall - Kill by name
$ killall firefox

# killall with signal
$ killall -9 firefox

# pkill - Kill by pattern
$ pkill firefox

# pkill with signal
$ pkill -9 firefox

# pkill by user
$ pkill -u username

# pkill by parent
$ pkill -P PPID

# Signals:
# 1  (SIGHUP)  - Hangup
# 2  (SIGINT)  - Interrupt (Ctrl+C)
# 9  (SIGKILL) - Kill (cannot be caught)
# 15 (SIGTERM) - Terminate (default)
# 18 (SIGCONT) - Continue
# 19 (SIGSTOP) - Stop (cannot be caught)

# List all signals
$ kill -l

Background dan Foreground

Bash - Background/Foreground Control
# Run command in background
$ command &
[1] 1234

# Run long-running command in background
$ sleep 3600 &
[1] 5678

# List background jobs
$ jobs
[1]+  Running                 sleep 3600 &

# Bring job to foreground
$ fg %1
$ fg 1

# Send foreground to background
# Press Ctrl+Z to suspend
# Then:
$ bg %1

# Suspend foreground process
# Press Ctrl+Z
[1]+  Stopped                 command

# Resume suspended job in background
$ bg

# Resume suspended job in foreground
$ fg

# Run command immune to hangups
$ nohup command &
$ nohup command > output.log 2>&1 &

# Run command with nice (priority)
$ nice -n 10 command
$ nice -n -5 command  # Higher priority (requires root)

# Change priority of running process
$ renice -n 10 -p PID

# Run command in subshell
$ (command1; command2; command3)

# Run command and discard output
$ command > /dev/null 2>&1

Resource Monitoring

Bash - Resource Monitoring
# System uptime
$ uptime
 09:15:00 up 15 min,  2 users,  load average: 0.00, 0.01, 0.00

# Memory usage
$ free -h
              total        used        free      shared  buff/cache   available
Mem:          7.7Gi       1.2Gi       5.1Gi       128Mi       1.4Gi       6.2Gi
Swap:         2.0Gi          0B       2.0Gi

# Disk usage
$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   15G   33G  32% /
/dev/sda2       100G   45G   50G  48% /home

# Disk usage by directory
$ du -sh /var/log/
256M    /var/log/

# Disk usage with details
$ du -sh /var/log/*
64M     /var/log/apt
128M    /var/log/syslog

# CPU info
$ lscpu
Architecture:          x86_64
CPU(s):                4
Thread(s) per core:    2

# Block devices
$ lsblk
NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda      8:0    0   50G  0 disk
└─sda1   8:1    0   50G  0 part /

# PCI devices
$ lspci

# USB devices
$ lsusb

# System information
$ uname -a
Linux kali 5.15.0-kali3-amd64 #1 SMP Debian 5.15.15-2kali1

# Kernel messages
$ dmesg
$ dmesg | tail

# System logs
$ journalctl
$ journalctl -u ssh
$ journalctl --since "1 hour ago"

Network Commands Overview

Linux menyediakan banyak command untuk network troubleshooting, monitoring, dan configuration. Menguasai command-command ini essential untuk network administration dan security analysis.

Network Configuration

Bash - Network Configuration Commands
# ip - Show/manipulate routing, devices, policy routing
$ ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
    inet 127.0.0.1/8 scope host lo
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
    inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0

# ip with brief output
$ ip -br addr
lo               UNKNOWN        127.0.0.1/8
eth0             UP             192.168.1.100/24

# Show routing table
$ ip route
default via 192.168.1.1 dev eth0
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.100

# Show link status
$ ip link
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500

# Show statistics
$ ip -s link

# Legacy commands (still used)
$ ifconfig
$ route -n
$ netstat -rn

Connectivity Testing

Bash - Connectivity Testing
# ping - Send ICMP echo requests
$ ping google.com
PING google.com (142.250.195.78) 56(84) bytes of data.
64 bytes from sof04s07-in-f14.1e100.net: icmp_seq=1 ttl=117 time=15.2 ms

# ping with count
$ ping -c 4 google.com

# ping with interval
$ ping -i 2 google.com

# ping with specific packet size
$ ping -s 1000 google.com

# traceroute - Trace route to host
$ traceroute google.com
traceroute to google.com (142.250.195.78), 30 hops max
 1  192.168.1.1  1.234 ms  1.123 ms  1.098 ms
 2  10.0.0.1  5.678 ms  5.456 ms  5.234 ms

# traceroute with ICMP
$ traceroute -I google.com

# traceroute with specific port
$ traceroute -p 80 google.com

# mtr - Combined ping and traceroute
$ mtr google.com

# mtr with report
$ mtr -r google.com

# mtr with specific count
$ mtr -c 10 google.com

# dig - DNS lookup
$ dig google.com
;google.com.                   IN      A
google.com.            123     IN      A       142.250.195.78

# dig with specific record type
$ dig google.com MX
$ dig google.com NS
$ dig google.com TXT

# dig short output
$ dig +short google.com

# nslookup (legacy)
$ nslookup google.com

# host (simple)
$ host google.com

# Reverse DNS lookup
$ dig -x 142.250.195.78
$ host 142.250.195.78

Port dan Connection Monitoring

Bash - Port and Connection Monitoring
# netstat - Network statistics
$ netstat
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address   Foreign Address  State
tcp        0      0 192.168.1.100:22 192.168.1.50:54321 ESTABLISHED

# netstat with listening ports
$ netstat -l
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address   State
tcp        0      0 0.0.0.0:22      LISTEN

# netstat with process info
$ netstat -tulpn
Proto Recv-Q Send-Q Local Address   PID/Program name
tcp        0      0 0.0.0.0:22      1234/sshd

# netstat with statistics
$ netstat -s

# netstat with routing table
$ netstat -r

# ss - Socket statistics (modern replacement)
$ ss
Netid State  Recv-Q Send-Q Local Address:Port  Peer Address:Port
tcp   ESTAB  0      0      192.168.1.100:22   192.168.1.50:54321

# ss with listening
$ ss -l
Netid State  Recv-Q Send-Q Local Address:Port
tcp   LISTEN 0      128    0.0.0.0:22

# ss with process info
$ ss -tulpn
Netid State  Recv-Q Send-Q Local Address:Port  Process
tcp   LISTEN 0      128    0.0.0.0:22      users:(("sshd",pid=1234,fd=3))

# ss with all sockets
$ ss -a

# ss with statistics
$ ss -s

# lsof - List open files (including network)
$ lsof -i
COMMAND  PID USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
sshd    1234 root    3u  IPv4  12345      0t0  TCP *:ssh (LISTEN)

# lsof with specific port
$ lsof -i :22

# lsof with specific protocol
$ lsof -i tcp
$ lsof -i udp

# lsof with specific user
$ lsof -u username

# lsof with specific process
$ lsof -p PID

Download dan Transfer

Bash - Download and Transfer Commands
# wget - Download files
$ wget https://example.com/file.txt

# wget with output filename
$ wget -O output.txt https://example.com/file.txt

# wget with continue
$ wget -c https://example.com/largefile.iso

# wget with background
$ wget -b https://example.com/file.txt

# wget with quiet mode
$ wget -q https://example.com/file.txt

# wget with recursive
$ wget -r https://example.com/directory/

# wget with specific depth
$ wget -r -l 2 https://example.com/

# curl - Transfer data
$ curl https://example.com

# curl with output
$ curl -o output.txt https://example.com/file.txt

# curl with headers
$ curl -I https://example.com

# curl with verbose
$ curl -v https://example.com

# curl with POST
$ curl -X POST -d "data=value" https://example.com/api

# curl with JSON
$ curl -X POST -H "Content-Type: application/json" \
       -d '{"key":"value"}' https://example.com/api

# curl with authentication
$ curl -u username:password https://example.com

# curl with silent mode
$ curl -s https://example.com

# curl with progress bar
$ curl -# -O https://example.com/file.txt

# scp - Secure copy
$ scp file.txt user@remote:/path/

# scp from remote
$ scp user@remote:/path/file.txt .

# scp recursive
$ scp -r directory user@remote:/path/

# rsync - Efficient file transfer
$ rsync -avh source/ user@remote:/path/

# rsync with delete
$ rsync -avh --delete source/ user@remote:/path/

# rsync with progress
$ rsync -avh --progress source/ user@remote:/path/

# rsync dry run
$ rsync -avhn source/ user@remote:/path/

Network Security Commands

Bash - Network Security Commands
# nmap - Network scanner
$ nmap 192.168.1.1

# nmap with specific ports
$ nmap -p 80,443 192.168.1.1

# nmap with port range
$ nmap -p 1-1000 192.168.1.1

# nmap with service detection
$ nmap -sV 192.168.1.1

# nmap with OS detection
$ nmap -O 192.168.1.1

# nmap with all
$ nmap -A 192.168.1.1

# nmap with aggressive scan
$ nmap -T4 -A 192.168.1.1

# nmap with output to file
$ nmap -oN output.txt 192.168.1.1

# tcpdump - Packet analyzer
$ sudo tcpdump

# tcpdump with interface
$ sudo tcpdump -i eth0

# tcpdump with filter
$ sudo tcpdump -i eth0 port 80

# tcpdump with host
$ sudo tcpdump -i eth0 host 192.168.1.100

# tcpdump with write to file
$ sudo tcpdump -i eth0 -w capture.pcap

# tcpdump with read from file
$ tcpdump -r capture.pcap

# tcpdump with verbose
$ sudo tcpdump -i eth0 -vv

# tcpdump with count
$ sudo tcpdump -i eth0 -c 100

# iptables - Firewall
$ sudo iptables -L
$ sudo iptables -L -n
$ sudo iptables -L -v

# iptables add rule
$ sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

# iptables delete rule
$ sudo iptables -D INPUT 1

# iptables save
$ sudo iptables-save > /etc/iptables/rules.v4

# iptables restore
$ sudo iptables-restore < /etc/iptables/rules.v4

# ufw - Uncomplicated Firewall
$ sudo ufw status
$ sudo ufw enable
$ sudo ufw disable

# ufw allow
$ sudo ufw allow 22
$ sudo ufw allow 80/tcp
$ sudo ufw allow from 192.168.1.0/24

# ufw delete
$ sudo ufw delete allow 22

Uji pemahaman Anda tentang Bab 17! Target minimal: 70% untuk melanjutkan ke Bab 18.