Buku "Bash and cybersecurity: serangan, pertahanan, dan analisis dari baris perintah Linux"

gambarHalo, habrozhiteli! Baris perintah dapat menjadi alat yang ideal untuk keamanan siber. Fleksibilitas yang luar biasa dan ketersediaan absolut mengubah antarmuka baris perintah (CLI) standar menjadi solusi mendasar jika Anda memiliki pengalaman yang sesuai.

Penulis Paul Tronkon dan Karl Albing berbicara tentang alat dan trik baris perintah untuk membantu Anda mengumpulkan data dengan perlindungan proaktif, menganalisis log, dan memantau kesehatan jaringan. Pentester akan belajar bagaimana melakukan serangan menggunakan fungsi kolosal yang dibangun di hampir semua versi Linux.


Untuk siapa buku ini?


Buku "Bash and cybersecurity" ditujukan bagi mereka yang ingin belajar cara bekerja dengan command line dalam konteks keamanan komputer. Tujuan kami bukan untuk mengganti alat yang ada dengan skrip baris perintah, melainkan mengajarkan Anda cara menggunakan baris perintah secara efektif untuk meningkatkan fungsionalitas yang ada.

Di sepanjang buku ini, kami memberikan contoh metode keamanan seperti pengumpulan data, analisis, dan pengujian penetrasi. Tujuan dari contoh-contoh ini adalah untuk menunjukkan kemampuan baris perintah dan memperkenalkan Anda dengan beberapa metode dasar yang digunakan dalam alat tingkat yang lebih tinggi.

Buku ini bukan pengantar pemrograman, meskipun beberapa konsep umum tercakup dalam Bagian I.

Pemantauan log waktu-nyata


Kemampuan untuk menganalisis majalah setelah suatu peristiwa terjadi adalah keterampilan yang penting. Tetapi sama pentingnya untuk dapat mengekstraksi informasi dari file log secara real time untuk mendeteksi tindakan berbahaya atau mencurigakan pada saat itu terjadi. Dalam bab ini, kita akan melihat metode untuk membaca entri jurnal saat dibuat dan diformat untuk menampilkan analitik dan menghasilkan peringatan berdasarkan indikator ancaman yang diketahui untuk suatu sistem atau jaringan (indikator kompromi).

Pemantauan Log Teks


Cara termudah untuk memantau log secara real time adalah dengan menggunakan perintah tail dengan parameter -f - itu terus membaca file dan menampilkannya di stdout ketika baris baru ditambahkan. Seperti pada bab-bab sebelumnya, sebagai contoh kita akan menggunakan log akses server web Apache, tetapi metode yang dijelaskan relevan untuk log teks apa pun. Untuk melacak log akses Apache menggunakan perintah tail, masukkan berikut ini:

tail -f /var/logs/apache2/access.log

Output dari perintah tail dapat diteruskan ke perintah grep, jadi hanya catatan yang cocok dengan kriteria tertentu yang akan ditampilkan. Contoh berikut melacak log akses Apache dan menampilkan entri yang sesuai dengan alamat IP tertentu:

tail -f /var/logs/apache2/access.log | grep '10.0.0.152'

Anda juga dapat menggunakan ekspresi reguler. Dalam contoh ini, hanya catatan yang mengembalikan kode status HTTP 404 "Halaman tidak ditemukan" yang akan ditampilkan; opsi -i ditambahkan untuk mengabaikan huruf karakter:

tail -f /var/logs/apache2/access.log | egrep -i 'HTTP/.*" 404'

Untuk menghapus dari informasi asing, output harus diteruskan ke perintah cut. Contoh ini memantau log akses untuk kueri yang mengarah ke kode status 404, dan kemudian menggunakan metode potong untuk hanya menampilkan tanggal / waktu dan halaman yang diminta: Selanjutnya, untuk menghapus tanda kurung siku dan tanda kutip ganda, Anda dapat mengarahkan output ke tr -d ' [] "'.

$ tail -f access.log | egrep --line-buffered 'HTTP/.*" 404' | cut -d' ' -f4-7
[29/Jul/2018:13:10:05 -0400] "GET /test
[29/Jul/2018:13:16:17 -0400] "GET /test.txt
[29/Jul/2018:13:17:37 -0400] "GET /favicon.ico




