man DOMANDE SISTEMI OPERATIVI

-Cercare, a partire dalla directory corrente, i file di testo

-Spiegare il job control con esempi
-Modificare il browser di default (il pacchetto virtuale del browser)

1. Scrivere uno script in bash che dati due numeri come argomenti stampa il maggiore.
2. Identificare il tipo di file leggendo i file
3. Creare un nuovo utente di nome “studente 2” e fai in modo che “studente” posso eseguire
la shell di studente2 ?

1) trovami tutti i file di testo nella directory correnteps

2) fammi un esempio di fork bomb e parlami di tutto ciò che lo riguarda:
3) crea un nuovo user e dai la possibilità di usare il bash di un altro user al nuovo user

Script che prende un numero e dice se è divisibile sia per 5 che 7

Configura file sudoers per eseguire slabtop con l utente
Mostra i magicbyte di un file e spiega ?
(Less o hexdump)

1)Trovare i file più piccoli di un mega e con il setuserid impostato

2) trovare le dipendenze di bash sia in forma scritta grafica da stud
3)modificare l'editor di sistema da stud

1) Script che accetta un numero come parametro e stampa un messaggio se è divisibile sia
per 5 che per 7 oppure no.

2) Spiegare il job control con degli esempi e dire per cosa è utile, che problemi risolve. ?fin

3) Mostrare i browser disponibili e modificare quello che viene aperto con il comando
browser. stud
Lode) Trovare in che file apt-update salva le informazioni sui pacchetti tramite strace.

File multicolonnare (id e nome utente)

Sudo per eseguire APT update (modifica file /etc/sudoers) da studiare

1) mi sembra di aver capito che avesse chiesto il meccanismo di controllo degli accessi su
un determinato file;
2) l'albero dei processi con la visualizzazione dei processi relativo al desktop environment e
spiegazione dei vari componenti del desktop manager;
3) trovare quale pacchetto fornisce il comando dd

stampare tutti i file di testo a partire dalla directory corrente

1) scrivi un script che riceve due parametri e stampa il piu' grande o un messaggio se sono
ug
2) dipendenze duali; irette/inverse del pacchetto bash, sia testuali che grafiche;
3) scrivere un esempio di fork bomb in Bash /be spiegarla

1. Trovare file più piccoli di 10 nel file system

2. Far eseguire slabtop senza password ad un utente qualsiasi
3. Stampa dipendenze dirette ed inverse di firefox
4. (per la lode) scarica pacchetti sorgenti bash e trovare il file con il main

1. Trova tutti i file con setuid e utente creatore root, poi quelli con setgid e gruppo di
lavoro root e infine quelli che hanno capabilities
2. Fai uso delle named pipe con una piccola demo
3. Trova tutti i pacchetti Debian che contengono librerie statiche
man
1. dimostrare in almeno 2 modi diversi che /bin/dd è un eseguibile
2. trovare quale disco contiene il file system principale per poi stampare solo le stringhe
3. albero processi di LibreOffice

1. Stampare i 5 file più grandi del sistema

2. Abilitare comando slabtop allo user studente
3. Mettere editor a nano

1. Permessi dei file

2. trovare tutti i file PHP (non va bene cercare solo la roba che finisce per .PHP)
3. jobs

1. trovare tutti gli script bash del sistema

2. dimostrare che un file gif lo è effettivamente
3. cambiare il browser predefinito

1. Esempio di pacchetti virtuali, cambiare l’editor di default, spiegare cosa significa la la

colonna stato e priorità
2. Dare all’utente “studente” la possibilità di eseguire qualsiasi comando come un altro
utente usando la propria password (quella di studente)
3. Aprire libreoffice e trovarlo in nell’albero dei processi

1. File multicolonnare partendo da /etc/shadow (intero progressivo, username, hash

password)

1. [immagino il quesito di partenza fosse di copiare un file da /usr/bin nella propria

home]: Cosa fa la copia di un file, per quanto riguarda i permessi?
2. Spiegazione dei vari tipi di dipemdenze di apt
3. Trovare l'albero dei processi del terminale

1. spiegazione del job control

1. trovare tutti i file immagine di tipo JPEG nel sistema

