Bardzo Prosty i Skuteczny Firewall. LINUX

IPTABLES - firewall

jeśli nie chcesz korzystać wbudowanego w dystrybucje konfiguratora firewall'a to ten post jest dla Ciebie.

(DOMYŚLNIE !!!! , zezwalamy na cały ruch wychodzący)

URUCHAMIANIE

(debian, ubuntu, centos, redhat, suse)
cd /etc/init.d

dla (slackware)
cd /etc/rc.d/

vi rc.firewall

#!/bin/sh
iptables -F
iptables -X
iptables -t nat -X
iptables -t nat -F
iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT ACCEPT

iptables -A INPUT -i lo -j ACCEPT
iptables -A FORWARD -o lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

## jesli uzywamy natowanie/maskowanie adresow
echo "1" >/proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o eth0 -s 10.0.0.0/24 -j MASQUERADE

## zezwol na polaczenia zainicjowane z komputera
iptables -A INPUT -j ACCEPT -m state --state ESTABLISHED,RELATED
iptables -A FORWARD -j ACCEPT -m state --state ESTABLISHED,RELATED

## ssh
iptables -A INPUT -s 0/0 -p tcp --dport 22 -j ACCEPT
## www
iptables -A INPUT -s 0/0 -p tcp --dport 80 -j ACCEPT
## ftp
iptables -A INPUT -s 0/0 -p tcp --dport 21 -j ACCEPT
iptables -A INPUT -s 0/0 -p tcp --dport 20 -j ACCEPT
iptables -A INPUT -s 0/0 -p udp --dport 20 -j ACCEPT
## serwer poczty jesli mamy
iptables -A INPUT -s 0/0 -p tcp --dport 25 -j ACCEPT

# przepuść torrenty
iptables -A INPUT -s 0/0 -p tcp --dport 6881:6889 -j ACCEPT
iptables -A INPUT -s 0/0 -p udp --dport 6881:6889 -j ACCEPT
iptables -A INPUT -s 0/0 -p udp --dport 12115 -j ACCEPT
iptables -A INPUT -s 0/0 -p tcp --dport 12115 -j ACCEPT
iptables -A INPUT -s 0/0 -p udp --dport 514 -j ACCEPT
iptables -A INPUT -s 0/0 -p udp --dport 7599 -j ACCEPT

##  zablokowanie ICMP - odpowiedzi ping
iptables -A INPUT -p icmp -j DROP
#iptables -A INPUT -p icmp --icmp-type 4 -j ACCEPT
#iptables -A INPUT -p icmp --icmp-type 12 -j ACCEPT
#iptables -A INPUT -p icmp --icmp-type 3 -j ACCEPT
#iptables -A INPUT -p icmp --icmp-type 11 -j ACCEPT
#iptables -A INPUT -p icmp --icmp-type 8 -j ACCEPT
#iptables -A INPUT -p icmp --icmp-type 0 -j ACCEPT 
#iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

## zablokawnie ataku slownikowego, tylko 4 polaczenia na minute

iptables -I INPUT -p tcp --dport 24  -m state --state NEW -m recent --set

iptables -I INPUT -p tcp --dport 24  -m state --state NEW -m recent --update --seconds 60 --hitcount 4 -j DROP

aby uruchamiał się po restarcie, dodajemy wpis do rc.local:

vi /etc/init.d/firewall

dodajemy na końcu (przed poleceniem exit 0)

/etc/init.d/firewall

WYŁĄCZANIE FIREWALL

stwórz plik  /etc/init.d/rc.firewall.stop

vi /etc/init.d/rc.firewall.stop

dodajemy

#!/bin/sh

iptables -F

iptables -X

iptables -t nat -X

iptables -t nat -F

iptables -P INPUT ACCEPT

iptables -P FORWARD ACCEPT

iptables -P OUTPUT ACCEPT

iptables -A INPUT -i lo -j ACCEPT

iptables -A FORWARD -o lo -j ACCEPT