Catatan: opsi --line-buffering dari perintah egrep digunakan di sini. Hal ini memaksa egrep untuk mencetak ke stdout setiap kali jeda baris terjadi. Tanpa parameter ini, buffering akan terjadi dan output tidak akan dikirim ke perintah cut sampai buffer penuh. Kami tidak ingin menunggu lama. Opsi ini memungkinkan perintah egrep untuk menulis setiap baris seperti yang ditemukan.

PEMBUAT LINE PERINTAH

Apa yang terjadi selama buffering? Bayangkan egrep menemukan banyak string yang cocok dengan pola yang ditentukan. Dalam hal ini, egrep akan memiliki banyak output. Tetapi output (pada kenyataannya, input atau output) jauh lebih mahal (membutuhkan lebih banyak waktu) daripada pemrosesan data (pencarian teks). Dengan demikian, semakin sedikit panggilan I / O, program akan semakin efisien.

grep , , . . grep . , grep 50 . , 50 , , . 50 !

egrep, , . egrep , , . , , , , . , .

, , tail -f ( ), . , « », . . .

, egrep , . , .


Anda dapat menggunakan perintah ekor dan egrep untuk memantau log dan menampilkan entri apa pun yang terkait dengan pola aktivitas mencurigakan atau berbahaya yang diketahui, sering disebut sebagai IOC. Anda dapat membuat sistem deteksi intrusi sederhana (IDS). Pertama, buat file yang berisi pola ekspresi reguler untuk IOC, seperti yang ditunjukkan pada Contoh 8.1.

Contoh 8.1. ioc.txt (1) Template ini (../) adalah indikator serangan direktori bundaran: penyerang mencoba untuk keluar dari direktori kerja saat ini dan mendapatkan file yang tidak dapat diakses olehnya. (2) Linux etc / passwd dan etc / shadow file digunakan untuk otentikasi sistem dan tidak boleh diakses melalui server web. (3)

\.\./ (1)
etc/passwd (2)
etc/shadow
cmd\.exe (3)
/bin/sh
/bin/bash





Melayani file cmd.exe, / bin / sh, atau / bin / bash adalah indikasi koneksi balik yang dikembalikan oleh server web. Koneksi terbalik sering menunjukkan upaya operasi yang berhasil.

Perhatikan bahwa IOC harus dalam format regex, karena nantinya akan digunakan oleh perintah egrep.

File ioc.txt dapat digunakan dengan opsi egrep -f. Parameter ini memberi tahu egrep untuk mencari pola ekspresi reguler dari file yang ditentukan. Ini memungkinkan Anda untuk menggunakan perintah ekor untuk memantau file log, dan karena setiap catatan ditambahkan, baris baca akan dibandingkan dengan semua templat di file IOC, menampilkan catatan yang sesuai. Berikut ini sebuah contoh:

tail -f /var/logs/apache2/access.log | egrep -i -f ioc.txt

Selain itu, perintah tee dapat digunakan untuk secara bersamaan menampilkan peringatan di layar dan menyimpannya untuk diproses nanti dalam file sendiri: Sekali lagi, opsi --line-buffered diperlukan untuk memastikan bahwa tidak ada masalah yang disebabkan oleh buffering output dari perintah.

tail -f /var/logs/apache2/access.log | egrep --line-buffered -i -f ioc.txt |
tee -a interesting.txt




Pemantauan Log Windows


Seperti yang telah disebutkan, Anda harus menggunakan perintah wevtutil untuk mengakses acara Windows. Meskipun perintah ini bersifat universal, ia tidak memiliki fungsi seperti tail, yang dapat digunakan untuk mengambil catatan masuk baru. Tetapi ada jalan keluar - gunakan skrip bash sederhana yang dapat memberikan fungsionalitas yang sama (Contoh 8.2).

Contoh 8.2. wintail.sh

#!/bin/bash -
#
# Bash  
# wintail.sh
#
# :
#    tail   Windows
#
# : ./wintail.sh
#

WINLOG="Application" (1)