2. spiegare in almeno 2 modi diversi che /bin/ls è un eseguibile – (usare hexdump e
file)
 3. creare un file multicolonnare con numero progressivo, user id e shell leggendo da
/etc/passwd

1. L’utente studenteos può creare un file all’interno della home di root? Perchè? Cosa si
può fare per fare in modo che tale utente possa farlo? (alla fine è stato creato un file
di nome prova.txt)
2. Dopo essere tornato alla situazione iniziale (ovvero studenteos non può entrare in
/root), fare in modo che l’utente possa eseguire nano per modificare /root/prova.txt
(tramite sudo). studenteos può leggere il file /root/prova.txt? Perchè?
3. Il magic number dei file di tipo ELF è composto dai seguenti 4 byte: 127, “E”, “L”, “F”.
Dimostrare che un file ELF lo è effettivamente (bisogna aprirlo con hexdump e
convertire il primo byte 7F da esadecimale a decimale per verificare che è
effettivamente 127)

aggiungo domande dell’anno scorso

1) Trovare tutti i file di testo

find / -name "*" -exec file '{}' \; 2>/dev/null | grep "text" | less
o
find / -name "*" -exec file '{}' \; 2>/dev/null | grep -E "(ASCII | UTF-8 UNICODE) text"

2) Dipendenze da 'dd'

dpkg -S "/bin/dd" ---> "coreutils" pacchetto contenente "dd"

debtree -R coreutils > coreutils.dot ---> Calcola le dipendenze

"-R" = "reverse dipendence"
dot -Tsvg coreutils.dot > coreutils.svg ---> Genera un'immagine vettoriale
inkscape coreutils.svg

man debtree

3) Realizzare una tabella in questo modo:

Indici numerici | Username Unix | hash password
| |
| |

su -
cat -n /etc/shadow ---> numero delle password accanto a queste = in questo caso 38
o wc -l /etc/shadow ---> direttamente numero delle righe nel file /etc/shadow
paste <( seq 1 38 ) <( cut -f 1 -d":" /etc/shadow ) <( cut -f 2 -d ":" /etc/shadow ) | column -t

---------------------------------------------------------------------------------------------------------

1) Script che stampa i numeri da 1 a 100 divisibili per 5 e 7

nano script.sh

Dentro il file:
declare -i a
 a=1

while [ $a -le 100 ];

do
if [ $(($a%5)) -eq 0 -a $(($a%7)) -eq 0 ]; then
echo $a
fi
a=$(($a+1))
done

risulta 35 e 70 all’istante , se ci mette tanto avete sbagliato

---------------------------------------------------------------------------------------------------------

Domanda del 2019

1) Studiare le attività di schedulazione di un processo a scelta

top -> priorità da 0 a 139: 0-99 non facilmente accessibile dall'utente -> sudo per impostare
top toglie 100

Schedulate in base alla priorità: dalla priorità più piccola

find / -printf "\n %s " -exec file '{}' \; 2>/dev/null | grep -E "^.*:[[:space:]].*image.*$" | sort -k1nr | head

---------------------------------------------------------------------------------------------------------

1) Trovare la immagini più grandi

vim immagini.sh

Dentro il file:
#!/bin/bash
find / -regex ".*\.\(gif\|png\|jpg\|svg\)$" -printf "%s %p\n" 2>/dev/null | sort -nrk 1 | head (sbagliato)
find / -printf "%s %p\n" -exec file ‘{}’ \; 2>/dev/null | grep “image” | sort -nrk 1 | head (giusto)

chmod +x immagini.sh
./immagini.sh

---------------------------------------------------------------------------------------------------------

2) Trovare pacchetto Debian che occupa più spazio su disco

apt show ".*" | grep "Download-Size:" | cut -f2 -d" " | sort -nrk 1 | head t-n 1

3) Dipendenze dirette e inverse del pacchetto "bash"

apt depends bash

- pre-dipendenza ---> Installata prima di bash

Necessario per operazioni di configurazione e installazione
- dipendenza ---> installata durante l'installazione di bash
Serve solo per eseguire

debtree -R bash > bash.dot "-R" = "reverse dipendence"

dot -Tsvg bash.dot > bash.svg
 inkscape bash.svg

---------------------------------------------------------------------------------------------------------

1) Pacchetto Debian che contiene "help"