iptables -A OUTPUT -o lo -j ACCEPT

uruchamianie firewall: /etc/init.d/rc.firewall

zatrzymywanie firewall: /etc/init.d/rc.firewall.stop

to wszystko  (wystarczy pod-edytować wpisy po siebie)

Montowanie po ssh

SSHFS

Aby zamontować jakiś katalog ze zdalnej maszyny na komputerze lokalnym - wykorzystamy komendę sshfs.

pakiet do ściągnięcia ze strony producenta:  http://fuse.sourceforge.net/sshfs.html
lub z dystrybutorni używanego Linuxa.

MONTOWANIE:
ładujemy moduł jądra:
$> modprobe fuse

montujemy zdalny udział:
$> sshfs -C root@IP_ZDALNEJ_MASZYNY:/var/www /var/www

$> sshfs -C romek@IP_ZDALNEJ_MASZYNY:/home/romek /mnt/romek 

lub (jeśli domyślny port 22 został zmieniony na inny np. 9876)

$> sshfs -C -p 8976 root@IP_ZDALNEJ_MASZYNY:/var/www /var/www

opcja -C wymusza kompresje danych podczas przesyłu

FSTAB

jeśli chcemy aby udział montował się za każdym razem gdy zresetujemy maszynę musimy dodać wpis do /etc/fstab

vi /etc/fstab (proszę przeedytować poniższa linie pod swoje ustawienia)

dodajemy wpis

romek@IP_ZDALNEJ_MASZYNY:/remote/folder /mount/point  fuse.sshfs noauto,x-systemd.automount,_netdev,users,idmap=user,IdentityFile=/home/jacek/.ssh/id_rsa,allow_other,reconnect 0 0

GENEROWANIE KLUCZA PUBLICZNEGO SSH

Jeśli nie chcemy podawać za każdym razem hasła warto wygenerować sobie klucz publiczny i dodać go do zdalnej maszyny.

polecenia na lokalnej maszynie: 

(podczas generowania klucza nie wpisujemy żadnych haseł , klikamy tylko ENTER)

$> ssh-keygen

Generating public/private rsa key pair.
Enter file in which to save the key (/home/jacek/.ssh/id_rsa): 
Created directory '/home/jacek/.ssh'.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/jacek/.ssh/id_rsa.
Your public key has been saved in /home/jacek/.ssh/id_rsa.pub.
The key fingerprint is:
02:c3:32:c0:e5:56:2e:cd:81:46:87:1a:13:b2:42:1a jacek@serwer
The key's randomart image is:
+--[ RSA 2048]----+
|Eo+oo+           |
|+B.=* .          |
|+ B+++           |
|...o.o           |
|      . S        |
|       .         |
|                 |
|                 |
|                 |
+-----------------+

w naszym katalogu domowym w katalogu .ssh został wygenerowany klucz publiczny

$> cat /home/jacek/.ssh/id_rsa.pub

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCzki0cc9M1rbBkgD/P+LN9/ozwl9nzF

ZZqLeGKP7uvz60OhdKw0rPmdAD50kt03VKnclAZGpB6HVY684h77RnVff86g0b1jimSidE

F+YO6nQQFWHpuAau84Tc8L7neFTRwXqqWzM00S6I8EmzDzuFEacmZZYAI2xhBx50D

X//PhzO/faF6QDqzuIAgogasdqaasdasdBvBQXXmGfP8KM3kilSpJYHLMRuHvO2IaUB6

O9z0PlKqw7hM+ukTKJxRxwD0MRN9KmnGNSe0cqKY7PvWdtNgBQf471LWAU7dpYlBH

DgxxMfJaDdM8FKtfBYgo0u45RYKpVOXkwhlmI5/1KJyhv2lJT jacek@serwer

kopiujemy ten plik na zdalny serwer i dodajmy jego zawartość do pliku authorized_keys

$> cat ~/.ssh/id_rsa.pub | ssh romek@IP_ZDALNEJ_MASZYNY "cat >> ~/.ssh/authorized_keys; chmod 700. ~/.ssh/authorized_keys"