LASTLOG=$(wevtutil qe "$WINLOG" //c:1 //rd:true //f:text) (2)

while true
do
      CURRENTLOG=$(wevtutil qe "$WINLOG" //c:1 //rd:true //f:text) (3)
      if [[ "$CURRENTLOG" != "$LASTLOG" ]]
      then
            echo "$CURRENTLOG"
            echo "----------------------------------"
            LASTLOG="$CURRENTLOG"
      fi
done

(1) Variabel ini menentukan log Windows yang ingin Anda lacak. Untuk daftar log yang saat ini tersedia di sistem, Anda dapat menggunakan perintah wevtutil el.

(2) Di sini, wevtutil dijalankan untuk meminta file log yang ditentukan. Parameter c: 1 hanya mengembalikan satu entri log. Parameter rd: true memungkinkan perintah untuk membaca entri log terbaru. Akhirnya, f: teks mengembalikan hasil dalam teks biasa, bukan dalam format XML, yang membuatnya mudah untuk membaca hasil dari layar.

(3)Beberapa baris berikutnya menjalankan perintah wevtutil lagi dan entri log yang baru diterima dibandingkan dengan yang terakhir dicetak pada layar. Jika mereka berbeda satu sama lain, ini berarti ada perubahan dalam log. Dalam hal ini, entri baru ditampilkan. Jika catatan yang dibandingkan adalah sama, tidak ada yang terjadi dan perintah wevtutil kembali dan mulai mencari dan membandingkan lagi.

Pembuatan histogram waktu-nyata


Perintah tail -f menyediakan aliran data saat ini. Tetapi bagaimana jika Anda ingin menghitung jumlah baris yang ditambahkan ke file untuk jangka waktu tertentu? Anda dapat mengamati aliran data ini, memulai penghitung waktu dan melakukan penghitungan selama periode waktu tertentu; maka penghitungan harus dihentikan dan hasilnya dilaporkan.

Karya ini dapat dibagi menjadi dua proses skrip: satu skrip akan membaca baris, dan yang lainnya akan menonton waktu. Timer memberi tahu penghitung garis menggunakan mekanisme komunikasi antar proses POSIX standar yang disebut sinyal. Sinyal adalah gangguan perangkat lunak, dan ada berbagai jenis sinyal. Beberapa di antaranya fatal - mengarah pada akhir proses (misalnya, pengecualian dalam operasi floating point). Sebagian besar sinyal ini dapat diabaikan atau ditangkap. Tindakan diambil ketika sinyal ditangkap. Banyak dari sinyal-sinyal ini memiliki tujuan yang telah ditentukan sebelumnya dalam sistem operasi. Kami akan menggunakan salah satu dari dua sinyal yang tersedia bagi pengguna. Ini adalah sinyal SIGUSR1 (yang lainnya adalah SIGUSR2).

Script shell dapat menangkap interupsi menggunakan perintah trap bawaan. Dengan bantuannya, Anda dapat memilih perintah yang menentukan tindakan apa yang ingin Anda lakukan ketika sinyal diterima, dan daftar sinyal yang memicu panggilan ke perintah ini. Sebagai contoh:

trap warnmsg SIGINT

Ini menyebabkan perintah warnmsg (skrip atau fungsi kita sendiri) dipanggil setiap kali skrip shell menerima sinyal SIGINT, misalnya, ketika Anda menekan Ctrl + C untuk mengganggu proses yang sedang berjalan.

Contoh 8.3 menunjukkan skrip yang melakukan penghitungan

Contoh 8.3 looper.sh

#!/bin/bash -
#
# Bash  
# looper.sh
#
# :
#    
#
# : ./looper.sh [filename]
# filename —  ,   ,
#  : log.file
#

function interval ()                                           (1)
{
      echo $(date '+%y%m%d %H%M%S') $cnt                       (2)
      cnt=0
}

declare -i cnt=0
trap interval SIGUSR1                                          (3)

shopt -s lastpipe                                              (4)

tail -f --pid=$$ ${1:-log.file} | while read aline             (5)
do
     let cnt++
done

(1) Fungsi interval akan dipanggil setelah menerima setiap sinyal. Tentu saja, interval harus ditentukan sebelum kita dapat menamainya dan menggunakan jebakan dalam ekspresi kita.

(2) Perintah tanggal dipanggil untuk memberikan stempel waktu untuk nilai variabel cnt yang kami cetak. Setelah penghitung ditampilkan, kami mereset nilai ini ke 0 untuk memulai hitungan mundur dari interval berikutnya.

(3) Sekarang interval didefinisikan, kita dapat menunjukkan bahwa fungsi dipanggil setiap kali proses kami menerima sinyal SIGUSR1.

(4)Ini adalah langkah yang sangat penting. Biasanya, ketika ada pipeline perintah (misalnya, ls-l | grep rwx | wc), bagian-bagian dari pipeline (setiap perintah) dieksekusi pada subnet dan setiap proses berakhir dengan pengidentifikasi prosesnya sendiri. Ini bisa menjadi masalah untuk skenario ini, karena loop sementara akan berada dalam subkulit dengan pengenal proses yang berbeda. Apapun proses yang dimulai, skrip looper.sh tidak akan mengetahui pengidentifikasi proses loop sementara untuk mengirim sinyal ke sana. Selain itu, mengubah nilai variabel cnt dalam subkulit tidak mengubah nilai cnt dalam proses utama, sehingga sinyal untuk proses utama akan setiap kali menetapkan nilai menjadi 0. Anda dapat menyelesaikan masalah ini dengan perintah shopt, yang mengatur parameter (-s) ke lastpipe. Ia memberi tahu shell untuk tidak membuat subkulit untuk perintah terakhir dalam pipa,dan jalankan perintah ini dalam proses yang sama seperti skrip itu sendiri. Dalam kasus kami, ini berarti bahwa perintah ekor akan dieksekusi dalam sebuah subkulit (yaitu, dalam proses lain), dan loop sementara akan menjadi bagian dari proses skrip utama. Catatan: opsi shell ini hanya tersedia dalam versi bash 4.x dan lebih tinggi dan hanya untuk shell yang tidak interaktif (mis. Skrip).

(5) Ini adalah perintah tail -f dengan parameter --pid lainnya. Kami menentukan pengidentifikasi proses, yang, setelah menyelesaikan proses ini, akan menyelesaikan perintah ekor. Kami menentukan ID proses dari skrip shell saat ini untuk dilihat. Tindakan ini memungkinkan Anda untuk membersihkan proses dan tidak membiarkan perintah ekor dieksekusi di latar belakang (jika, katakanlah, skrip ini berjalan di latar belakang; Contoh 8.4).

Skrip tailcount.sh memulai dan menghentikan skrip dengan stopwatch (timer) dan menghitung interval waktu.

Contoh 8.4. tailcount.sh

#!/bin/bash -
#
# Bash  
# tailcount.sh
#
# :
#    n 
#
# : ./tailcount.sh [filename]
#     filename:  looper.sh
#

#  —    
function cleanup ()
{
      [[ -n $LOPID ]] && kill $LOPID          (1)
}

trap cleanup EXIT                             (2)
bash looper.sh $1 &                           (3)
LOPID=$!                                      (4)
#   
sleep 3

while true
do
      kill -SIGUSR1 $LOPID
      sleep 5
done >&2                                      (5)

(1) Karena skrip ini akan menjalankan skrip lain, skrip ini harus dibersihkan setelah bekerja. Jika pengidentifikasi proses disimpan dalam LOPID, variabel akan menyimpan nilai, oleh karena itu fungsi akan mengirim sinyal ke proses ini menggunakan perintah kill. Jika Anda tidak menentukan sinyal tertentu dalam perintah kill, maka sinyal SIGTERM akan dikirim secara default.

(2) Perintah EXIT bukan sinyal. Ini adalah kasus khusus ketika pernyataan trap memberi tahu shell untuk memanggil fungsi ini (dalam hal ini pembersihan) jika shell yang menjalankan skrip ini akan dimatikan.

(3)Sekarang pekerjaan yang sebenarnya dimulai. Skrip looper.sh diluncurkan, yang akan berjalan di latar belakang: agar skrip ini berfungsi sepanjang siklus (tanpa menunggu perintah untuk menyelesaikan pekerjaan), skrip ini terputus dari keyboard.

(4) Di sini, pengidentifikasi proses skrip yang baru saja kami mulai di latar belakang disimpan.

(5) Pengalihan ini hanyalah tindakan pencegahan. Semua output yang berasal dari loop sementara atau dari pernyataan kill / sleep (walaupun kami tidak mengharapkannya) tidak boleh dicampur dengan output apa pun dari fungsi looper.sh, yang, meskipun bekerja di latar belakang, masih mengirimkannya ke stdout. Oleh karena itu, kami mengarahkan data dari stdout ke stderr.

Untuk meringkas, kita melihat bahwa meskipun fungsi looper.sh ditempatkan di latar belakang, pengidentifikasi prosesnya disimpan dalam variabel shell. Setiap lima detik, skrip tailcount.sh mengirimkan sinyal SIGUSR1 ke proses ini (yang dieksekusi dalam fungsi looper.sh), yang, pada gilirannya, memanggil skrip looper.sh untuk mencetak jumlah baris saat ini yang diperbaiki di dalamnya dan memulai kembali penghitungan. Setelah keluar, skrip tailcount.sh akan dihapus dengan mengirimkan sinyal SIGTERM ke fungsi looper.sh untuk menghentikannya.

Dengan bantuan dua skrip - skrip yang melakukan penghitungan baris, dan skrip dengan stopwatch (penghitung waktu) yang mengontrol skrip pertama - Anda bisa mendapatkan output (jumlah baris untuk periode tertentu), berdasarkan skrip berikutnya akan membuat histogram. Disebut seperti ini:

bash tailcount.sh | bash livebar.sh

Script livebar.sh membaca data dari stdin dan mencetak output ke stdout, satu baris untuk setiap baris input (Contoh 8.5).

Contoh 8.5 livebar.sh

#!/bin/bash -
#
# Bash  
# livebar.sh
#
# :
#    «» 
#
# :
# <output from other script or program> | bash livebar.sh
#

function pr_bar ()                                         (1)
{
      local raw maxraw scaled
      raw=$1
      maxraw=$2
      ((scaled=(maxbar*raw)/maxraw))
      ((scaled == 0)) && scaled=1 #   
      for((i=0; i<scaled; i++)) ; do printf '#' ; done
      printf '\n'

} # pr_bar

maxbar=60     #         (2)
MAX=60
while read dayst timst qty
do
      if (( qty > MAX ))                                   (3)
      then
           let MAX=$qty+$qty/4    #   
           echo "                      **** rescaling: MAX=$MAX"
      fi
      printf '%6.6s %6.6s %4d:' $dayst $timst $qty         (4)
      pr_bar $qty $MAX
done

(1) Fungsi pr_bar menampilkan string tagar yang diskalakan berdasarkan parameter yang disediakan ke ukuran maksimum. Fitur ini mungkin tampak familier, seperti yang kita gunakan sebelumnya dalam skrip histogram.sh.

(2) Ini adalah ukuran garis tagar terpanjang yang dapat kami izinkan (lakukan tanpa pembungkus garis).

(3)Seberapa besar nilai yang akan ditampilkan? Tanpa mengetahui hal ini sebelumnya (meskipun data ini dapat disediakan untuk skrip sebagai argumen), skrip akan melacak maksimum. Jika maksimum ini terlampaui, nilai akan mulai "skala" dan garis-garis yang sekarang ditampilkan, dan garis masa depan juga akan diskalakan ke maksimum baru. Script menambahkan 25% ke nilai maksimum, sehingga tidak harus menskala nilai jika nilai baru berikutnya setiap kali hanya meningkat 1-2%.

(4)printf menentukan lebar minimum dan maksimum dari dua bidang pertama yang akan dicetak. Ini adalah prangko tanggal dan waktu yang akan terpotong jika nilai lebar terlampaui. Untuk menampilkan seluruh nilai, tentukan lebarnya empat karakter. Dalam hal ini, meskipun ada batasan, semua nilai akan dicetak. Jika jumlah karakter dalam nilai kurang dari empat, yang hilang akan ditambah dengan spasi.

Karena skrip ini dibaca dari stdin, Anda dapat menjalankannya sendiri untuk melihat bagaimana perilakunya. Berikut ini sebuah contoh:

$ bash  livebar.sh
201010 1020 20
201010     1020 20:####################
201010 1020 70
                       **** rescaling: MAX=87
201010     1020 70:################################################
201010 1020 75
201010 1020 75:###################################################
^C

Dalam contoh ini, input dicampur dengan output. Anda juga dapat memasukkan input ke file dan mengarahkannya ke skrip untuk hanya melihat output:

$ bash livebar.sh < testdata.txt
bash livebar.sh < x.data
201010 1020 20:####################
                 **** rescaling: MAX=87
201010 1020 70:################################################
201010 1020 75:###################################################
$

»Informasi lebih lanjut tentang buku itu dapat ditemukan di situs web penerbit
» Isi
» Kutipan

Untuk Khabrozhiteley Diskon 25% pada kupon - Bash

Setelah pembayaran versi kertas buku, sebuah buku elektronik dikirim melalui email.

All Articles