apt:
- search: anche ricerche regex
- show: mostra informazioni sul pacchetto

apt-file search help

o
type help

---------------------------------------------------------------------------------------------------------

1) Identificatori di chiamate di sistema

man syscalls

2) Illustrare l'algoritmo di accesso ai file rispetto a /proc/kcore

- Verifica permessi per l'utente che prova ad accederci e componenti del pattern (cartelle)
- Controllo privilegi /
- Controllo privilegi /proc
- Controllo privilegi /proc/kcore

Controllo in ciascuna delle terne

3) Pacchetto Debian che fornisce il comando ulimit

man bash-builtins

---------------------------------------------------------------------------------------------------------

1) Realizzare uno script che riceve due parametri: file e pattern. Ritorna il numero di volte che il pattern è nel file

nano a.sh

Nel file:
#!/bin/bash

grep -cE "^.*$2.*$" $1

o
grep -c "$2" $1

exit 0

chmod 755 a.sh

o
chmod +x a.sh
 ./a.sh [nome file] [pattern]

---------------------------------------------------------------------------------------------------------

1) Tutti i pacchetti debian

apt-cache search -x "*.deb" ---> Meglio evitare

apt list --installed | grep debian

---------------------------------------------------------------------------------------------------------

1) Trovare i file con privilegi particolari

-Setuid
find / -perm -u+s -user root -exec ls -l '{}' \; 2>/dev/null
+
-Setgid
find / -perm -g+s -group root -exec ls -l '{}' \; 2>/dev/null
+
-Capabilities
find / -exec /usr/sbin/getcap '{}' \; 2>/dev/null

Buona soluzione ma lenta, perché i comandi vengono svolti per ogni file nel filesystem

Migliore soluzione:

/usr/sbin/getcap -r / 2>/dev/null ---> -r = ricorsivo

---------------------------------------------------------------------------------------------------------

1) Job control -> studiare

Job control puoi provare a lanciare un comando con & alla fine e poi guardi i processi
Si io ho fatto proprio così. Ho lanciato una sleep 30 &
Poi con i comandi fg, bg e jobs fai vedere lo stato dei processi.

---------------------------------------------------------------------------------------------------------

1) Script per trovare tutti i file di testo vecchio al massimo di un mese

find / -mtime -30 -exec file '{}' \; 2>/dev/null | grep "text"

---------------------------------------------------------------------------------------------------------

1) Trovare i file più grandi di 1 MB

find / -size +1M 2>/dev/null

---------------------------------------------------------------------------------------------------------
1) Lettura di un file una riga alla volta usando solo bash

exec 5<"$1"

while IFS= read -u 5 line; do

echo "F: $line"
done

Apre il file in $1 e lo mette nel file descriptor 5.

'exec 5<"$1"' Ti permette di aprire il file e tenerlo aperto.

Il comando "read" (con le opzioni apposite) permette di leggere solo una riga dal file
descriptor senza chiuderlo.
Entrambi sono comandi interni di bash.

---------------------------------------------------------------------------------------------------------

1) Fare una dimostrazione dei pacchetti virtuali

readlink -f /bin/editor ---> Editor da usare

update-alternatives --config editor ---> Visualizzare le 4 scelte possibili
apt install editor ---> Varie versioni
apt show editor ---> Mostra che è un pacchetto virtuale

3) Mostrare il tree di processi con pid e argomenti, e evidenziare il desktop manager

pstree -p -a -H $(pidof gdm3) | less

---------------------------------------------------------------------------------------------------------

1) Cercare "root","ROOT","Root",ecc... in tutti i file di sistema ed evidenzia il match

grep root --color=yes -rni / 2>/dev/null

"-r" = Ricorsivamente "-n" = Mostra la riga "-i" = Case insensitive

2) Algoritmo di accesso al file /dev/tty

- Controllo privilegi /
- Controllo privilegi /dev
- Controllo privilegi /dev/tty

Controllo in ciascuna delle terne

- Setuid = "S" al posto della "x" nella prima terna ---> Una volta che lo script parte agisce con il privilegi del
creatore
- Setgid = "S" al posto della "x" nella seconda terna ---> Una volta che lo script parte agisce con il privilegi del
gruppo del creatore
- Capabilities = Privilegi particolari del creatore a seconda della propria funzione