od teraz powinniśmy móc logowac sie bez podawania hasła.

ssh romek@IP_ZDALNEJ_MASZYNY

$>

nasze auto-montowanie podczas uruchamiania systemu zadzieje się automatycznie

Wysłanie powiadomienia z konsoli root na X'y użytkownika

Czasami potrzebujemy wysłać wiadomość na ekran dla użytkownika który pracuje na X'ach a my na poczciwej czarnej konsoli.

Ale jak to zrobić skoro my zalogowaliśmy się  np. po ssh.  i do X'ow nie mamy dostepu.

Załóżmy że , użyszkodnik zalogowany jest jako kowalski.

 

root@komp:~# ps ax | grep X
 6916 tty7     Ss+    6:23 /usr/bin/X :1 -auth /var/run/lightdm/root/:1 -nolisten tcp vt7 -novtswitch
13753 pts/1    S+     0:00 grep --color=auto X

interesuje nas parametr po X , w naszym przypadku :1

 

su - kowalski -c 'DISPLAY=:1.0 xmessage "Prosze o zrestartowanie komputera. Administrator sieci"'

 

w efekcie kolega kowalski powinien na ekranie otrzymać komunikat.

 

Prosze o zrestartowanie komputera. Administrator sieci

 

zamiast xmessage można też użyć notify-send

 

 

LVM - Logical Volume Management

1) Fdisk (początkowe zarządzenie dyskiem, dyskami)

fdisk /dev/sda
(LVM typ 8e )

2) Tworzenie woluminu fizycznego (formatowanie)

pvcreate /dev/sda1
odpowiednio
pvcreate /dev/sdaX X=[1,2,3,4,5,...,n]

informacje o woluminach
pvdisplay
3) Tworzenie grupy:

vgcreate moje_dane /dev/sda1
lub
vgcreate moje_dane /dev/sda1 /dev/sda2 /dev/sda3
lub
vgcreate moje_dane /dev/sda1 /dev/sdb1 /dev/sdc1

sprawdzamy

vgscan
lub
vgdisplay
lub
vgdisplay moje_dane

4) Tworzenie woluminu logicznego.

tworzymy 100GB o nazwie partycja1 (dla LVM moje_dane)

lvcreate -n partycja1 --size 100g moje_dane
sprawdzamy

lvdisplay

5) Formatiren ;)

mkfs.ext4 /dev/moje_dane/partycja1

6) Montowanie

mkdir /mnt/partycja1/

vi /etc/fstab  (jeśli chcemy aby sie montowało podczas startu maszyny)

/dev/moje_dane/partycja1 /mnt/partycja1/ ext4 auto,users,rw,exec,dev,relatime  0  2

Ustawmy uprawnienia (kto może czytać/pisać w tym zasobie)
 
chown gienek:users /mnt/partycja1
chmod 775 /mnt/partycja1

7) Zmiana rozmiaru wolumenów

:zwiekszanie ze 100 do 300

umount /mnt/partycja1/
lvextend -L+200g /dev/moje_dane/partycja1
e2fsck -f /dev/moje_dane/partycja1
resize2fs /dev/moje_dane/partycja1
mount /mnt/partycja1

:zmniejszanie z 100 do 50

umount /mnt/partycja1/
e2fsck -f /dev/moje_dane/partycja1
resize2fs /dev/moje_dane/partycja1 50g
lvreduce -L-50g /dev/moje_dane/partycja1
resize2fs /dev/moje_dane/partycja1
mount /mnt/partycja1


Montowanie obrazów dysków KVM opartych na LVM

kpartx -av /dev/mapper/vgname/vlname

stworzone zostaną dowiązania do stworzonych w /vgname/vlname partycji
np. /vgname/vlname-home itd.

teraz możemy już traktować te dowiązania jak zwykłe urządzenia blokowe typu /dev/sda1 itd.

