# pingwinowanie 5+1
# zad 1
Na oko to:
1. pobieramy balenaEtcher [link](https://github.com/balena-io/etcher/releases/download/v1.18.11/balenaEtcher-1.18.11-x64.AppImage)
2. `chmod +x ~/Downloads/balenaEtcher-*.AppImage`
3. ~/Downloads/balenaEtcher*.AppImage
4. pobierz iso jakiegoś systemu
5. Reszte wyklikasz
# zad 3
## rwx - co to jest
Spróbujmy najpierw wyświetlić sobie parę plików (spoiler):
```bash
ll /media/my_precious/
total 16K
-rw------- 1 kabanok kabanok 36 04-05 12:45 asd
drwx------ 2 kabanok kabanok 4.0K 04-05 12:49 asd123/
drwx------ 2 kabanok kabanok 4.0K 04-05 12:49 asd124/
-rw------- 1 kabanok kabanok 0 04-06 11:11 elo
-rw------- 1 kabanok kabanok 0 04-06 11:22 elo2
drwx------ 2 kabanok kabanok 4.0K 04-06 11:23 elo23/
```
Jak widać - w pierwszej kolumnie są - na pierwszy rzut oka - jakieś dziwne znaczki. Tak na prawdę są to tryby dostępu dla odpowiednio właściciela pliku, grupy która ma dostęp do pliku oraz dla reszty.
Mamy 3 tryby dostępu - `rwx` oznaczające odpowiednio:
- r (read) - Prawo do odczytu zawartości katalogu. Użytkownik posiadający to prawo może wyświetlić listę plików i podkatalogów znajdujących się w katalogu.
- w (write) - Prawo do zapisu w katalogu. Użytkownik posiadający to prawo może tworzyć, usuwać lub zmieniać pliki i podkatalogi wewnątrz katalogu.
- x (execute) - Prawo do wykonywania katalogu. W przypadku katalogów oznacza to, że użytkownik może używać tego katalogu jako elementu ścieżki (np. cd), aby uzyskać dostęp do jego zawartości. Bez tego prawa, użytkownik nie będzie w stanie przejść do tego katalogu ani wykonać na nim żadnych operacji.
Jak nimi manipulować (chmod), np:
```bash=
chmod +rx plik # dodaje do pliku prawa do odczytu i odpalania (dla właściciela, grupy i reszty)
chmod 755 plik # dodaje do pliku prawa rwxr-xr-x (wszystko dla właściciela, brak możliwości zapisu dla grupy i reszty)
```
**Jak liczyć te 755?**
Każda cyfra to osobny poziom dostępu: pierwsza-właściciel, druga-grupa, trzecia-reszta.
Jak liczymy gdy mamy już wybrane kogo chcemy? Zapisujemy to w postaci bitowej: 5 = 101 i and-ujemy z rwx, więc 5 = r-x.
żeby z kodu zamienić na liczbę to po prostu uznajemy że `-` to 0 a `r/w/x` to 1. Wtedy np `-wx` to będzie `011 = 3`
Katalog musi mieć prawa `-wx` żeby można było tworzyc pliki ale nie wolno było czytać.
```bash=
> chmod 300 kat/
> ll
total 12K
d-wx------ 2 kabanok kabanok 4.0K 04-06 13:24 kat/
-rw-r--r-T 1 kabanok kabanok 0 04-06 13:08 sticky
-rw-r--r-- 1 kabanok kabanok 1.8K 04-06 12:42 zad3.md
-rw-r--r-- 1 kabanok kabanok 1.8K 04-06 11:43 zad4.md
> touch kat/siema
> ls kat/
ls: cannot open directory 'kat/': Permission denied
```
## sticky bit
Sticky bit to specjalne uprawnienie dla plików, które pozwala na usuwanie pliku, tylko jego właścicielowi. Dla katalogów - tylko właściciel pliku, właściciel katalogu oraz administrator systemu mogą usuwać lub zmieniać pliki w tym katalogu, nawet jeśli inni użytkownicy mają uprawnienia zapisu do tego katalogu.
Operacje:
```bash=
chmod +t plik # dodaje sticky bit w pliku/katalogu
chmod -t plik # odejmuje
```
Jak zobaczyć czy jest ustawiony?
```bash
> ls -l sticky
-rw-r--r-T 1 kabanok kabanok 0 04-06 13:08 sticky
```
Jak widać jest to na ostatniej pozycji (tam gdzie było x! )
Na szczęście znaleziono sposób jak temu zaradzić - `małe t = t+x, a duże T = samo t`
## setgid
Na katalogu - oznacza że nowe pliki dziedziczą grupę po grupie głównej katalogu a nie użytkownika.
Na pliku - oznacza że pliki utworzone podczas wywołania tego pliku będą dziedziczone po grupie głównej pliku a nie użytkownika.
Jak ustawić?
```bash=
mkdir 3zad
chmod g+s 3zad/
sudo chgrp git 3zad
touch 3zad/elo
```
I widzimy że
```
> ll 3zad/
total 0
-rw-r--r-- 1 kabanok git 0 04-06 15:52 elo
```
## /tmp i /usr/local
**/tmp:**
```
> ll /tmp -d
drwxrwxrwt 16 root root 560 04-06 16:05 /tmp/
```
Ma to sens, bo chcemy zeby wszyscy użytkownicy mogli zapisywać pliki do tmp, ale ustawiamy sticky bit żeby nikt nie mógł innemu użytkownikowi usuwać plików/katalogów
**/usr/local:**
```
> ll /usr/local -d
drwxr-xr-x 11 root root 4.0K 2022-08-16 /usr/local/
```
Ma to sens - w tym folderze są zainstalowane pakiety i chcielibyśmy, żeby paczki mógł instalować tylko administrator, ale chcemy również żeby inni użytkownicy mogli korzystać z plików w środku i je odpalać
# zad 4
## setup pendrive
```
sudo fdisk -l
sudo fdisk /dev/sda
```
*zrobić dobrze pendriveowi*
```
sudo mkfs.vfat -n MY_PRECIOUS /dev/sda1
```
## czy wyszło
```
lsblk -o NAME,FSTYPE,LABEL
```
## zamianki w /etc/fstab
`mkdir -p -m0 /media/my_precious/`
```
blkid | grep MY_PREC
```
*kopiujemy UUID*
```
sudo vim /etc/fstab
```
dodajemy na dole:
`UUID=*skopiowane* /media/my_precious vfat opcje 0 0`
I opcje to są:
`noauto,user,noexec,dmask=077,fmask=177`
**noauto**: Ta opcja powoduje, że partycja nie jest automatycznie montowana podczas uruchamiania systemu.
**user**: Ta opcja umożliwia zwykłym użytkownikom montowanie i odmontowywanie partycji.
**noexec**: blokuje odpalanie programów
**dmask=077**: dmask=077 oznacza że od domyślnych uprawnień (chyba 755) odejmujemy 077 czyli dostajemy 700 (hehe).
**fmask=177**: to samo tylko dla plików (dla plików domyślne jest 644 chyba)
Ostatnie dwa zera oznaczają:
- pierwsze:
określa, czy system plików powinien być uwzględniany w kopii zapasowej przez narzędzie dump. Zazwyczaj, gdy ta wartość wynosi 0, system plików nie będzie uwzględniany w kopii zapasowej, podczas gdy 1 oznacza, że powinien.
- drugie:
określa kolejność w jakiej sprawdzane są systemy plików (fsck) podczas uruchamiania systemu.
- `0`: System plików jest pomijany (brak sprawdzania).
- `1`: System plików jest sprawdzany jako pierwszy.
- wyższe: System plików jest sprawdzany sekwencyjnie po sprawdzeniu systemów plików o priorytecie `1` (`2`->`3`->...).
więc do fstaba dodajemy:
`UUID=... /media/my_precious vfat noauto,user,noexec,dmask=077,fmask=177 0 0`
I musimy zrobić reload: `sudo systemctl daemon-reload`
## Montowanie i demontaż
Montowanie: `mount /media/my_precious`
Demontażowanie: `umount /media/my_precious`
# zad 5
## Nie wiem czy to co robie ma sens
## Jak stworzyć ramdysk
```bash
sudo mkdir /mnt/ramdisk -p
sudo mount -t ramfs ramfs /mnt/ramdisk
```
## Porównanie
### Nwm czy jednak nie o to chodziło???
#### ramdysk
1. tworzymy obraz w ramdysku: `dd if=/dev/zero of=/mnt/ramdisk/encrypted_container bs=2M count=2048`
2. szyfracja: `sudo cryptsetup luksFormat /mnt/ramdisk/encrypted_container`
3. otwieranie szyfracji: `sudo cryptsetup luksOpen /dev/loop0 enc_cont`
4. napierdalamy dane: `sudo dd if=/dev/urandom of=/dev/mapper/enc_cont bs=1M count=1024 conv=fsync`
```bash
sudo dd if=/dev/urandom of=/dev/mapper/enc_cont bs=1M count=1024 conv=fsync
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 2.54661 s, 322 MB/s
```
5. oczyszczanie:
```bash
sudo cryptsetup luksClose enc_cont
```
#### dysk
1. tworzymy obraz w ramdysku: `dd if=/dev/zero of=~/studia/lin/lista6/encrypted_container bs=2M count=2048`
2. szyfracja: `sudo cryptsetup luksFormat ~/studia/lin/lista6/encrypted_container`
3. otwieranie szyfracji: `sudo cryptsetup luksOpen /dev/loop0 enc_cont`
4. napierdalamy dane: `sudo dd if=/dev/urandom of=/dev/mapper/enc_cont bs=1M count=1024 conv=fsync`
```bash
sudo dd if=/dev/urandom of=/dev/mapper/enc_cont bs=1M count=1024 conv=fsync
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 5.97807 s, 180 MB/s
```
5. oczyszczanie:
```bash
sudo cryptsetup luksClose enc_cont
```
### Odczyt
#### ramdysk
```bash
> sudo dd if=/dev/mapper/enc_cont of=/dev/null bs=1M
4080+0 records in
4080+0 records out
4278190080 bytes (4.3 GB, 4.0 GiB) copied, 2.17428 s, 2.0 GB/s
```
#### dysk
```bash
> sudo dd if=/dev/mapper/enc_cont of=/dev/null bs=1M
4080+0 records in
4080+0 records out
4278190080 bytes (4.3 GB, 4.0 GiB) copied, 2.22449 s, 1.9 GB/s
```
# zad 6
## Enable (wtf jak to jest po polsku) zram
```bash=
sudo modprobe zram
```
## Co to zram
Zram to moduł jądra pozwalający na utworzenie skompresowanego ramdysku - taki ramdysk ale dane sa kompresowane przy zapisie i dekompresowane przy odczycie.
## Jak stworzyć device zram?
- tworzenie
```bash=
sudo zramctl --find --size 4G
sudo mkfs.ext4 /dev/zram<X>
```
- usuwanie
```bash=
sudo zramctl --reset /dev/zram<X>
```
## Staty
```bash=
sudo dd if=/dev/zero of=/mnt/zram/enc bs=3M count=1024 conv=fsync
sudo cryptsetup luksFormat /mnt/zram/enc
sudo cryptsetup luksOpen /mnt/zram/enc enc
sudo dd if=/dev/urandom of=/dev/mapper/enc bs=1M count=1024 conv=fsync
sudo cryptsetup luksClose enc
```
```bash=
> sudo dd if=/dev/urandom of=/dev/mapper/enc bs=1M count=1024 conv=fsync
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 5.40304 s, 199 MB/s
```
Jest znacznie szybsze od normalnego dysku, więc czymuby nie zrobić w tym swapa??? (:DDD)
# zad 7 (sic!)
## Szybki tutorial
### Tworzenie urządzenia zram
```bash=
sudo zramctl --find --algorithm zstd --size 4G
```
### tworzymy swapka
```bash=
sudo mkswap -U clear /dev/zram0
sudo swapon --priority 100 /dev/zram0
```
### cleanup
```bash=
sudo swapoff /dev/zram0
sudo echo 1 > /sys/module/zswap/parameters/enabled
```
## Automatyczne mountowanie
Do pliku `/etc/udev/rules.d/99-zram.rules` dodajemy:
```
ACTION=="add", KERNEL=="zram1", TTR{comp_algorithm}="zstd", ATTR{disksize}="4G", RUN="/usr/bin/mkswap -U clear dev/%k", TAG+="systemd"
```
```bash=
sudo vim /etc/udev/rules.d/99-zram.rules
```
I oczywiście trzeba dodać nową pozycję w `fstab`:
`/dev/zram0 none swap defaults,pri=100 0 0`
```bash=
sudo vim /etc/fstab
```
Sign in with Wallet
Connect another wallet