3) Trovare i pacchetti debian con librerie statiche

apt search "^lib.*-dev$"

 Stampa dei file forniti dalla Libreria del C:
apt-file list "libc6-dev"

Ci sono file /include/ e librerie statiche (che terminano con .a)

---------------------------------------------------------------------------------------------------------

1) Aprire Firefox, YouTube e far partire un video

Trovare il pid di Firefox e l'albero dei processi

pgrep -l firefox

pstree -a -p 5161 ( pid Firefox )

{...} ---> Gruppi di thread

2) Usare strace su apt update e trovare la directory dove vengono messi i file dei repository

apt update
strace apt update 2>&1 | less
ls -l /var/cache/apt/archives ---> No
ls -l [Altra cartella che si vede nell'output di strace]

---------------------------------------------------------------------------------------------------------

1) Trovare tutti i link simbolici presenti nel file system

man find
find -L / -type l

2) Trovare il pid del processo padre

pid_t pid = getppid() ---> Processo padre

---------------------------------------------------------------------------------------------------------

1) Creare un file e dare i permessi di accesso a solo due specifici utenti distinti

touch perStudente2.txt
su -
mkdir /home/lavoro
chmod 750 lavoro
chown studente:studente lavoro
chown studente:studente perStudente2.txt

Creare un altro utente studente2:

su -
useradd studente2
passwd studente2

usermod -a -G studente2 studente

 su - studente2

cat perStudente2.txt

---------------------------------------------------------------------------------------------------------

1) Scrivere uno script di shell in BASH che legge un file una riga alla volta, scarta tutte le righe che
iniziano con "r" e stampa le altre, il tutto cercando di usare solo costrutti di BASH

#!/bin/bash

exec 5<"file.txt"

while IFS= read -u 5 line; do

if [ ${line:0:1} != 'r' ]; then
echo $line
fi
done

---------------------------------------------------------------------------------------------------------

1) Scaricare le coreutils e trovare l'implementazione di cp

apt source coreutils

cd coreutils/source
ls -l | grep "rm"
Trovo cp.c

2) Stampare l'albero dei processi di un'istanza di libreoffice

Lanciare libreoffice
pstree -aps $(pgrep -l oosplash)

---------------------------------------------------------------------------------------------------------

1) Cercare tutti i file più recenti di un mese posseduti da root

find / -mtime -30 -user root -exec file '{}' \; 2>/dev/null | grep text

2) Creare file multicollonare

Numero | User
n | ...
... |
1 |
|

paste <(seq $(cat /etc/passwd | wc -l) -1 1) <(cut -f1 -d":" /etc/passwd) | column -t > tabellaUtenti.txt
o
paste <(tac <(seq $(wc -l /etc/passwd | cut -d " " -f1))) <(cut -d":" -f1 /etc/passwd)| column -t > tabellaUtenti.txt
---------------------------------------------------------------------------------------------------------

1) Individuare tutti i file di tipo script bash

find / -exec file '{}' \; 2>/dev/null | grep "shell script"

Per trovarli tutti ---> da root

2) Controllo permessi /etc/shadow

ls -ld /
ls -ld /etc
ls -l /etc/shadow

3) Trovi la parola "password" in tutti i file, mostrare il match

grep --color=yes -Hnir password / 2>/dev/null

"-H" = stampa il nome del file

"-n" = numero di riga
"-i" = case insensitive
"-r" = ricorsivo

---------------------------------------------------------------------------------------------------------

i
1) Script in C che stampi i metadati di un file

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv, char **envp) {

const char* pathname = "metadati.c";

struct stat statbuf;

int ris = stat(pathname, &statbuf);

if(ris==-1) {
perror("Errore");
exit(EXIT_FAILURE);
}

printf("ld\n",statbuf.st_size);
exit(EXIT_SUCCESS);
}

2) Trovare i pacchetti che contengono tutti i comandi echo

type -a echo
Il primo è un comando interno di shell ---> bash
 apt-file search /usr/bin/echo ---> Non è registrato nel database di apt-file ---> Copia di /bin/echo per ragioni
storiche
apt-file search /bin/echo ---> coreutils

---------------------------------------------------------------------------------------------------------