np.
mount  /dev/mapper/vgname/vlname-home /home 
fsck.ext4 /dev/mapper/vgname/vlname-home

Szyfrowanie swap - ecrypt

Aby włączyć/wyłączyć szyfrowanie swap w systemie linux , postępuj z poniższymi instrukcjami



TURN ON

sudo ecryptfs-setup-swap 

TURN OFF

sudo swapoff -a 

sudo cryptsetup remove /dev/mapper/cryptswap1 

sudo vim /etc/crypttab 
(*usunac/zahaszować wpis dla swap /dev/sda5* )

sudo /sbin/mkswap /dev/sda5 

sudo swapon /dev/sda5 

sudo vim /etc/fstab 
(*zamienić /dev/mapper/cryptswap1 na /dev/sda5*)

Maszyna virtualna - KVM

URUCHAMIANIE KVM  (ubuntu)

sudo apt-get install kvm
sudo apt-get install bridge-utils

Edycja  /etc/network/interfaces

auto lo
iface lo inet loopback
auto br0
iface br0 inet static
address xxx.xxx.xxx.xxx
netmask xxx.xxx.xxx.xxx
gateway xxx.xxx.xxx.xxx
bridge_ports eth0
bridge_stp off
bridge_maxwait 5

Edycja /etc/qemu-ifup

#!/bin/sh
/sbin/ifconfig $1 0.0.0.0 promisc up
/usr/sbin/brctl addif br0 $1
sleep 2

Teraz musimy stworzyć virtualny dysk:

mamy 2 możliwości

1) tworzymy dysk o stałej wielkości 4GB (dysk fizycznie tyle zajmie na dysku)

    dd if=/dev/zero of=disk01.img bs=1G count=4


2) tworzymy dysk o interesującej nas wielkości ale wielkość nie będzie alokowana (załóżmy ze chcemy dysk 10GB)

    qemu-img create -f qcow2 disk01.qcow2 10G


Teraz instalujemy system na virtualnym dysku

1)  z obrazu instalacyjnego  w pliku
    kvm -hda disk01.img -cdrom os.iso -m 512 -boot d -vnc IP:1
2) z dysku cdrom
    kvm -cdrom /dev/cdrom  -m 1024 -boot d -vnc  IP:1 disk01.qcow2

(po instalacji)

 Teraz mamy zamiar uruchomić maszynę wirtualną z obsługą sieci. Możemy przypisać do niej adresu MAC dla interfejsu sieciowego VM. 
Jest to ważne, jeśli używamy więcej niż 1 VM. Każda maszyna wirtualna powinna mieć inny mac-address.

    kvm -hda disk01.img -m 512 -boot c -net nic,vlan=0,macaddr=00:16:3e:00:00:01 -net tap -nographic -daemonize

powinniśmy mieć  już możliwość podłączenia się po ssh do naszej maszyny , jeśli występują problemy można dołożyć podgląd vnc

(czasami gdy są problemy z dostepem do sieci możan sprobować tak)

     kvm -hda disk01.img -m 512 -boot c -net nic,vlan=0,macaddr=00:16:3e:00:00:01,model=rtl8139 -net tap -nographic -daemonize

 ******

Konwertowanie obrazów:

virtualbox  --> kvm

• najpierw konwersja na obraz typu IMG

   VBoxManage clonehd /sciezka/do/obraz.vdi /sciezka/do/obraz.img --format raw

• teraz konwersja z obrazu IMG na format którego używa KVM

    qemu-img convert -f raw obraz.img -O qcow2 obraz.qcow2





Przykłady uruchomień kvm:

    kvm -hda /sciezka/disk1.qcow -hdb /sciezka/disk2.qcow -m 2048 -vga none -usb -usbdevice tablet -net nic -net user,hostfwd=tcp:192.168.1.2:2228-:22 



*****************

 
Przenoszenie działających obrazów systemu pliku do KVM opartych na LVM.
1. chyba najlepsze rozwiązanie (po sieci) 

