From: Simone Piccardi Date: Sat, 28 Jan 2012 15:46:45 +0000 (+0000) Subject: Rimosso programma inutile e messo programma di test per le ACL. X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=commitdiff_plain;h=5d2f43482c192e29b4e0039adf1de81d5f3e54b9;p=gapil.git Rimosso programma inutile e messo programma di test per le ACL. --- diff --git a/filedir.tex b/filedir.tex index 36453cb..050dcf7 100644 --- a/filedir.tex +++ b/filedir.tex @@ -5184,7 +5184,7 @@ costituita da un \textsl{tipo}, da un eventuale tipo \const{ACL\_USER} e \const{ACL\_GROUP}.} e da un insieme di permessi. Ad ogni oggetto sul filesystem si può associare una ACL che ne governa i permessi di accesso, detta \textit{access ACL}. Inoltre per le directory si -può impostare una ACL aggiuntiva, detta \textit{default ACL}, che serve ad +può impostare una ACL aggiuntiva, detta ``\textit{Default ACL}'', che serve ad indicare quale dovrà essere la ACL assegnata di default nella creazione di un file all'interno della directory stessa. Come avviene per i permessi le ACL possono essere impostate solo del proprietario del file, o da un processo con @@ -5242,7 +5242,7 @@ che possono essere assegnati tramite voci di tipo \const{ACL\_USER}, \const{ACL\_GROUP} e \const{ACL\_GROUP\_OBJ}. Se in una di queste voci si fosse specificato un permesso non presente in \const{ACL\_MASK} questo verrebbe ignorato. L'uso di una ACL di tipo \const{ACL\_MASK} è di particolare -utilità quando essa associata ad una \textit{default ACL} su una directory, in +utilità quando essa associata ad una \textit{Default ACL} su una directory, in quanto i permessi così specificati verranno ereditati da tutti i file creati nella stessa directory. Si ottiene così una sorta di \itindex{umask} \textit{umask} associata ad un oggetto sul filesystem piuttosto che a un @@ -5251,7 +5251,7 @@ processo. Dato che le ACL vengono a costituire una estensione dei permessi ordinari, uno dei problemi che si erano posti nella loro standardizzazione era appunto quello della corrispondenza fra questi e le ACL. Come accennato i permessi -ordinari vengono mappati le tre voci di tipo \const{ACL\_USER\_OBJ}, +ordinari vengono mappati nelle tre voci di tipo \const{ACL\_USER\_OBJ}, \const{ACL\_GROUP\_OBJ} e \const{ACL\_OTHER} che devono essere presenti in qualunque ACL; un cambiamento ad una di queste voci viene automaticamente riflesso sui permessi ordinari dei file e viceversa.\footnote{per permessi @@ -5278,7 +5278,7 @@ quello relativo alla creazione di nuovi file,\footnote{o oggetti sul \func{creat} (vedi sez.~\ref{sec:file_open}), \func{mkdir} (vedi sez.~\ref{sec:file_dir_creat_rem}), \func{mknod} e \func{mkfifo} (vedi sez.~\ref{sec:file_mknod}).} che come accennato può essere modificato dalla -presenza di una \textit{default ACL} sulla directory che andrà a contenerli. +presenza di una \textit{Default ACL} sulla directory che andrà a contenerli. Se questa non c'è valgono le regole usuali illustrate in sez.~\ref{sec:file_perm_management}, per cui essi sono determinati dalla \itindex{umask} \textit{umask} del processo, e la sola differenza è che i @@ -5387,12 +5387,12 @@ Si tenga presente che pur essendo \type{acl\_t} un \index{tipo!opaco} tipo opaco che identifica ``\textsl{l'oggetto}'' ACL, il valore restituito dalla funzione non è altro che un puntatore all'area di memoria allocata per i dati richiesti. Pertanto in caso di fallimento verrà restituito un puntatore nullo -e si dovrà, in questa come in tutte le funzioni seguenti che restituiscono un -oggetto di tipo \type{acl\_t}, confrontare il valore di ritorno della funzione -con ``\code{(acl\_t) NULL}''.\footnote{dato che il valore \var{NULL} in questo - caso viene restituito come oggetto di tipo \type{acl\_t}, un confronto del - risultato della funzione con \var{NULL} darebbe un errore di compilazione - per la differenza di tipo.} +di tipo ``\code{(acl\_t) NULL}'' e si dovrà, in questa come in tutte le +funzioni seguenti che restituiscono un oggetto di tipo \type{acl\_t}, +confrontare il valore di ritorno della funzione con \val{NULL}.\footnote{a + voler essere estremamente pignoli si dovrebbe usare ``\code{(acl\_t) + NULL}'', ma è sufficiente fare un confronto direttamente con \val{NULL} + essendo cura del compilatore fare le conversioni necessarie.} Una volta che si siano completate le operazioni sui dati di una ACL la memoria allocata per un oggetto \type{acl\_t} dovrà essere liberata esplicitamente @@ -5401,7 +5401,7 @@ attraverso una chiamata alla funzione \funcd{acl\_free}, il cui prototipo è: \begin{funcproto}{ \fhead{sys/types.h} \fhead{sys/acl.h} -\fdecl{int acl\_free(void * obj\_p)} +\fdecl{int acl\_free(void *obj\_p)} \fdesc{Disalloca la memoria riservata per una ACL.} } @@ -5417,14 +5417,14 @@ Si noti come la funzione usi come argomento un puntatore di tipo ``\ctyp{void *}'', essa infatti può essere usata non solo per liberare la memoria allocata per i dati di una ACL, ma anche per quella usata per creare le stringhe di descrizione testuale delle ACL o per ottenere i valori dei -qualificatori della una voce di una ACL. - -Pertanto a seconda dei casi occorrerà eseguire un \textit{cast} a ``\ctyp{void - *}'' del tipo di dato di cui si vuole eseguire la disallocazione. Si tenga -presente poi che oltre a \func{acl\_init} ci sono molte altre funzioni che -possono allocare memoria per i dati delle ACL, è pertanto opportuno tenere -traccia di tutte le chiamate a queste funzioni perché alla fine delle -operazioni tutta la memoria allocata dovrà essere liberata con +qualificatori della una voce di una ACL. L'uso del tipo generico ``\ctyp{void + *}'' consente di evitare di eseguire un \textit{cast} al tipo di dato di cui +si vuole effettuare la disallocazione. + +Si tenga presente poi che oltre a \func{acl\_init} ci sono molte altre +funzioni che possono allocare memoria per i dati delle ACL, è pertanto +opportuno tenere traccia di tutte le chiamate a queste funzioni perché alla +fine delle operazioni tutta la memoria allocata dovrà essere liberata con \func{acl\_free}. Una volta che si abbiano a disposizione i dati di una ACL tramite il @@ -5623,7 +5623,7 @@ di uso più immediato, è \funcd{acl\_to\_text}, ed il suo prototipo è: \begin{funcproto}{ \fhead{sys/types.h} \fhead{sys/acl.h} -\fdecl{char * acl\_to\_text(acl\_t acl, ssize\_t *len\_p)} +\fdecl{char *acl\_to\_text(acl\_t acl, ssize\_t *len\_p)} \fdesc{Produce la rappresentazione testuale di una ACL.} } @@ -5646,14 +5646,14 @@ intera in questa verrà restituita (come \itindex{value~result~argument} \textit{value result argument}) la dimensione della stringa con la rappresentazione testuale, non comprendente il carattere nullo finale. -La seconda funzione, che permette di controllare con dovizia di dettagli la -generazione della stringa contenente la rappresentazione testuale della ACL, è -\funcd{acl\_to\_any\_text}, ed il suo prototipo è: +La seconda funzione, che permette di controllare con una gran dovizia di +particolari la generazione della stringa contenente la rappresentazione +testuale della ACL, è \funcd{acl\_to\_any\_text}, ed il suo prototipo è: \begin{funcproto}{ \fhead{sys/types.h} \fhead{sys/acl.h} -\fdecl{char * acl\_to\_any\_text(acl\_t acl, const char *prefix, char +\fdecl{char *acl\_to\_any\_text(acl\_t acl, const char *prefix, char separator, int options)} \fdesc{Produce la rappresentazione testuale di una ACL.} } @@ -5915,20 +5915,49 @@ ad un altra con \funcm{acl\_copy\_entry} o eliminare una voce da una ACL con \itindend{Access~Control~List~(ACL)} +Come esempio di utilizzo di queste funzioni nei sorgenti allegati alla guida +si è distribuito il programma \texttt{mygetfacl.c}, che consente di leggere le +ACL di un file, passato come argomento. + +\begin{figure}[!htbp] + \footnotesize \centering + \begin{minipage}[c]{\codesamplewidth} + \includecodesample{listati/mygetfacl.c} + \end{minipage} + \normalsize + \caption{Corpo principale del programma \texttt{mygetfacl.c}.} + \label{fig:proc_mygetfacl} +\end{figure} + +La sezione principale del programma, da cui si è rimossa la sezione sulla +gestione delle opzioni, è riportata in fig.~\ref{fig:proc_mygetfacl}. Il +programma richiede un unico argomento (\texttt{\small 16--20}) che indica il +file di cui si vuole leggere la ACL. Se questo è presente si usa +(\texttt{\small 22}) la funzione \func{get\_acl\_file} per leggerne la ACL, e +si controlla (\texttt{\small 23--26}) se l'operazione ha successo, uscendo con +un messaggio di errore in caso contrario. + +Ottenuta la ACL la si converte in formato testuale (\texttt{\small 27}) con la +funzione \func{acl\_to\_text}, controllando di nuovo se l'operazione ha +successo (\texttt{\small 23--26}) ed uscendo in caso contrario. Si provvede +infine a stampare la rappresentazione testuale (\texttt{\small 28}) e dopo +aver liberato (\texttt{\small 29--30}) le risorse allocate automaticamente, +si conclude l'esecuzione. + \subsection{La gestione delle quote disco} \label{sec:disk_quota} -Quella delle quote disco è una funzionalità introdotta inizialmente da BSD, e +Quella delle quote disco è una funzionalità introdotta inizialmente da BSD e presente in Linux fino dai kernel dalla serie 2.0, che consente di porre dei tetti massimi al consumo delle risorse di un filesystem (spazio disco e -\itindex{inode} \textit{inode}) da parte di utenti e gruppi. +\itindex{inode} \textit{inode}) da parte di utenti e gruppi. Dato che la funzionalità ha senso solo per i filesystem su cui si mantengono i dati degli utenti\footnote{in genere la si attiva sul filesystem che contiene le \textit{home} degli utenti, dato che non avrebbe senso per i file di sistema che in genere appartengono all'amministratore.} essa deve essere -esplicitamente richiesta. Questo si fa, per tutti i filesystem che le +attivata esplicitamente. Questo si fa, per tutti i filesystem che le supportano, tramite due distinte opzioni di montaggio, \texttt{usrquota} e \texttt{grpquota} che abilitano le quote rispettivamente per gli utenti e per i gruppi. Così è possibile usare le limitazioni sulle quote o sugli utenti o @@ -5941,8 +5970,8 @@ relativi al consumo delle risorse da parte degli utenti e dei gruppi, che a far rispettare i limiti imposti dal sistema, con la generazione di un errore di \errcode{EDQUOT} per tutte le operazioni sui file che porterebbero ad un superamento degli stessi. Si tenga presente che questi due compiti sono -separati, il primo si attiva al montaggio del filesystem con le quote -attivate, il secondo deve essere abilitato esplicitamente. +separati, il primo si attiva al montaggio del filesystem con il supporto per +le quote, il secondo deve essere abilitato esplicitamente. Per il mantenimento dei dati di consumo delle risorse vengono usati due file riservati nella directory radice del filesystem su cui si sono attivate le @@ -5955,17 +5984,18 @@ l'unica rimasta in uso, questi file sono \texttt{aquota.user} e Dato che questi file vengono aggiornati soltanto se il filesystem è stato montato attivando il supporto delle quote, se si abilita il supporto in un -secondo tempo, si si sono eseguite delle operazioni sul filesystem quando era -disabilitato, i dati contenuti possono non corrispondere esattamente allo -stato corrente del consumo delle risorse. Per questo motivo prima di montare -in scrittura un filesystem su cui sono abilitate le quote viene richiesto di -utilizzare il comando \cmd{quotacheck} per verificare e aggiornare i dati. +secondo tempo e nel frattempo sono state eseguite delle operazioni sul +filesystem quando il supporto era disabilitato, i dati contenuti possono non +corrispondere esattamente allo stato corrente del consumo delle risorse. Per +questo motivo prima di montare in scrittura un filesystem su cui sono +abilitate le quote viene richiesto di utilizzare il comando \cmd{quotacheck} +per verificare e aggiornare i dati. Le restrizioni sul consumo delle risorse previste dal sistema delle quote prevedono sempre la presenza di due diversi limiti, il primo viene detto \textit{soft limit} e può essere superato per brevi periodi di tempo senza che -causare errori, il secondo viene detto \textit{hard limit} non può mai essere -superato. +causare errori per lo sforamento delle quote, il secondo viene detto +\textit{hard limit} e non può mai essere superato. Il periodo di tempo per cui è possibile eccedere rispetto alle restrizioni indicate dal \textit{soft limit} è detto ``\textsl{periodo di grazia}'' @@ -6049,7 +6079,7 @@ macro \macro{QCMD}: La macro consente di specificare, oltre al tipo di operazione, da indicare con l'argomento \param{subcmd} se questa deve applicarsi alle quote utente o alle quote gruppo. Questo viene indicato dall'argomento \param{type} che deve -essere sempre definito ed assegnato ad uno fra i due valori \const{USRQUOTA} e +essere sempre definito ed assegnato ad uno fra i due valori \const{USRQUOTA} o \const{GRPQUOTA}. \begin{table}[htb] @@ -6405,8 +6435,8 @@ suddividere i vari privilegi tradizionalmente associati all'amministratore in un insieme di \textsl{capacità} distinte. L'idea era che queste capacità potessero essere abilitate e disabilitate in maniera indipendente per ciascun processo con privilegi di amministratore, permettendo così una granularità -molto più fine nella distribuzione degli stessi che evitasse la originaria -situazione di ``\textsl{tutto o nulla}''. +molto più fine nella distribuzione degli stessi che evitasse la situazione +originaria di ``\textsl{tutto o nulla}''. \itindbeg{file~capabilities} @@ -6737,7 +6767,7 @@ non più modificabile \const{SECURE\_KEEP\_CAPS}, ed analogamente avviene con \const{SECURE\_NO\_SETUID\_FIXUP} e con \const{SECURE\_NOROOT\_LOCKED} per \const{SECURE\_NOROOT}. -Per l'impostazione di questi flag sono stata predisposte due specifiche +Per l'impostazione di questi flag sono state predisposte due specifiche operazioni di \func{prctl} (vedi sez.~\ref{sec:process_prctl}), \const{PR\_GET\_SECUREBITS}, che consente di ottenerne il valore, e \const{PR\_SET\_SECUREBITS}, che consente di modificarne il valore; per @@ -6933,12 +6963,12 @@ però dedicare un discorso a parte a \const{CAP\_SETPCAP}, il cui significato è stato completamente cambiato con l'introduzione delle \textit{file capabilities} nel kernel 2.6.24. In precedenza questa capacità era quella che permetteva al processo che la possedeva di impostare o rimuovere le -\textit{capabilities} che fossero presenti nel \textit{permitted set} del -chiamante di un qualunque altro processo. In realtà questo non è mai stato -l'uso inteso nelle bozze dallo standard POSIX, ed inoltre, come si è già -accennato, dato che questa capacità è assente nel \textit{capabilities - bounding set} usato di default, essa non è neanche mai stata realmente -disponibile. +\textit{capabilities} presenti nel suo \textit{permitted set} su un qualunque +altro processo. In realtà questo non è mai stato l'uso inteso nelle bozze +dallo standard POSIX, ed inoltre, come si è già accennato, dato che questa +capacità è sempre stata assente (a meno di specifiche ricompilazioni del +kernel) nel \textit{capabilities bounding set} usato di default, essa non è +neanche mai stata realmente disponibile. Con l'introduzione \itindex{file~capabilities} \textit{file capabilities} e il cambiamento del significato del \textit{capabilities bounding set} la @@ -7081,21 +7111,22 @@ modifiche o adeguamenti su qualunque versione del kernel è opportuno utilizzare le interfacce di alto livello che vedremo più avanti. La struttura a cui deve puntare l'argomento \param{hdrp} serve ad indicare, -tramite il campo \var{pid}, il PID del processo del quale si vogliono leggere -o modificare le \textit{capabilities}. Con \func{capset} questo, se si usano -le \itindex{file~capabilities} \textit{file capabilities}, può essere solo 0 o -PID del processo chiamante, che sono equivalenti. Non tratteremo, essendo -comunque di uso irrilevante, il caso in cui, in mancanza di tale supporto, la -funzione può essere usata per modificare le \textit{capabilities} di altri -processi, per il quale si rimanda alla pagina di manuale. +tramite il campo \var{pid}, il \ids{PID} del processo del quale si vogliono +leggere o modificare le \textit{capabilities}. Con \func{capset} questo, se si +usano le \itindex{file~capabilities} \textit{file capabilities}, può essere +solo 0 o il \ids{PID} del processo chiamante, che sono equivalenti. Non +tratteremo, essendo comunque di uso irrilevante, il caso in cui, in mancanza +di tale supporto, la funzione può essere usata per modificare le +\textit{capabilities} di altri processi, per il quale si rimanda, se +interessati, alla lettura della pagina di manuale. Il campo \var{version} deve essere impostato al valore della versione delle stesse usata dal kernel (quello indicato da una delle costanti \texttt{\_LINUX\_CAPABILITY\_VERSION\_n} di fig.~\ref{fig:cap_kernel_struct}) altrimenti le funzioni ritorneranno con un errore di \errcode{EINVAL}, restituendo nel campo stesso il valore corretto della versione in uso. La -versione due è comunque deprecata e non deve essere usata (il kernel stamperà -un avviso). +versione due è comunque deprecata e non deve essere usata, ed il kernel +stamperà un avviso se lo si fa. I valori delle \textit{capabilities} devono essere passati come maschere binarie;\footnote{e si tenga presente che i valori di @@ -7131,9 +7162,9 @@ opaco, \type{cap\_t}, come puntatore ai dati mantenuti nel cosiddetto In questo modo è possibile mascherare i dettagli della gestione di basso livello, che potranno essere modificati senza dover cambiare le funzioni -dell'interfaccia, che pertanto fanno riferimento soltanto ad oggetti di questo -tipo. L'interfaccia pertanto non soltanto fornisce le funzioni per modificare -e leggere le \textit{capabilities}, ma anche quelle per gestire i dati +dell'interfaccia, che fanno riferimento soltanto ad oggetti di questo tipo. +L'interfaccia pertanto non soltanto fornisce le funzioni per modificare e +leggere le \textit{capabilities}, ma anche quelle per gestire i dati attraverso i \textit{capability state}, che presentano notevoli affinità, essendo parte di bozze dello stesso standard, con quelle già viste per le ACL. @@ -7176,13 +7207,14 @@ funzione, \funcd{cap\_free}, il cui prototipo è: La funzione permette di liberare la memoria allocata dalle altre funzioni della libreria sia per un \textit{capability state}, nel qual caso l'argomento -dovrà essere un dato di tipo \type{cap\_t}, che per una descrizione testuale -dello stesso,\footnote{cioè quanto ottenuto tramite la funzione - \func{cap\_to\_text}.} nel qual caso l'argomento dovrà essere un dato di -tipo \texttt{char *}. Per questo motivo l'argomento \param{obj\_d} è -dichiarato come \texttt{void *} e deve sempre corrispondere ad un puntatore -ottenuto tramite le altre funzioni della libreria, altrimenti la funzione -fallirà con un errore di \errval{EINVAL}. +sarà un dato di tipo \type{cap\_t}, che per una descrizione testuale dello +stesso,\footnote{cioè quanto ottenuto tramite la funzione + \func{cap\_to\_text}.} nel qual caso l'argomento sarà un dato di tipo +\texttt{char *}. Per questo motivo l'argomento \param{obj\_d} è dichiarato +come \texttt{void *}, per evitare la necessità di eseguire un \textit{cast}, +ma dovrà comunque corrispondere ad un puntatore ottenuto tramite le altre +funzioni della libreria, altrimenti la funzione fallirà con un errore di +\errval{EINVAL}. Infine si può creare una copia di un \textit{capability state} ottenuto in precedenza tramite la funzione \funcd{cap\_dup}, il cui prototipo è: @@ -7204,9 +7236,8 @@ La funzione crea una copia del \textit{capability state} posto all'indirizzo copia, che conterrà gli stessi valori delle \textit{capabilities} presenti nell'originale. La memoria necessaria viene allocata automaticamente dalla funzione. Una volta effettuata la copia i due \textit{capability state} -potranno essere modificati in maniera completamente -indipendente.\footnote{alla fine delle operazioni si ricordi però di - disallocare anche la copia, oltre all'originale. } +potranno essere modificati in maniera completamente indipendente, ed alla fine +delle operazioni si dovrà disallocare anche la copia, oltre all'originale. Una seconda classe di funzioni di servizio previste dall'interfaccia sono quelle per la gestione dei dati contenuti all'interno di un \textit{capability @@ -7231,8 +7262,8 @@ creazione con \func{cap\_init}. Una variante di \func{cap\_clear} è \funcd{cap\_clear\_flag} che cancella da un \textit{capability state} tutte le \textit{capabilities} di un certo -insieme fra quelli di pag.~\pageref{sec:capabilities_set}, il suo prototipo -è: +insieme fra quelli elencati a pag.~\pageref{sec:capabilities_set}, il suo +prototipo è: \begin{funcproto}{ \fhead{sys/capability.h} @@ -7245,8 +7276,8 @@ insieme fra quelli di pag.~\pageref{sec:capabilities_set}, il suo prototipo } \end{funcproto} -La funzione richiede che si indichi quale degli insiemi si intente cancellar -ad \param{cap\_p} con l'argomento \param{flag}. Questo deve essere specificato +La funzione richiede che si indichi quale degli insiemi si intente cancellare +da \param{cap\_p} con l'argomento \param{flag}. Questo deve essere specificato con una variabile di tipo \type{cap\_flag\_t} che può assumere esclusivamente\footnote{si tratta in effetti di un tipo enumerato, come si può verificare dalla sua definizione che si trova in @@ -7328,7 +7359,7 @@ flag,\\ \fdesc{Imposta il valore di una \textit{capability}.} } -{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual +{Le funzioni ritornano $0$ in caso di successo e $-1$ per un errore, nel qual caso \var{errno} potrà assumere solo il valore \errval{EINVAL}. } \end{funcproto} @@ -7370,7 +7401,8 @@ tab.~\ref{tab:cap_value_type}. La funzione \func{cap\_get\_flag} legge lo stato della capacità indicata dall'argomento \param{cap} all'interno dell'insieme indicato dall'argomento -\param{flag} e lo restituisce nella variabile puntata +\param{flag} e lo restituisce come \itindex{value~result~argument} +\textit{value result argument} nella variabile puntata dall'argomento \param{value\_p}. Questa deve essere di tipo \type{cap\_flag\_value\_t} ed assumerà uno dei valori di tab.~\ref{tab:cap_value_type}. La funzione consente pertanto di leggere solo @@ -7394,7 +7426,7 @@ testuale, è \funcd{cap\_to\_text}, il cui prototipo è: \begin{funcproto}{ \fhead{sys/capability.h} -\fdecl{char * cap\_to\_text(cap\_t caps, ssize\_t * length\_p)} +\fdecl{char *cap\_to\_text(cap\_t caps, ssize\_t *length\_p)} \fdesc{Genera una visualizzazione testuale delle \textit{capabilities}.} } @@ -7407,7 +7439,8 @@ testuale, è \funcd{cap\_to\_text}, il cui prototipo è: La funzione ritorna l'indirizzo di una stringa contente la descrizione testuale del contenuto del \textit{capability state} \param{caps} passato come argomento, e, qualora l'argomento \param{length\_p} sia diverso da \val{NULL}, -restituisce nella variabile intera da questo puntata la lunghezza della +restituisce come \itindex{value~result~argument} \textit{value result + argument} nella variabile intera da questo puntata la lunghezza della stringa. La stringa restituita viene allocata automaticamente dalla funzione e pertanto dovrà essere liberata con \func{cap\_free}. @@ -7551,17 +7584,14 @@ prototipo\footnote{su alcune pagine di manuale la funzione è descritta con un } {La funzione ritorna un \textit{capability state} in caso di successo e - \val{NULL} per un errore, nel qual caso \var{errno} assumerà i valori: - - - \errval{ESRCH} o \errval{ENOMEM} nel loro significato generico. -} + \val{NULL} per un errore, nel qual caso \var{errno} assumerà i valori + \errval{ESRCH} o \errval{ENOMEM} nel loro significato generico. } \end{funcproto} La funzione legge il valore delle \textit{capabilities} del processo indicato con l'argomento \param{pid}, e restituisce il risultato tramite il puntatore -ad \textit{capability state} contenente tutti i dati che provvede ad allocare -autonomamente e che al solito deve essere disallocato con +ad un \textit{capability state} contenente tutti i dati che provvede ad +allocare autonomamente e che al solito deve essere disallocato con \func{cap\_free}. Qualora il processo indicato non esista si avrà un errore di \errval{ESRCH}. Gli stessi valori possono essere letti direttamente nel filesystem \textit{proc}, nei file \texttt{/proc//status}; ad esempio per @@ -7580,10 +7610,10 @@ CapEff: 00000000fffffeff \itindend{capability~state} -Infine per impostare le \textit{capabilities} del processo corrente (non -esiste una funzione che permetta di cambiare le \textit{capabilities} di un -altro processo) si deve usare la funzione \funcd{cap\_set\_proc}, il cui -prototipo è: +Infine per impostare le \textit{capabilities} del processo corrente (nella +bozza dello standard POSIX.1e non esiste una funzione che permetta di cambiare +le \textit{capabilities} di un altro processo) si deve usare la funzione +\funcd{cap\_set\_proc}, il cui prototipo è: \begin{funcproto}{ \fhead{sys/capability.h} @@ -7611,13 +7641,13 @@ funzione fallirà, e per quanto appena detto, lo stato delle \textit{capabilities} non verrà modificato (neanche per le parti eventualmente permesse). -Oltre a queste funzioni sono presenti due ulteriori funzioni, \funcm{capgetp} -e \funcm{capsetp}, che svolgono un compito analogo. Queste funzioni risalgono -alla implementazione iniziale delle \textit{capabilities} ed in particolare -\funcm{capsetp} consentiva anche di cambiare le capacità di un altro -processo. Le due funzioni oggi sono deprecate e pertanto eviteremo di -trattarle, per chi fosse interessato si rimanda alla lettura della loro pagina -di manuale. +Oltre a queste funzioni su Linux sono presenti due ulteriori funzioni, +\funcm{capgetp} e \funcm{capsetp}, che svolgono un compito analogo. Queste +funzioni risalgono alla implementazione iniziale delle \textit{capabilities} +ed in particolare \funcm{capsetp} consentirebbe anche, come possibile in quel +caso, di cambiare le capacità di un altro processo. Le due funzioni oggi sono +deprecate e pertanto eviteremo di trattarle, per chi fosse interessato si +rimanda alla lettura della loro pagina di manuale. Come esempio di utilizzo di queste funzioni nei sorgenti allegati alla guida si è distribuito il programma \texttt{getcap.c}, che consente di leggere le @@ -7625,7 +7655,7 @@ si è distribuito il programma \texttt{getcap.c}, che consente di leggere le quando lo si lancia, il che può sembrare inutile, ma serve a mostrarci quali sono le \textit{capabilities} standard che ottiene un processo lanciato dalla riga di comando.} o tramite l'opzione \texttt{-p}, quelle di un -processo qualunque il cui pid viene passato come parametro dell'opzione. +processo qualunque il cui \ids{PID} viene passato come parametro dell'opzione. \begin{figure}[!htbp] \footnotesize \centering @@ -7640,7 +7670,7 @@ processo qualunque il cui pid viene passato come parametro dell'opzione. La sezione principale del programma è riportata in fig.~\ref{fig:proc_getcap}, e si basa su una condizione sulla variabile \var{pid} che se si è usato l'opzione \texttt{-p} è impostata (nella sezione di gestione delle opzioni, -che si è tralasciata) al valore del \textsl{pid} del processo di cui si vuole +che si è tralasciata) al valore del \ids{PID} del processo di cui si vuole leggere le \textit{capabilities} e nulla altrimenti. Nel primo caso (\texttt{\small 1--6}) si utilizza (\texttt{\small 2}) \func{cap\_get\_proc} per ottenere lo stato delle capacità del processo, nel secondo (\texttt{\small @@ -7663,45 +7693,51 @@ funzione. \subsection{La gestione dei {chroot}} \label{sec:file_chroot} -% TODO introdurre nuova sezione sulle funzionalità di sicurezza avanzate, con -% dentro chroot SELinux e AppArmor, Tomoyo, Smack, cgroup o che altro ??? +% TODO: valutare se introdurre una nuova sezione sulle funzionalità di +% sicurezza avanzate, con dentro chroot SELinux e AppArmor, Tomoyo, Smack, +% cgroup o altro + +% TODO: trattare la funzione setns e i namespace file descriptors (vedi +% http://lwn.net/Articles/407495/) introdotti con il kernel 3.0 + +% TODO: spostare chroot e le funzioni affini relative ai container da qualche +% parte diversa se è il caso. -% inserire setns (introdotta con il 3.0, vedi http://lwn.net/Articles/407495/) -% e le funzionalità di isolamento dei container Benché non abbia niente a che fare con permessi, utenti e gruppi, la funzione \func{chroot} viene usata spesso per restringere le capacità di accesso di un programma ad una sezione limitata del filesystem, per cui ne parleremo in questa sezione. -% TODO riferimenti ai bind mount, link simbolici ecc. - Come accennato in sez.~\ref{sec:proc_fork} ogni processo oltre ad una \index{directory~di~lavoro} directory di lavoro, ha anche una directory \textsl{radice}\footnote{entrambe sono contenute in due campi (rispettivamente \var{pwd} e \var{root}) di \kstruct{fs\_struct}; vedi fig.~\ref{fig:proc_task_struct}.} che, pur essendo di norma corrispondente -alla radice dell'albero di file e directory come visto dal kernel (ed -illustrato in sez.~\ref{sec:file_pathname}), ha per il processo il significato -specifico di directory rispetto alla quale vengono risolti i +alla radice dell'albero dei file dell'intero sistema, ha per il processo il +significato specifico di directory rispetto alla quale vengono risolti i \itindsub{pathname}{assoluto}\textit{pathname} assoluti.\footnote{cioè quando un processo chiede la risoluzione di un \textit{pathname}, il kernel usa sempre questa directory come punto di partenza.} Il fatto che questo valore sia specificato per ogni processo apre allora la possibilità di modificare le -modalità di risoluzione dei \textit{pathname} assoluti da parte di un processo -cambiando questa directory, così come si fa coi -\itindsub{pathname}{relativo}\textit{pathname} relativi cambiando la +modalità di risoluzione dei \itindsub{pathname}{assoluto} \textit{pathname} +assoluti da parte di un processo cambiando questa directory, così come si fa +coi \itindsub{pathname}{relativo} \textit{pathname} relativi cambiando la \index{directory~di~lavoro} directory di lavoro. -Normalmente la directory radice di un processo coincide anche con la radice -del filesystem usata dal kernel, e dato che il suo valore viene ereditato dal -padre da ogni processo figlio, in generale i processi risolvono i -\itindsub{pathname}{assoluto} \textit{pathname} assoluti a partire sempre -dalla stessa directory, che corrisponde alla radice del sistema. +Normalmente la directory radice di un processo coincide con la radice generica +dell'albero dei file, che è la directory che viene montata direttamente dal +kernel all'avvio secondo quanto illustrato in sez.~\ref{sec:file_pathname}. +Questo avviene perché, come visto in sez.~\ref{cha:process_handling} la +directory radice di un processo viene ereditata dal padre attraverso una +\func{fork} e mantenuta attraverso una \func{exec}, e siccome tutti i processi +derivano da \cmd{init}, che ha come radice quella montata dal kernel, questa +verrà mantenuta. In certe situazioni però è utile poter impedire che un processo possa accedere -a tutto il filesystem; per far questo si può cambiare la sua directory radice -con la funzione di sistema \funcd{chroot}, il cui prototipo è: +a tutto l'albero dei file iniziale; per far questo si può cambiare la sua +directory radice con la funzione di sistema \funcd{chroot}, il cui prototipo +è: \begin{funcproto}{ \fhead{unistd.h} @@ -7723,49 +7759,51 @@ La funzione imposta la directory radice del processo a quella specificata da \param{path} (che ovviamente deve esistere) ed ogni \itindsub{pathname}{assoluto} \textit{pathname} assoluto usato dalle funzioni chiamate nel processo sarà risolto a partire da essa, rendendo impossibile -accedere alla parte di albero sovrastante. Si ha così quella che viene +accedere alla parte di albero sovrastante. Si ha così quella che viene chiamata una \textit{chroot jail}, in quanto il processo non può più accedere a file al di fuori della sezione di albero in cui è stato \textsl{imprigionato}. Solo un processo con i privilegi di amministratore può usare questa -funzione,\footnote{più precisamente la \itindex{capabilities} capacità - \const{CAP\_SYS\_CHROOT}.} e la nuova radice, per quanto detto in +funzione,\footnote{più precisamente se possiede la \itindex{capabilities} + capacità \const{CAP\_SYS\_CHROOT}.} e la nuova radice, per quanto detto in sez.~\ref{sec:proc_fork}, sarà ereditata da tutti i suoi processi figli. Si -tenga presente però che la funzione non cambia la directory di lavoro, che -potrebbe restare fuori dalla \textit{chroot jail}. - -Questo è il motivo per cui la funzione è efficace solo se dopo averla eseguita -si cedono i privilegi di amministratore. Infatti se per un qualche motivo il -processo resta con \index{directory~di~lavoro} la directory di lavoro fuori -dalla \textit{chroot jail}, potrà comunque accedere a tutto il resto del -filesystem usando \itindsub{pathname}{relativo} dei \textit{pathname} -relativi, i quali, partendo da una directory di lavoro fuori della -\textit{chroot jail}, potranno (con l'uso di ``\texttt{..}'') risalire fino -alla radice effettiva del filesystem. - -Ma se ad un processo restano i privilegi di amministratore esso potrà comunque -portare la sua \index{directory~di~lavoro} directory di lavoro fuori dalla -\textit{chroot jail} in cui si trova. Basta infatti creare una nuova -\textit{chroot jail} con l'uso di \func{chroot} su una qualunque directory -contenuta nell'attuale directory di lavoro. Per questo motivo l'uso di questa -funzione non ha molto senso quando un processo necessita dei privilegi di -amministratore per le sue normali operazioni. - -Un caso tipico di uso di \func{chroot} è quello di un server FTP anonimo, in -questo caso infatti si vuole che il server veda solo i file che deve -trasferire, per cui in genere si esegue una \func{chroot} sulla directory che -contiene i file. Si tenga presente però che in questo caso occorrerà -replicare all'interno della \textit{chroot jail} tutti i file (in genere -programmi e librerie) di cui il server potrebbe avere bisogno. - - - -% TODO: trattare la funzione setns e i namespace file descriptors (vedi -% http://lwn.net/Articles/407495/) introdotti con il kernel 3.0 +tenga presente però che la funzione non cambia la directory di lavoro del +processo, che potrebbe restare fuori dalla \textit{chroot jail}. + +Questo è il motivo per cui la funzione è efficace nel restringere un processo +ad un ramo di albero solo se dopo averla eseguita si cedono i privilegi di +amministratore. Infatti se per un qualunque motivo il processo resta con la +sua \index{directory~di~lavoro} directory di lavoro al di fuori dalla +\textit{chroot jail}, potrà accedere a tutto il resto del filesystem usando +\itindsub{pathname}{relativo} dei \textit{pathname} relativi, dato che in tal +caso è possibile, grazie all'uso di ``\texttt{..}'', risalire all'indietro +fino alla radice effettiva dell'albero dei file. + +Potrebbe sembrare che per risolvere il problema sia sufficiente ricordarsi di +eseguire preventivamente anche una \func{chdir} sulla directory su cui si +andrà ad eseguire \func{chroot}, così da assicurarsi che le directory di +lavoro sia all'interno della \textit{chroot jail}. Ma se ad un processo +restano i privilegi di amministratore esso potrà comunque portare la sua +\index{directory~di~lavoro} directory di lavoro fuori dalla \textit{chroot + jail} in cui si trova. Basterà infatti eseguire di nuovo \func{chroot} su +una qualunque directory contenuta nell'attuale directory di lavoro perché +quest'ultima risulti al di fuori della nuova \textit{chroot jail}. Per questo +motivo l'uso di questa funzione non ha molto senso quando un processo di cui +si vuole limitare l'accesso necessita comunque dei privilegi di amministratore +per le sue normali operazioni. + +Nonostante queste limitazioni la funzione risulta utile qualora la si possa +applicare correttamente cedendo completamente i privilegi di amministratore +una volta eseguita. Ed esempio caso tipico di uso di \func{chroot} è quello +di un server FTP anonimo in si vuole che il server veda solo i file che deve +trasferire. In tal caso si esegue una \func{chroot} sulla directory che +contiene i file, che il server dovrà in grado di leggere come utente +ordinario, e poi si cedono tutti i privilegi di amministratore. Si tenga +presente però che in casi come questo occorrerà fornire all'interno della +\textit{chroot jail} un accesso anche a tutti i file (in genere programmi e +librerie) di cui il server potrebbe avere bisogno. -% TODO: spostare chroot e le funzioni affini relative ai container da qualche -% parte diversa se è il caso. % LocalWords: sez like filesystem unlink MacOS Windows VMS inode kernel unistd % LocalWords: int const char oldpath newpath errno EXDEV EPERM st Smack SysV diff --git a/prochand.tex b/prochand.tex index b09fdfd..ad9f0b0 100644 --- a/prochand.tex +++ b/prochand.tex @@ -3917,10 +3917,10 @@ indicare la unità di esecuzione generica messa a disposizione del kernel che Oltre a questo la funzione consente, ad uso delle nuove funzionalità di virtualizzazione dei processi, di creare nuovi \textit{namespace} per una -serie di proprietà generali dei processi (come l'elenco dei PID, l'albero dei -file, i \itindex{mount~point} \textit{mount point}, la rete, ecc.), che -consentono di creare gruppi di processi che vivono in una sorta di spazio -separato dagli altri, che costituisce poi quello che viene chiamato un +serie di proprietà generali dei processi (come l'elenco dei \ids{PID}, +l'albero dei file, i \itindex{mount~point} \textit{mount point}, la rete, +ecc.), che consentono di creare gruppi di processi che vivono in una sorta di +spazio separato dagli altri, che costituisce poi quello che viene chiamato un \textit{container}. La \textit{system call} richiede soltanto due argomenti: il diff --git a/sources/cap_print.c b/sources/cap_print.c deleted file mode 100644 index 4e33061..0000000 --- a/sources/cap_print.c +++ /dev/null @@ -1,110 +0,0 @@ -/* cap_print.c - * - * Copyright (C) 2005 Simone Piccardi - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or (at - * your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ -/***************************************************************************** - * - * File cap_print.c: An example for capabilities print - * - * Author: S. Piccardi Dec. 2005 - * - *****************************************************************************/ -#include /* C standard library */ -#include /* standard I/O library */ -#include /* unix standard library */ -#include - -/* - * Program cap_print - * - * Use libcap2 functions and print results - */ -/* Help printing routine */ -void usage(void); - -int main(int argc, char *argv[]) -{ - /* - * Variables definition - */ - int i; - cap_t capstatus; - cap_flag_t capset=CAP_EFFECTIVE; - cap_flag_value_t capval; - cap_value_t capability; - char * buffer; - /* - * Input section: decode command line parameters - * Use getopt function - */ - opterr = 0; /* don't want writing to stderr */ - while ( (i = getopt(argc, argv, "hepi")) != -1) { - switch (i) { - /* - * Handling options - */ - case 'i': /* read inherited set */ - capset=CAP_INHERITABLE; - break; - case 'e': /* read effective set */ - capset=CAP_EFFECTIVE; - break; - case 'p': /* read permitted set */ - capset=CAP_PERMITTED; - break; - case 'h': /* help option */ - printf("Wrong -h option use\n"); - usage(); - return -1; - break; - case '?': /* unrecognized options */ - printf("Unrecognized options -%c\n",optopt); - usage(); - default: /* should not reached */ - usage(); - } - } - /* *********************************************************** - * - * Options processing completed - * - * Main code beginning - * - * ***********************************************************/ - if ((argc - optind) != 0) { - printf("Wrong number of arguments %d\n", argc - optind); - usage(); - } - if ( (capstatus = cap_get_proc()) == NULL) { - perror("Lettura delle capabilities fallita"); - } - if ( (buffer = cap_to_text(capstatus, NULL)) == NULL) { - perror("Cannot convert capability status:"); - } - printf("Capabilities:\n %s\n", buffer); - exit(0); -} -/* - * routine to print usage info and exit - */ -void usage(void) { - printf("Program mygethost: do an hostname resolution \n"); - printf("Usage:\n"); - printf(" mygethost [-h] hostname \n"); - printf(" -h print this help\n"); - exit(1); -} diff --git a/sources/mygetfacl.c b/sources/mygetfacl.c new file mode 100644 index 0000000..fc4ca8e --- /dev/null +++ b/sources/mygetfacl.c @@ -0,0 +1,117 @@ +/* mygetfacl.c + * + * Copyright (C) 2012 Simone Piccardi + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or (at + * your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/**************************************************************** + * + * Program mygetfacl.c: + * A simple program that get a file acl + * + * Author: Simone Piccardi + * Jan 2012 + * + ****************************************************************/ +/* + * Include needed headers + */ +#include /* primitive system data types */ +#include /* C standard library */ +#include /* unix standard library */ +#include /* standard I/O library */ +#include /* acl library (use -l acl) */ +#include /* acl library (use -l acl) */ + + +/* pass -D DEBUG to gcc to enable debug printing */ +#ifdef DEBUG +#define debug printf +#else +#define debug(fmt, arg...) +#endif /* DEBUG */ + +/* + * Program mygetfacl + */ +/* Help printing routine */ +void usage(void); + +int main(int argc, char *argv[]) +{ +/* + * Variables definition + */ + acl_t acl; + ssize_t size; + char * buffer; + int i; + /* + * Input section: decode command line parameters + * Use getopt function + */ + opterr = 0; /* don't want writing to stderr */ + while ( (i = getopt(argc, argv, "h")) != -1) { + switch (i) { + /* + * Handling options + */ + case 'h': /* help option */ + printf("Wrong -h option use\n"); + usage(); + return -1; + break; + case '?': /* unrecognized options */ + printf("Unrecognized options -%c\n",optopt); + usage(); + default: /* should not reached */ + usage(); + } + } + /* must have an argument */ + if ((argc - optind) != 1) { + printf("Wrong number of arguments %d\n", argc - optind); + usage(); + } + /* main body */ + errno = 0; + acl = acl_get_file(argv[1], ACL_TYPE_DEFAULT); + if (acl == NULL) { + printf("error on getting ACL for file %s\n", argv[1]); + perror(argv[1]); + return 1; + } + buffer = acl_to_text(acl, &size); + if (buffer == NULL) { + perror("cannot convert acl"); + return 1; + } + printf("ACL:%s\n", buffer); + acl_free(acl); + acl_free(buffer); + return 0; +} + + +/* + * routine to print usage info and exit + */ +void usage(void) { + printf("Program mymount: \n"); + printf("Usage:\n"); + printf("mygetfacl [-h] file\n"); + printf(" -h print this help\n"); + exit(1); +}