1) Con una demo illustrare gli strumenti principali per la gestione della history

Tutti i comandi inseriti passati

history ---> Comando interno di shell
fc ---> fix command
history 10 ---> Ultimi 10 comandi
!t ---> Ultimo comando che inizia per t
!! ---> Ultimo comando

Unico file ---> HISTFILE contiene il nome del file della history

Attento con man history che porta alla libreria del C ---> Non legge i comandi interni di shell

Il giusto è help history

---------------------------------------------------------------------------------------------------------

1) Scaricare l'ultima versione della libreria del C e mostrare differenze

Usare git https://www.gnu.org/software/libc/sources.html

git tag o https://sourceware.org/git/?p=glibc.git

2) Programma in C per clonare un processo

#include <unistd.h>
#include <stdio.h>

int main(int argc, char **argv, char **envp) {

pid_t f = fork();

if(f == 0) {
printf("Processo figlio\n");
}

else if(f == -1) {

perror("Errore: processo non creato");
}
else {
printf("Pid %d\n", f);
}
}

3) Trovare tutti i file di testo più recenti di un mese (30 giorni) posseduti dall'utente root

su -
find / -user root -mtime -30 -exec file '{}' \; 2>/dev/null | grep "text"

---------------------------------------------------------------------------------------------------------
1) Trovare tutti i link simbolici all'interno del file system

su -
find / -type l

2) Mostrare il job control

Insieme di comandi per gestire l'esecuzione dei comandi in maniera simultanea

Ctrl+Z ferma esecuzione

jobs -l

Processo + ---> Ultimo comando lanciato

Processo - ---> Penultimo comando lanciato

fg %5 ---> Tornare in primo piano comando in background

bg %5 ---> Tornare in esecuzione in background

Uccidere tutti i processi: kill %5 %4 ...

A che serve? Nato nei primi sistemi che avevano terminali seriali -> 1 solo schermo testuale
1 Unico comando poteva partire in foreground e occupare esclusivamente il canale standard input

3) Script in bash che implementa il giochino dell'impiccato

#!/bin/bash

declare -i numeroDaIndovinare=48
declare -i tentativi=0
declare -i numeroInserito

while true ; do
echo "Inserire un numero:"
read numeroInserito
let tentativi=++tentativi
if [ $numeroInserito -lt $numeroDaIndovinare ]; then
echo "Il numero inserito è più piccolo"
elif [ $numeroInserito -gt $numeroDaIndovinare ]; then
echo "Il numero inserito è più grande"
else
echo "Indovinato in $tentativi tentativi!!"
break
fi
done

---------------------------------------------------------------------------------------------------------

1) Fare in modo che una cartella con dei file sia condivisibile tra solo due utenti

su -
mkdir shared
gpasswd -a docente studente ---> Mette docente nel gruppo studente
 ls -ld shared
chown root:studente shared/
chmod 0750 /shared
chmod 0660 /shared/prova.txt

cd shared
touch prova.txt
chown studente:studente prova.txt
logout

2) Illustrare con una demo i pacchetti virtuali debian

sudo apt install editor

Una sorta di raccoglitore che contiene più pacchetti "reali"

sudo apt show editor ---> Mostra che è virtuale

apt update alternatives

sudo update-alternatives --config editor

Tutti i pacchetti installati: Priorità maggiore = Più semplice
Posso modificare l'editor predefinito

---------------------------------------------------------------------------------------------------------

1) Metapacchetti debian

Pacchetti che installano pochissimi file (Informazioni generali, copyright, ecc...)

Un sacco di dipendenze

esempio GNOME

apt-file list -x "^gnome$" ---> Installa 4 file

apt depends gnome ---> Un sacco di dipendenze

Uso:
- Installare un sacco di pacchetti con un solo nome
(- Un kernel potrebbe non riconoscere una perifirica nell'ultima versione)

---------------------------------------------------------------------------------------------------------

1) Analizzare un file in esadecimale

Comando hexdump

2) Byte ELF = Domanda per la lode

Un eseguibile UNIX in formato “ELF” contiene i caratteri 'E', 'L', 'F' nel secondo, terzo e
quarto byte. Si digiti less /bin/ls per verificare.

---------------------------------------------------------------------------------------------------------