Na maszynie docelowej:

iptables -I INPUT -p tcp --dport 9897 -s IP_ZRODLA -j ACCEPT
nc -l -p 9897 |dd of=/dev/mapper/vgname/lvname

Na maszynie źródła:
(wyłączamy bez błędów maszynę virtualną która chcemy skopiować.) 
 
dd if=/dev/mapper/vgname/lvname | nc IP_DOCELOWEJ 9897
[Enter]

i czekamy w zależność od ilości danych i łącza, np. przy łączy 1,5Mbit i 40GB danych to czas około 1h


2. możemy użyć komendy rsync

na maszynie docelowej:

tworzymy partycje na naszym pustym wolumenie LVM identyczna jak na maszynie źródłowej (nie konieczne ale wskazane, nie trzeba zmieniać wówczas /etc/fstab)

fdisk /dev/mapper/vgname/lvname


używamy komendy kpartx aby zobaczyć stworzone partycje
kpartx -av /dev/mapper/vgname/lvname



teraz powinniśmy w /dev/mapper/ odnaleźć odnośniki do naszych partycji

dalej postępujemy już jak z urządzeniami blokowymi (dyskami)
tworzymy system plików
np.
mkfs.ext4 /dev/mapper/vgname/lvname-home

itd.
tworzymy jakiś punkt montowania np. nowy
mkdir /nowy/
cd nowy
tworzymy katalogi które będą montowane np. home , var
mkdir home var
 
na maszynie źródła (na działającym virtualu):

rsync -avz -e ssh root@IP_ZDALNEGOKOMPA:/  /nowy/
i czekamy aż się zrobi

następnie należy uruchomić kvm z butowaniem się cdrom z obrazem np. knoppixa i uaktualnić wpis w MBR dla grub'a lub lilo.

np.
qemu-system-x86_64 -cdrom knoppix.iso -m 1096 -vnc :1 -boot d -drive file=/dev/mapper/vgname/lvname
,cache=none,if=virtio -pidfile /home/test.pid

dla lilo wystarczy uruchomić komendę
lilo

dla grub uruchomić komendę
grub-install /dev/vda1 (podać poprawny dysk)

Usuwanie plikow starszych niż ....

Czasami zachodzi potrzeba kasowania plików których "świeżość" ;) przekroczyła pewną ilość dni.

np.
choćby stare backupy ,  lub stare zdjęcia,  cokolwiek

oto kilka prostych porad jak się do tego zabrać:


1)
możemy wykorzystać do tego startego poczciwego find'a



find .  -ctime +30 -delete

lub jeśli szukamy tylko np. archiwum tar.gz

find . -name '*.tar.gz' -ctime +30 -delete

(kasowanie nastąpi w bieżącym katalogu dla plików starszych i równych 30 dni)

jeśli chcemy w innym katalogu to zamiast . po find wpisujemy zadany katalog

np.

find /tmp -name '*.tar.gz' -ctime +30 -delete 

(skasujemy wszystkie swoje pliki tar.tgz z katalogu /tmp , starsze niż 30 dni)


2)
możemy też wykorzystać skrypt w bash'u

vi kasuj_30dni.sh
 
(stwórz plik  z zawartością (poniżej))

#!/bin/sh

DZIS=`date +%s`
DOBA=86400

ls $1 | while read file
do
 STATE=`stat --format=%Y ${file}`
 PARAMETR=$(((DZIS-STATE)/DOBA))
 if [ $PARAMETR -gt 30 ]
 then
        echo "Kasuje plik ${file} ktory jest starszy niz 30 dni"
        rm -f -v ${file}
 fi
done

dodajmy uprawnienia dla pliku:

chmod u+x  kasuj_30dni.sh

i bęc uruchamiamy (tylko ostrożnie bo skasuje nam wszystko powyżej 30 dni w bieżącym katalogu)

./kasuj_30dni.sh

Andrzej Tarnowiecki

Usługi Informatyczne - tarnet.eu.org